Initial commit: Debian Manager — управление Debian-серверами

- SSH/SFTP управление без агентов
- Пакеты (apt), Docker, файлы, systemd, ufw, cron
- Плейбуки, групповые операции, планировщик
- Бэкапы, отчёты, Portainer, Proxmox VE, Gitea Deploy
- Терминал, Telegram-уведомления, тёмная/светлая тема

app/core/agent.py

@@ -0,0 +1,217 @@
+"""Агент-режим: установка агента на сервер, WS-сервер, приём метрик."""
+from __future__ import annotations
+
+import asyncio
+import json
+import secrets
+import time
+from typing import Callable, Optional
+
+from app.core.ssh import SSHClient
+from app.db.database import get_session
+from app.db.models import MetricSnapshot, Server, Setting
+
+# последние метрики по server_id: {"cpu": .., "mem": .., "disk": .., "ts": ..}
+agent_metrics: dict[int, dict] = {}
+_http_server = None
+
+AGENT_VERSION = "0.1"
+
+AGENT_SCRIPT = r'''#!/usr/bin/env python3
+"""Debian Manager agent: метрики по WebSocket. Только stdlib."""
+import json, socket, ssl, sys, time, urllib.request, os
+try:
+    import psutil
+except ImportError:
+    psutil = None
+
+SERVER_WS = os.environ.get("DM_SERVER", "ws://127.0.0.1:9101")
+TOKEN = os.environ.get("DM_TOKEN", "")
+SERVER_ID = int(os.environ.get("DM_SERVER_ID", "0"))
+INTERVAL = float(os.environ.get("DM_INTERVAL", "5"))
+
+def metrics():
+    cpu = 0.0
+    if psutil:
+        cpu = psutil.cpu_percent(interval=None)
+        vm = psutil.virtual_memory()
+        mem_used, mem_total = vm.used // 1048576, vm.total // 1048576
+        du = psutil.disk_usage("/")
+        disk = du.percent
+    else:
+        with open("/proc/stat") as f:
+            parts = f.readline().split()
+            idle = int(parts[4]) + int(parts[5])
+            total = sum(int(x) for x in parts[1:8])
+            cpu = round((1 - idle / total) * 100, 1) if total else 0
+        with open("/proc/meminfo") as f:
+            mi = {}
+            for line in f:
+                k, v = line.split(":")
+                mi[k] = int(v.split()[0])
+            mem_total = mi["MemTotal"] // 1024
+            mem_used = (mi["MemTotal"] - mi.get("MemAvailable", mi["MemFree"])) // 1024
+        st = os.statvfs("/")
+        disk = round((st.f_blocks - st.f_bavail) * 100 / st.f_blocks, 1)
+    with open("/proc/loadavg") as f:
+        load = float(f.read().split()[0])
+    return {"cpu": cpu, "mem_used": mem_used, "mem_total": mem_total,
+            "mem_pct": round(mem_used * 100 / mem_total, 1) if mem_total else 0,
+            "disk": disk, "load": load, "ts": time.time()}
+
+def main():
+    # минимальный WebSocket-клиент на stdlib (только текстовые фреймы, без маскировки сложная;
+    # для простоты используем HTTP POST каждые INTERVAL сек — надёжнее и без библиотек)
+    url = SERVER_WS.replace("ws://", "http://").replace("wss://", "https://") + "/metrics"
+    while True:
+        try:
+            data = json.dumps({"server_id": SERVER_ID, "token": TOKEN,
+                               "metrics": metrics()}).encode()
+            req = urllib.request.Request(url, data=data,
+                                         headers={"Content-Type": "application/json"})
+            urllib.request.urlopen(req, timeout=10)
+        except Exception as e:
+            print("send error:", e, file=sys.stderr)
+        time.sleep(INTERVAL)
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def _get(key: str) -> str:
+    with get_session() as s:
+        row = s.get(Setting, key)
+        return row.value if row else ""
+
+
+def _set(key: str, value: str) -> None:
+    with get_session() as s:
+        row = s.get(Setting, key) or Setting(key=key)
+        row.value = value
+        s.add(row)
+        s.commit()
+
+
+def get_agent_port() -> int:
+    return int(_get("agent_port") or "9102")
+
+
+def get_or_create_token(server_id: int) -> str:
+    key = f"agent_token_{server_id}"
+    token = _get(key)
+    if not token:
+        token = secrets.token_hex(16)
+        _set(key, token)
+    return token
+
+
+async def install_agent(srv: Server, app_host: str, log=None) -> bool:
+    """Установить агента на сервер через SSH."""
+    def _log(m):
+        if log:
+            log(m)
+    token = get_or_create_token(srv.id)
+    port = get_agent_port()
+    env = (f"DM_SERVER=http://{app_host}:{port} DM_TOKEN={token} "
+           f"DM_SERVER_ID={srv.id} DM_INTERVAL=5")
+    script_b64 = __import__("base64").b64encode(AGENT_SCRIPT.encode()).decode()
+
+    unit = f"""[Unit]
+Description=Debian Manager Agent
+After=network.target
+
+[Service]
+Type=simple
+Environment="{env.replace('"', chr(92)+'"')}"
+ExecStart=/usr/bin/python3 /opt/dm-agent/agent.py
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+"""
+    unit_b64 = __import__("base64").b64encode(unit.encode()).decode()
+
+    async with SSHClient(srv) as c:
+        _log("создаю /opt/dm-agent")
+        await c.sudo("mkdir -p /opt/dm-agent")
+        _log("записываю agent.py")
+        await c.sudo(f"echo {script_b64} | base64 -d > /opt/dm-agent/agent.py")
+        await c.sudo(f"echo {unit_b64} | base64 -d > /etc/systemd/system/dm-agent.service")
+        _log("запускаю systemd unit")
+        r = await c.sudo("systemctl daemon-reload && systemctl enable --now dm-agent")
+        if not r.ok:
+            _log(f"ошибка: {r.stderr}")
+            return False
+        _log("агент установлен и запущен")
+        return True
+
+
+async def uninstall_agent(srv: Server, log=None) -> None:
+    def _log(m):
+        if log:
+            log(m)
+    async with SSHClient(srv) as c:
+        await c.sudo("systemctl disable --now dm-agent 2>/dev/null; "
+                     "rm -f /etc/systemd/system/dm-agent.service; "
+                     "rm -rf /opt/dm-agent; systemctl daemon-reload")
+    _set(f"agent_token_{srv.id}", "")
+    _log("агент удалён")
+
+
+async def agent_status(srv: Server) -> str:
+    async with SSHClient(srv) as c:
+        r = await c.sudo("systemctl is-active dm-agent 2>/dev/null")
+        return r.stdout.strip() or "не установлен"
+
+
+# ---------- HTTP-приёмник метрик ----------
+
+async def _metrics_handler(reader, writer):
+    try:
+        req = await reader.readuntil(b"\r\n\r\n")
+        head = req.decode(errors="replace")
+        length = 0
+        for line in head.splitlines():
+            if line.lower().startswith("content-length:"):
+                length = int(line.split(":", 1)[1].strip())
+        body = await reader.readexactly(length) if length else b"{}"
+        data = json.loads(body)
+        sid = int(data.get("server_id", 0))
+        if data.get("token") != _get(f"agent_token_{sid}"):
+            raise ValueError("bad token")
+        m = data.get("metrics", {})
+        agent_metrics[sid] = m
+        with get_session() as s:
+            s.add(MetricSnapshot(
+                server_id=sid,
+                cpu_percent=m.get("cpu", 0),
+                mem_percent=m.get("mem_pct", 0),
+                mem_used_mb=m.get("mem_used", 0),
+                mem_total_mb=m.get("mem_total", 0),
+                disk_percent=m.get("disk", 0),
+                load1=m.get("load", 0),
+            ))
+            s.commit()
+        resp = b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok"
+    except Exception:
+        resp = b"HTTP/1.1 400 Bad\r\nContent-Length: 0\r\n\r\n"
+    writer.write(resp)
+    await writer.drain()
+    try:
+        writer.close()
+    except Exception:
+        pass
+
+
+async def start(port: Optional[int] = None) -> None:
+    global _http_server
+    if _http_server:
+        return
+    port = port or get_agent_port()
+    _http_server = await asyncio.start_server(_metrics_handler, "0.0.0.0", port)
+
+
+def is_running() -> bool:
+    return _http_server is not None

app/core/backup.py

@@ -0,0 +1,98 @@
+"""Резервное копирование: tar на сервере → SFTP → локальный архив."""
+from __future__ import annotations
+
+import asyncio
+import shlex
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from sqlmodel import select
+
+from app.core import files as fcore
+from app.core.ssh import SSHClient
+from app.db.database import get_session
+from app.db.models import BackupRecord, Server
+
+BACKUP_DIR = Path.home() / ".debian-manager" / "backups"
+BACKUP_DIR.mkdir(parents=True, exist_ok=True)
+
+
+async def run_backup(srv: Server, paths: str, download: bool = True,
+                     log=None) -> BackupRecord:
+    """Создать tar.gz на сервере и скачать. log — callable(str)."""
+    def _log(line: str):
+        if log:
+            log(line)
+
+    with get_session() as s:
+        rec = BackupRecord(server_id=srv.id, paths=paths, status="pending")
+        s.add(rec)
+        s.commit()
+        s.refresh(rec)
+        rec_id = rec.id
+
+    def _set(**fields):
+        with get_session() as s:
+            r = s.get(BackupRecord, rec_id)
+            for k, v in fields.items():
+                setattr(r, k, v)
+            s.add(r)
+            s.commit()
+
+    try:
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        name = f"dm-backup-{srv.name}-{ts}.tar.gz"
+        remote = f"/tmp/{name}"
+        path_args = " ".join(shlex.quote(p) for p in paths.split())
+
+        async with SSHClient(srv) as c:
+            _log(f"tar -czf {remote} {path_args}")
+            r = await c.sudo(
+                f"tar -czf {remote} --ignore-failed-read {path_args} 2>&1", timeout=1800
+            )
+            if not r.ok and "tar:" not in (r.stdout + r.stderr)[:20]:
+                # tar возвращает 1 при --ignore-failed-read если часть файлов пропущена — ок
+                pass
+            r = await c.sudo(f"stat -c %s {remote}", timeout=30)
+            size = int(r.stdout.strip() or 0)
+            _log(f"архив на сервере: {size // 1024} КБ")
+            # дать доступ пользователю для SFTP
+            await c.sudo(f"chmod 644 {remote} && chown {srv.username}:{srv.username} {remote}")
+
+            local = ""
+            if download:
+                local_path = BACKUP_DIR / srv.name / name
+                local_path.parent.mkdir(parents=True, exist_ok=True)
+                _log(f"скачивание → {local_path}")
+                await fcore.download(c, remote, str(local_path),
+                                     lambda d, t: _log(f"  {d//1024}/{t//1024} КБ"))
+                local = str(local_path)
+                await c.run(f"rm -f {remote}")
+
+        _set(status="success", file=local, size=size, log="")
+        rec = get_record(rec_id)
+        return rec
+    except Exception as e:
+        _set(status="error", log=str(e))
+        return get_record(rec_id)
+
+
+def get_record(rec_id: int) -> BackupRecord:
+    with get_session() as s:
+        return s.get(BackupRecord, rec_id)
+
+
+def list_backups(server_id: Optional[int] = None, limit: int = 50) -> List[BackupRecord]:
+    with get_session() as s:
+        q = select(BackupRecord).order_by(BackupRecord.id.desc()).limit(limit)
+        if server_id:
+            q = q.where(BackupRecord.server_id == server_id)
+        return list(s.exec(q).all())
+
+
+def stats() -> tuple[int, int]:
+    """(кол-во, суммарный размер байт)"""
+    recs = list_backups(limit=1000)
+    ok = [r for r in recs if r.status == "success"]
+    return len(ok), sum(r.size for r in ok)

app/core/cron_svc.py

@@ -0,0 +1,126 @@
+"""Cron: чтение/запись crontab, версии, описание расписаний."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from croniter import croniter
+
+from app.core.ssh import SSHClient
+from app.db.database import get_session
+from app.db.models import CronBackup
+
+
+@dataclass
+class CronLine:
+    raw: str
+    enabled: bool
+    schedule: str
+    command: str
+    comment: str = ""
+
+    @property
+    def is_entry(self) -> bool:
+        return bool(self.schedule)
+
+
+def parse_crontab(content: str) -> List[CronLine]:
+    lines: List[CronLine] = []
+    for raw in content.splitlines():
+        stripped = raw.strip()
+        enabled = True
+        candidate = stripped
+        if not candidate:
+            lines.append(CronLine(raw, True, "", ""))
+            continue
+        if candidate.startswith("#"):
+            enabled = False
+            candidate = candidate.lstrip("#").strip()
+        parts = candidate.split(None, 5)
+        if candidate.startswith("@") and len(candidate.split(None, 1)) == 2:
+            sched, cmd = candidate.split(None, 1)
+            lines.append(CronLine(raw, enabled, sched, cmd))
+        elif len(parts) == 6 and _looks_like_schedule(parts[:5]):
+            lines.append(CronLine(raw, enabled, " ".join(parts[:5]), parts[5]))
+        else:
+            lines.append(CronLine(raw, enabled, "", "", comment=stripped))
+    return lines
+
+
+def _looks_like_schedule(fields: List[str]) -> bool:
+    for f in fields:
+        for ch in f:
+            if ch not in "0123456789*,-/":
+                return False
+    return True
+
+
+def humanize(schedule: str) -> str:
+    try:
+        if schedule.startswith("@"):
+            return {"@reboot": "при загрузке", "@daily": "ежедневно",
+                    "@hourly": "ежечасно", "@weekly": "еженедельно",
+                    "@monthly": "ежемесячно", "@yearly": "ежегодно"}.get(schedule, schedule)
+        it = croniter(schedule)
+        nxt = it.get_next(__import__("datetime").datetime)
+        return f"следующий запуск: {nxt:%Y-%m-%d %H:%M}"
+    except Exception:
+        return "неверное выражение"
+
+
+def render(lines: List[CronLine]) -> str:
+    out = []
+    for l in lines:
+        if not l.is_entry:
+            out.append(l.raw)
+            continue
+        entry = f"{l.schedule} {l.command}"
+        out.append(entry if l.enabled else f"# {entry}")
+    return "\n".join(out) + "\n"
+
+
+async def get_crontab(c: SSHClient, user: Optional[str] = None) -> str:
+    cmd = f"crontab -u {user} -l" if user else "crontab -l"
+    r = await c.sudo(cmd, timeout=30)
+    if not r.ok and "no crontab" in (r.stderr + r.stdout):
+        return ""
+    return r.stdout
+
+
+async def set_crontab(c: SSHClient, content: str, server_id: int,
+                      user: Optional[str] = None) -> None:
+    # бэкап текущего
+    current = await get_crontab(c, user)
+    with get_session() as s:
+        s.add(CronBackup(server_id=server_id, user=user or "current", content=current))
+        s.commit()
+    import base64
+    b64 = base64.b64encode(content.encode()).decode()
+    target = f"crontab -u {user} -" if user else "crontab -"
+    r = await c.sudo(f"echo {b64} | base64 -d | {target}", timeout=30)
+    if not r.ok:
+        raise RuntimeError(r.stderr)
+
+
+async def list_cron_files(c: SSHClient) -> dict:
+    """Системные cron-файлы: /etc/crontab + /etc/cron.d/*"""
+    out = {}
+    r = await c.sudo("cat /etc/crontab 2>/dev/null", timeout=30)
+    if r.ok:
+        out["/etc/crontab"] = r.stdout
+    r = await c.sudo("ls /etc/cron.d/ 2>/dev/null", timeout=30)
+    for name in r.stdout.split():
+        rr = await c.sudo(f"cat '/etc/cron.d/{name}'", timeout=30)
+        if rr.ok:
+            out[f"/etc/cron.d/{name}"] = rr.stdout
+    return out
+
+
+def backups(server_id: int, user: str, limit: int = 10) -> List[CronBackup]:
+    from sqlmodel import select
+    with get_session() as s:
+        return list(s.exec(
+            select(CronBackup)
+            .where(CronBackup.server_id == server_id, CronBackup.user == user)
+            .order_by(CronBackup.id.desc()).limit(limit)
+        ).all())

app/core/diff.py

@@ -0,0 +1,43 @@
+"""Diff пакетов между серверами."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List
+
+from app.core.packages import Package, list_packages
+from app.core.ssh import SSHClient
+
+
+@dataclass
+class VersionDiff:
+    name: str
+    version_a: str
+    version_b: str
+
+
+@dataclass
+class PackageDiff:
+    only_a: List[Package]
+    only_b: List[Package]
+    version_mismatch: List[VersionDiff]
+
+
+async def diff_servers(ca: SSHClient, cb: SSHClient,
+                       user_only: bool = True) -> PackageDiff:
+    pa = await list_packages(ca)
+    pb = await list_packages(cb)
+    if user_only:
+        pa = [p for p in pa if not p.is_system and p.manual]
+        pb = [p for p in pb if not p.is_system and p.manual]
+
+    map_a: Dict[str, Package] = {p.name: p for p in pa}
+    map_b: Dict[str, Package] = {p.name: p for p in pb}
+
+    only_a = [map_a[n] for n in sorted(map_a.keys() - map_b.keys())]
+    only_b = [map_b[n] for n in sorted(map_b.keys() - map_a.keys())]
+    mismatch = [
+        VersionDiff(n, map_a[n].version, map_b[n].version)
+        for n in sorted(map_a.keys() & map_b.keys())
+        if map_a[n].version != map_b[n].version
+    ]
+    return PackageDiff(only_a, only_b, mismatch)

app/core/docker_svc.py

@@ -0,0 +1,109 @@
+"""Docker по SSH: команды docker с JSON-выводом. Не требует docker CLI на клиенте."""
+from __future__ import annotations
+
+import json
+from typing import List, Optional
+
+from app.core.ssh import SSHClient
+
+
+async def _docker(c: SSHClient, args: str, timeout: int = 120) -> str:
+    r = await c.sudo(f"docker {args}", timeout=timeout)
+    return r.stdout
+
+
+async def available(c: SSHClient) -> bool:
+    r = await c.sudo("docker version --format '{{.Server.Version}}'", timeout=30)
+    return r.ok and bool(r.stdout.strip())
+
+
+async def server_version(c: SSHClient) -> str:
+    r = await c.sudo("docker version --format '{{.Server.Version}}'", timeout=30)
+    return r.stdout.strip()
+
+
+# ---------- контейнеры ----------
+
+async def list_containers(c: SSHClient) -> List[dict]:
+    out = await _docker(c, "ps -a --format '{{json .}}'")
+    return [json.loads(l) for l in out.splitlines() if l.strip()]
+
+
+async def container_action(c: SSHClient, cid: str, action: str) -> str:
+    assert action in ("start", "stop", "restart", "kill", "rm")
+    return await _docker(c, f"{action} {cid}")
+
+
+async def container_logs(c: SSHClient, cid: str, tail: int = 200) -> str:
+    return await _docker(c, f"logs --tail {tail} {cid}")
+
+
+async def container_inspect(c: SSHClient, cid: str) -> dict:
+    out = await _docker(c, f"inspect {cid}")
+    data = json.loads(out)
+    return data[0] if data else {}
+
+
+async def container_stats(c: SSHClient) -> List[dict]:
+    out = await _docker(
+        c, "stats --no-stream --format '{{json .}}'", timeout=60
+    )
+    return [json.loads(l) for l in out.splitlines() if l.strip()]
+
+
+# ---------- образы ----------
+
+async def list_images(c: SSHClient) -> List[dict]:
+    out = await _docker(c, "images --format '{{json .}}'")
+    return [json.loads(l) for l in out.splitlines() if l.strip()]
+
+
+async def pull(c: SSHClient, image: str):
+    return c.run_stream(f"docker pull {image}", use_sudo=True)
+
+
+async def remove_image(c: SSHClient, image: str) -> str:
+    return await _docker(c, f"rmi {image}")
+
+
+# ---------- тома ----------
+
+async def list_volumes(c: SSHClient) -> List[dict]:
+    out = await _docker(c, "volume ls --format '{{json .}}'")
+    return [json.loads(l) for l in out.splitlines() if l.strip()]
+
+
+async def remove_volume(c: SSHClient, name: str) -> str:
+    return await _docker(c, f"volume rm {name}")
+
+
+# ---------- сети ----------
+
+async def list_networks(c: SSHClient) -> List[dict]:
+    out = await _docker(c, "network ls --format '{{json .}}'")
+    return [json.loads(l) for l in out.splitlines() if l.strip()]
+
+
+# ---------- система ----------
+
+async def system_df(c: SSHClient) -> str:
+    return await _docker(c, "system df")
+
+
+async def system_prune(c: SSHClient) -> str:
+    return await _docker(c, "system prune -f", timeout=600)
+
+
+# ---------- compose ----------
+
+async def compose_projects(c: SSHClient) -> List[dict]:
+    out = await _docker(c, "compose ls --format json")
+    try:
+        return json.loads(out)
+    except json.JSONDecodeError:
+        return []
+
+
+async def compose_action(c: SSHClient, workdir: str, action: str, timeout: int = 600) -> str:
+    assert action in ("up -d", "down", "restart", "pull", "ps", "logs")
+    return await _docker(c, f"compose -f {workdir}/docker-compose.yml {action}", timeout)

app/core/files.py

@@ -0,0 +1,123 @@
+"""SFTP файловый менеджер."""
+from __future__ import annotations
+
+import stat
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+from typing import Callable, List, Optional
+
+import asyncssh
+
+from app.core.ssh import SSHClient
+
+
+@dataclass
+class FileEntry:
+    name: str
+    path: str
+    is_dir: bool
+    size: int
+    mtime: float
+    permissions: str
+
+
+def _fmt_perms(mode: int) -> str:
+    return stat.filemode(mode) if mode else "?"
+
+
+async def list_dir(c: SSHClient, path: str) -> List[FileEntry]:
+    async with c.conn.start_sftp_client() as sftp:
+        entries = []
+        try:
+            attrs = await sftp.readdir(path)
+        except asyncssh.SFTPFailure as e:
+            raise PermissionError(str(e))
+        for a in attrs:
+            if a.filename in (".", ".."):
+                continue
+            full = str(PurePosixPath(path) / a.filename)
+            is_dir = stat.S_ISDIR(a.attrs.permissions or 0)
+            entries.append(
+                FileEntry(
+                    name=a.filename,
+                    path=full,
+                    is_dir=is_dir,
+                    size=a.attrs.size or 0,
+                    mtime=a.attrs.mtime or 0,
+                    permissions=_fmt_perms(a.attrs.permissions or 0),
+                )
+            )
+        entries.sort(key=lambda e: (not e.is_dir, e.name.lower()))
+        return entries
+
+
+async def download(c: SSHClient, remote: str, local: str,
+                   progress: Optional[Callable[[int, int], None]] = None) -> None:
+    async with c.conn.start_sftp_client() as sftp:
+        size = (await sftp.stat(remote)).size or 0
+        done = 0
+        async with sftp.open(remote, "rb") as rf, open(local, "wb") as lf:
+            while True:
+                chunk = await rf.read(65536)
+                if not chunk:
+                    break
+                lf.write(chunk)
+                done += len(chunk)
+                if progress:
+                    progress(done, size)
+
+
+async def upload(c: SSHClient, local: str, remote: str,
+                 progress: Optional[Callable[[int, int], None]] = None) -> None:
+    import os
+    size = os.path.getsize(local)
+    done = 0
+    async with c.conn.start_sftp_client() as sftp:
+        async with sftp.open(remote, "wb") as rf, open(local, "rb") as lf:
+            while True:
+                chunk = lf.read(65536)
+                if not chunk:
+                    break
+                await rf.write(chunk)
+                done += len(chunk)
+                if progress:
+                    progress(done, size)
+
+
+async def delete(c: SSHClient, path: str, is_dir: bool) -> None:
+    async with c.conn.start_sftp_client() as sftp:
+        if is_dir:
+            await c.run(f"rm -rf {path!r}")
+        else:
+            await sftp.remove(path)
+
+
+async def mkdir(c: SSHClient, path: str) -> None:
+    async with c.conn.start_sftp_client() as sftp:
+        await sftp.makedirs(path, exist_ok=True)
+
+
+async def rename(c: SSHClient, old: str, new: str) -> None:
+    async with c.conn.start_sftp_client() as sftp:
+        await sftp.rename(old, new)
+
+
+async def read_text(c: SSHClient, path: str, limit: int = 500_000) -> str:
+    async with c.conn.start_sftp_client() as sftp:
+        async with sftp.open(path, "rb") as f:
+            data = await f.read(limit)
+        return data.decode("utf-8", errors="replace")
+
+
+async def write_text(c: SSHClient, path: str, content: str, use_sudo: bool = False) -> None:
+    if use_sudo:
+        # запись в root-owned файл через sudo tee
+        import base64
+        b64 = base64.b64encode(content.encode()).decode()
+        r = await c.sudo(f"echo {b64} | base64 -d > {path!r}")
+        if not r.ok:
+            raise PermissionError(r.stderr)
+    else:
+        async with c.conn.start_sftp_client() as sftp:
+            async with sftp.open(path, "wb") as f:
+                await f.write(content.encode())

app/core/firewall.py

@@ -0,0 +1,98 @@
+"""UFW файрвол."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from app.core.ssh import SSHClient
+
+
+@dataclass
+class Rule:
+    number: int
+    to: str
+    action: str
+    from_: str
+    raw: str
+
+
+async def is_installed(c: SSHClient) -> bool:
+    r = await c.run("which ufw")
+    return r.ok and bool(r.stdout.strip())
+
+
+async def status(c: SSHClient) -> tuple[bool, str]:
+    """(active, raw_status)"""
+    r = await c.sudo("ufw status verbose", timeout=30)
+    active = "Status: active" in r.stdout
+    return active, r.stdout
+
+
+async def list_rules(c: SSHClient) -> List[Rule]:
+    r = await c.sudo("ufw status numbered", timeout=30)
+    rules: List[Rule] = []
+    for line in r.stdout.splitlines():
+        line = line.strip()
+        if line.startswith("[") and "]" in line:
+            num = int(line[1:line.index("]")].strip())
+            rest = line[line.index("]") + 1:].strip()
+            parts = rest.split()
+            # "22/tcp ALLOW IN Anywhere"
+            to = parts[0] if parts else ""
+            action = " ".join(parts[1:3]) if len(parts) > 2 else (parts[1] if len(parts) > 1 else "")
+            from_ = " ".join(parts[3:]) if len(parts) > 3 else ""
+            rules.append(Rule(num, to, action, from_, line))
+    return rules
+
+
+async def ensure_ssh_allowed(c: SSHClient, ssh_port: int) -> None:
+    """Защита от отстрела себя: разрешить текущий SSH-порт."""
+    rules = await list_rules(c)
+    for rule in rules:
+        if str(ssh_port) in rule.to and "ALLOW" in rule.action.upper():
+            return
+    await c.sudo(f"ufw allow {ssh_port}/tcp", timeout=30)
+
+
+async def enable(c: SSHClient, ssh_port: int) -> str:
+    await ensure_ssh_allowed(c, ssh_port)
+    r = await c.sudo("yes | ufw enable", timeout=30)
+    return r.stdout + r.stderr
+
+
+async def disable(c: SSHClient) -> str:
+    r = await c.sudo("ufw disable", timeout=30)
+    return r.stdout + r.stderr
+
+
+async def add_rule(c: SSHClient, port: str, action: str = "allow",
+                   proto: str = "tcp", from_addr: str = "") -> str:
+    assert action in ("allow", "deny", "limit", "reject")
+    src = f"from {from_addr} " if from_addr else ""
+    r = await c.sudo(f"ufw {action} {src}to any port {port} proto {proto}", timeout=30)
+    return r.stdout + r.stderr
+
+
+async def delete_rule(c: SSHClient, number: int) -> str:
+    r = await c.sudo(f"yes | ufw delete {number}", timeout=30)
+    return r.stdout + r.stderr
+
+
+async def listening_ports(c: SSHClient) -> List[str]:
+    r = await c.sudo("ss -tlnp | awk 'NR>1{print $4, $6}'", timeout=30)
+    return [l for l in r.stdout.splitlines() if l.strip()]
+
+
+PRESETS = {
+    "Только SSH": [("{ssh_port}", "allow", "tcp")],
+    "Веб-сервер": [("{ssh_port}", "allow", "tcp"), ("80", "allow", "tcp"), ("443", "allow", "tcp")],
+    "Docker-хост": [("{ssh_port}", "allow", "tcp"), ("2375", "deny", "tcp"), ("2376", "deny", "tcp")],
+}
+
+
+async def apply_preset(c: SSHClient, preset_name: str, ssh_port: int) -> str:
+    log = []
+    for port, action, proto in PRESETS[preset_name]:
+        p = port.format(ssh_port=ssh_port)
+        log.append(await add_rule(c, p, action, proto))
+    return "\n".join(log)

app/core/gitea.py

@@ -0,0 +1,110 @@
+"""Gitea: репозитории, raw-файлы, деплой compose на сервер."""
+from __future__ import annotations
+
+from typing import List, Optional
+
+import httpx
+
+from app.core.ssh import SSHClient
+from app.db.database import get_session
+from app.db.models import Setting
+
+DEFAULT_URL = "http://192.168.1.171:3000"
+
+
+def _get(key: str) -> str:
+    with get_session() as s:
+        row = s.get(Setting, key)
+        return row.value if row else ""
+
+
+def _set(key: str, value: str) -> None:
+    with get_session() as s:
+        row = s.get(Setting, key) or Setting(key=key)
+        row.value = value
+        s.add(row)
+        s.commit()
+
+
+def get_config() -> dict:
+    return {"url": _get("gitea_url") or DEFAULT_URL, "token": _get("gitea_token")}
+
+
+def save_config(url: str, token: str) -> None:
+    _set("gitea_url", url.rstrip("/"))
+    _set("gitea_token", token)
+
+
+async def _client() -> httpx.AsyncClient:
+    cfg = get_config()
+    headers = {"Authorization": f"token {cfg['token']}"} if cfg["token"] else {}
+    return httpx.AsyncClient(base_url=cfg["url"], headers=headers, timeout=20)
+
+
+async def list_repos() -> List[dict]:
+    async with await _client() as cl:
+        r = await cl.get("/api/v1/user/repos", params={"limit": 50})
+        r.raise_for_status()
+        return [{"name": x["name"], "full_name": x["full_name"],
+                 "clone_url": x["clone_url"], "default_branch": x["default_branch"]}
+                for x in r.json()]
+
+
+async def get_file(repo: str, path: str, ref: str = "main") -> str:
+    async with await _client() as cl:
+        r = await cl.get(f"/api/v1/repos/{repo}/raw/{path}", params={"ref": ref})
+        r.raise_for_status()
+        return r.text
+
+
+async def test_connection() -> tuple[bool, str]:
+    try:
+        async with await _client() as cl:
+            r = await cl.get("/api/v1/version")
+            if r.status_code == 200:
+                return True, f"Gitea {r.json().get('version')}"
+            return False, f"HTTP {r.status_code}"
+    except Exception as e:
+        return False, str(e)
+
+
+# ---------- деплой compose ----------
+
+async def deploy(c: SSHClient, clone_url: str, repo_name: str, branch: str,
+                 compose_path: str, env_content: Optional[str], log) -> None:
+    """git clone/pull в /opt/stacks/<repo> + docker compose up -d."""
+    base = "/opt/stacks"
+    workdir = f"{base}/{repo_name}"
+    await c.sudo(f"mkdir -p {base}")
+
+    r = await c.sudo(f"test -d {workdir}/.git && echo exists || echo missing")
+    if "exists" in r.stdout:
+        log(f"git pull в {workdir}")
+        r = await c.sudo(f"git -C {workdir} fetch --all && git -C {workdir} checkout {branch} "
+                         f"&& git -C {workdir} pull origin {branch}", timeout=300)
+    else:
+        log(f"git clone {clone_url} → {workdir}")
+        url = clone_url
+        r = await c.sudo(f"git clone -b {branch} {url} {workdir}", timeout=300)
+    log(r.stdout[-1000:] + r.stderr[-500:])
+    if not r.ok:
+        raise RuntimeError("git операция не удалась")
+
+    if env_content is not None:
+        import base64
+        b64 = base64.b64encode(env_content.encode()).decode()
+        await c.sudo(f"echo {b64} | base64 -d > {workdir}/.env")
+        log(".env записан")
+
+    log("docker compose up -d")
+    r = await c.sudo(f"docker compose -f {workdir}/{compose_path} up -d", timeout=900)
+    log(r.stdout + r.stderr)
+    if not r.ok:
+        raise RuntimeError("compose up не удался")
+
+
+async def stack_action(c: SSHClient, repo_name: str, compose_path: str, action: str) -> str:
+    assert action in ("up -d", "down", "restart", "pull", "logs --tail 100", "ps")
+    r = await c.sudo(f"docker compose -f /opt/stacks/{repo_name}/{compose_path} {action}",
+                     timeout=600)
+    return r.stdout + r.stderr

app/core/group_ops.py

@@ -0,0 +1,143 @@
+"""Групповые операции по нескольким серверам с rolling-режимом."""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Callable, Coroutine, Dict, List, Optional
+
+from app.core.ssh import SSHClient, check_server, wait_online
+from app.db.models import Server
+
+LogCallback = Callable[[str], None]
+
+
+@dataclass
+class ServerResult:
+    server_id: int
+    name: str
+    status: str = "pending"   # pending/running/success/error
+    log: str = ""
+
+
+@dataclass
+class GroupResult:
+    results: Dict[int, ServerResult] = field(default_factory=dict)
+
+    @property
+    def ok_count(self) -> int:
+        return sum(1 for r in self.results.values() if r.status == "success")
+
+    @property
+    def err_count(self) -> int:
+        return sum(1 for r in self.results.values() if r.status == "error")
+
+
+async def run_group(
+    servers: List[Server],
+    operation: Callable[[SSHClient, Server, LogCallback], Coroutine],
+    concurrency: int = 5,
+    fail_fast: bool = False,
+    rolling: bool = False,
+    on_status: Optional[Callable[[GroupResult], None]] = None,
+) -> GroupResult:
+    """Выполнить operation(c, server, log) на группе серверов."""
+    result = GroupResult(results={
+        s.id: ServerResult(server_id=s.id, name=s.name) for s in servers
+    })
+    sem = asyncio.Semaphore(1 if rolling else concurrency)
+    stop_flag = asyncio.Event()
+
+    async def worker(srv: Server):
+        if stop_flag.is_set():
+            result.results[srv.id].status = "error"
+            result.results[srv.id].log = "пропущено (fail-fast)"
+            return
+        async with sem:
+            r = result.results[srv.id]
+            r.status = "running"
+            if on_status:
+                on_status(result)
+
+            def log(line: str) -> None:
+                r.log += line + "\n"
+                if on_status:
+                    on_status(result)
+
+            try:
+                async with SSHClient(srv) as c:
+                    await operation(c, srv, log)
+                r.status = "success"
+            except Exception as e:
+                r.status = "error"
+                r.log += f"[ОШИБКА] {e}\n"
+                if fail_fast:
+                    stop_flag.set()
+            if on_status:
+                on_status(result)
+
+    if rolling:
+        for srv in servers:
+            await worker(srv)
+            if stop_flag.is_set():
+                break
+    else:
+        await asyncio.gather(*(worker(s) for s in servers))
+    return result
+
+
+# ---------- готовые операции ----------
+
+def op_apt_update():
+    async def op(c: SSHClient, srv: Server, log: LogCallback):
+        log("$ apt-get update")
+        r = await c.sudo("DEBIAN_FRONTEND=noninteractive apt-get update", timeout=600)
+        log(r.stdout[-2000:] or "(пустой вывод)")
+        if not r.ok:
+            raise RuntimeError(r.stderr[-500:])
+    return op
+
+
+def op_upgrade(dist: bool = False):
+    async def op(c: SSHClient, srv: Server, log: LogCallback):
+        kind = "dist-upgrade" if dist else "upgrade"
+        log(f"$ apt-get {kind} -y")
+        async for line in c.run_stream(
+            f"DEBIAN_FRONTEND=noninteractive apt-get {kind} -y", use_sudo=True
+        ):
+            log(line)
+    return op
+
+
+def op_reboot(wait: bool = True):
+    async def op(c: SSHClient, srv: Server, log: LogCallback):
+        log("$ reboot")
+        await c.sudo("(sleep 1; reboot) &", timeout=10)
+        if wait:
+            log("ожидание возврата сервера...")
+            await asyncio.sleep(10)
+            ok = await wait_online(srv, timeout_s=300)
+            if not ok:
+                raise RuntimeError("сервер не вернулся за 5 минут")
+            log("сервер снова онлайн")
+    return op
+
+
+def op_install_package(names: List[str]):
+    async def op(c: SSHClient, srv: Server, log: LogCallback):
+        log(f"$ apt-get install -y {' '.join(names)}")
+        async for line in c.run_stream(
+            "DEBIAN_FRONTEND=noninteractive apt-get install -y " + " ".join(names),
+            use_sudo=True,
+        ):
+            log(line)
+    return op
+
+
+def op_shell(cmd: str):
+    async def op(c: SSHClient, srv: Server, log: LogCallback):
+        log(f"$ {cmd}")
+        r = await c.sudo(cmd, timeout=600)
+        log(r.stdout[-3000:])
+        if not r.ok:
+            raise RuntimeError(r.stderr[-500:] or f"rc={r.returncode}")
+    return op

app/core/monitor.py

@@ -0,0 +1,94 @@
+"""Мониторинг: сбор метрик по SSH, снапшоты в БД."""
+from __future__ import annotations
+
+from typing import Optional
+
+from sqlmodel import select
+
+from app.core.ssh import SSHClient
+from app.db.database import get_session
+from app.db.models import MetricSnapshot
+
+# Каждая команда выводит одну строку "KEY value..."; парсер ниже.
+# CPU считаем по дельте двух замеров /proc/stat за 1 секунду.
+_METRICS_CMD = (
+    # CPU: первая строка cpu в /proc/stat (user nice system idle iowait irq softirq steal)
+    "read cpu u n s idle iow irq sirq st rest < /proc/stat; "
+    "t1=$((u+n+s+idle+iow+irq+sirq+st)); i1=$((idle+iow)); "
+    "sleep 1; "
+    "read cpu u n s idle iow irq sirq st rest < /proc/stat; "
+    "t2=$((u+n+s+idle+iow+irq+sirq+st)); i2=$((idle+iow)); "
+    "dt=$((t2-t1)); di=$((i2-i1)); "
+    "if [ $dt -gt 0 ]; then awk -v a=$dt -v b=$di 'BEGIN{printf \"CPU %.1f\\n\", (a-b)*100/a}'; else echo 'CPU 0.0'; fi; "
+    # RAM: used/total в МБ
+    "free -m | awk 'NR==2{printf \"MEM %d %d\\n\", $3, $2}'; "
+    # Диск: процент занятого на /
+    "df -m / | awk 'NR==2{printf \"DISK %.1f\\n\", $3*100/$2}'; "
+    # Load average 1min
+    "awk '{printf \"LOAD %s\\n\", $1}' /proc/loadavg; "
+    # Сеть: суммарные байты rx/tx всех интерфейсов
+    "awk '/: /{rx+=$2; tx+=$10} END{printf \"NET %d %d\\n\", rx, tx}' /proc/net/dev"
+)
+
+
+async def collect(c: SSHClient, server_id: int, prev_net: Optional[tuple] = None) -> MetricSnapshot:
+    r = await c.run(_METRICS_CMD, timeout=30)
+    cpu = mem_used = mem_total = disk = load = 0.0
+    rx = tx = 0
+    for line in r.stdout.splitlines():
+        p = line.split()
+        if len(p) < 2:
+            continue
+        if p[0] == "CPU":
+            cpu = float(p[1])
+        elif p[0] == "MEM":
+            mem_used, mem_total = int(p[1]), int(p[2])
+        elif p[0] == "DISK":
+            disk = float(p[1])
+        elif p[0] == "LOAD":
+            load = float(p[1])
+        elif p[0] == "NET":
+            rx, tx = int(p[1]), int(p[2])
+
+    rx_kbs = tx_kbs = 0.0
+    if prev_net:
+        dt = 60.0  # интервал опроса
+        rx_kbs = max(0.0, (rx - prev_net[0]) / 1024 / dt)
+        tx_kbs = max(0.0, (tx - prev_net[1]) / 1024 / dt)
+
+    snap = MetricSnapshot(
+        server_id=server_id,
+        cpu_percent=round(cpu, 1),
+        mem_percent=round(mem_used * 100 / mem_total, 1) if mem_total else 0,
+        mem_used_mb=mem_used,
+        mem_total_mb=mem_total,
+        disk_percent=disk,
+        load1=load,
+        net_rx_kbs=round(rx_kbs, 1),
+        net_tx_kbs=round(tx_kbs, 1),
+    )
+    with get_session() as s:
+        s.add(snap)
+        s.commit()
+    return snap
+
+
+def latest(server_id: int) -> Optional[MetricSnapshot]:
+    with get_session() as s:
+        return s.exec(
+            select(MetricSnapshot)
+            .where(MetricSnapshot.server_id == server_id)
+            .order_by(MetricSnapshot.id.desc())
+            .limit(1)
+        ).first()
+
+
+def history(server_id: int, limit: int = 60) -> list[MetricSnapshot]:
+    with get_session() as s:
+        rows = s.exec(
+            select(MetricSnapshot)
+            .where(MetricSnapshot.server_id == server_id)
+            .order_by(MetricSnapshot.id.desc())
+            .limit(limit)
+        ).all()
+        return list(reversed(rows))

app/core/notify.py

@@ -0,0 +1,91 @@
+"""Telegram-уведомления с антиспамом."""
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+import httpx
+
+from app.db.database import get_session
+from app.db.models import Setting
+
+_antispam: dict[str, float] = {}
+THROTTLE_S = 600  # не чаще 1 раза в 10 мин на ключ
+
+
+def _get(key: str) -> str:
+    with get_session() as s:
+        row = s.get(Setting, key)
+        return row.value if row else ""
+
+
+def _set(key: str, value: str) -> None:
+    with get_session() as s:
+        row = s.get(Setting, key) or Setting(key=key)
+        row.value = value
+        s.add(row)
+        s.commit()
+
+
+def get_config() -> dict:
+    return {
+        "token": _get("tg_token"),
+        "chat_id": _get("tg_chat_id"),
+        "enabled": _get("tg_enabled") == "1",
+        "on_alert": _get("tg_on_alert") == "1",
+        "on_task_done": _get("tg_on_task_done") == "1",
+    }
+
+
+def save_config(token: str, chat_id: str, enabled: bool,
+                on_alert: bool, on_task_done: bool) -> None:
+    _set("tg_token", token)
+    _set("tg_chat_id", chat_id)
+    _set("tg_enabled", "1" if enabled else "0")
+    _set("tg_on_alert", "1" if on_alert else "0")
+    _set("tg_on_task_done", "1" if on_task_done else "0")
+
+
+async def send(text: str, key: Optional[str] = None, force: bool = False) -> bool:
+    """Отправить сообщение. key — для антиспама (например 'disk:server1')."""
+    cfg = get_config()
+    if not cfg["enabled"] or not cfg["token"] or not cfg["chat_id"]:
+        return False
+    if key and not force:
+        last = _antispam.get(key, 0)
+        if time.time() - last < THROTTLE_S:
+            return False
+        _antispam[key] = time.time()
+    url = f"https://api.telegram.org/bot{cfg['token']}/sendMessage"
+    try:
+        async with httpx.AsyncClient(timeout=15) as cl:
+            r = await cl.post(url, json={
+                "chat_id": cfg["chat_id"],
+                "text": text,
+                "parse_mode": "HTML",
+                "disable_web_page_preview": True,
+            })
+            return r.status_code == 200
+    except Exception:
+        return False
+
+
+async def test() -> tuple[bool, str]:
+    cfg = get_config()
+    if not cfg["token"] or not cfg["chat_id"]:
+        return False, "заполните token и chat_id"
+    ok = await send("✅ Debian Manager: тестовое уведомление", force=True)
+    return ok, "отправлено" if ok else "ошибка отправки (проверьте token/chat_id)"
+
+
+async def alert(server_name: str, text: str) -> None:
+    cfg = get_config()
+    if cfg["enabled"] and cfg["on_alert"]:
+        await send(f"⚠️ <b>{server_name}</b>: {text}", key=f"alert:{server_name}:{text[:30]}")
+
+
+async def task_done(server_name: str, title: str, status: str) -> None:
+    cfg = get_config()
+    if cfg["enabled"] and cfg["on_task_done"]:
+        icon = "✅" if status == "success" else "❌"
+        await send(f"{icon} <b>{server_name}</b>: {title} — {status}", force=True)

app/core/packages.py

@@ -0,0 +1,101 @@
+"""APT: update/upgrade, списки пакетов, установка/удаление."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List
+
+from app.core.ssh import SSHClient
+
+SYSTEM_PRIORITIES = {"required", "important"}
+
+
+@dataclass
+class Package:
+    name: str
+    version: str
+    priority: str
+    manual: bool
+    upgradable: bool = False
+    candidate: str = ""
+
+    @property
+    def is_system(self) -> bool:
+        return self.priority in SYSTEM_PRIORITIES
+
+
+async def apt_update(c: SSHClient) -> str:
+    r = await c.sudo("DEBIAN_FRONTEND=noninteractive apt-get update", timeout=600)
+    return r.stdout + r.stderr
+
+
+async def list_upgradable(c: SSHClient) -> List[dict]:
+    r = await c.run("apt list --upgradable 2>/dev/null | tail -n +2")
+    out = []
+    for line in r.stdout.splitlines():
+        if not line.strip():
+            continue
+        # nginx/stable 1.22.1-9+deb12u1 amd64 [upgradable from: 1.22.1-9]
+        parts = line.split()
+        if len(parts) >= 2:
+            name = parts[0].split("/")[0]
+            out.append({"name": name, "candidate": parts[1], "raw": line})
+    return out
+
+
+async def list_packages(c: SSHClient) -> List[Package]:
+    """Все установленные пакеты с приоритетом и признаком manual."""
+    r = await c.run(
+        "dpkg-query -W -f='${Package}\\t${Version}\\t${Priority}\\n'", timeout=180
+    )
+    manual_r = await c.run("apt-mark showmanual", timeout=120)
+    manual = set(manual_r.stdout.split())
+    pkgs: List[Package] = []
+    for line in r.stdout.splitlines():
+        parts = line.split("\t")
+        if len(parts) == 3:
+            name, version, prio = parts
+            pkgs.append(Package(name, version, prio, name in manual))
+    return pkgs
+
+
+def split_packages(pkgs: List[Package]) -> Dict[str, List[Package]]:
+    """Разбивка на системные / пользовательские / зависимости."""
+    system = [p for p in pkgs if p.is_system]
+    user = [p for p in pkgs if not p.is_system and p.manual]
+    deps = [p for p in pkgs if not p.is_system and not p.manual]
+    return {"system": system, "user": user, "deps": deps}
+
+
+async def apt_upgrade(c: SSHClient, dist: bool = False):
+    """Стриминг upgrade. Возвращает async-итератор строк."""
+    cmd = "DEBIAN_FRONTEND=noninteractive apt-get {} -y".format(
+        "dist-upgrade" if dist else "upgrade"
+    )
+    return c.run_stream(cmd, use_sudo=True)
+
+
+async def install(c: SSHClient, names: List[str]):
+    cmd = "DEBIAN_FRONTEND=noninteractive apt-get install -y " + " ".join(names)
+    return c.run_stream(cmd, use_sudo=True)
+
+
+async def remove(c: SSHClient, names: List[str], purge: bool = False):
+    action = "purge" if purge else "remove"
+    cmd = f"DEBIAN_FRONTEND=noninteractive apt-get {action} -y " + " ".join(names)
+    return c.run_stream(cmd, use_sudo=True)
+
+
+async def autoremove(c: SSHClient):
+    return c.run_stream(
+        "DEBIAN_FRONTEND=noninteractive apt-get autoremove -y", use_sudo=True
+    )
+
+
+async def apt_show(c: SSHClient, name: str) -> str:
+    r = await c.run(f"apt-cache show {name} 2>/dev/null | head -40")
+    return r.stdout
+
+
+async def apt_search(c: SSHClient, query: str) -> List[str]:
+    r = await c.run(f"apt-cache search {query} 2>/dev/null | head -50")
+    return [l for l in r.stdout.splitlines() if l.strip()]

app/core/playbooks.py

@@ -0,0 +1,188 @@
+"""Плейбуки: YAML + Jinja2, типы шагов, выполнение."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable, Coroutine, List, Optional
+
+import yaml
+from jinja2 import Template
+
+from app.core.ssh import SSHClient
+from app.db.models import Server
+
+LogCallback = Callable[[str], None]
+
+PLAYBOOKS_DIR = Path.home() / ".debian-manager" / "playbooks"
+PLAYBOOKS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+BUILTIN = {
+    "Новый сервер": """\
+name: "Настройка нового сервера"
+vars:
+  ssh_port: "22"
+steps:
+  - name: Обновить систему
+    apt: {update: true, upgrade: dist}
+  - name: Установить базовые утилиты
+    apt: {install: [curl, htop, git, ufw, fail2ban]}
+  - name: Firewall (SSH + исходящие)
+    ufw: {preset: "Только SSH"}
+  - name: Включить ufw
+    shell: "yes | ufw enable"
+""",
+    "Docker-хост": """\
+name: "Docker-хост"
+steps:
+  - name: Обновить индекс пакетов
+    apt: {update: true}
+  - name: Установить Docker
+    apt: {install: [docker.io, docker-compose-v2]}
+  - name: Запустить docker
+    systemd: {unit: docker, action: "enable --now"}
+""",
+    "Обновить и перезагрузить": """\
+name: "Обновить всё и перезагрузить"
+steps:
+  - name: Update
+    apt: {update: true}
+  - name: Upgrade
+    apt: {upgrade: dist}
+  - name: Autoremove
+    apt: {autoremove: true}
+  - name: Reboot
+    reboot: {wait: true}
+""",
+}
+
+
+def list_playbooks() -> List[str]:
+    names = sorted(p.stem for p in PLAYBOOKS_DIR.glob("*.yml"))
+    return list(BUILTIN.keys()) + names
+
+
+def load(name: str) -> dict:
+    if name in BUILTIN:
+        return yaml.safe_load(BUILTIN[name])
+    path = PLAYBOOKS_DIR / f"{name}.yml"
+    return yaml.safe_load(path.read_text(encoding="utf-8"))
+
+
+def save(name: str, content: str) -> None:
+    yaml.safe_load(content)  # валидация
+    (PLAYBOOKS_DIR / f"{name}.yml").write_text(content, encoding="utf-8")
+
+
+def delete(name: str) -> None:
+    p = PLAYBOOKS_DIR / f"{name}.yml"
+    if p.exists():
+        p.unlink()
+
+
+def _render(value, ctx: dict):
+    if isinstance(value, str):
+        return Template(value).render(**ctx)
+    if isinstance(value, list):
+        return [_render(v, ctx) for v in value]
+    if isinstance(value, dict):
+        return {k: _render(v, ctx) for k, v in value.items()}
+    return value
+
+
+async def run_playbook(c: SSHClient, srv: Server, pb: dict, log: LogCallback,
+                       extra_vars: Optional[dict] = None) -> None:
+    ctx = dict(pb.get("vars") or {})
+    ctx.update(extra_vars or {})
+    ctx.setdefault("ssh_port", str(srv.port))
+    log(f"=== Плейбук: {pb.get('name', '?')} | сервер: {srv.name} ===")
+    for i, step in enumerate(pb.get("steps", []), 1):
+        name = _render(step.get("name", f"шаг {i}"), ctx)
+        log(f"\n--- [{i}] {name} ---")
+
+        when = step.get("when")
+        if when:
+            cond = str(_render(when, ctx)).strip()
+            if cond.lower() in ("false", "0", "", "no"):
+                log("пропущен (when)")
+                continue
+
+        try:
+            if "shell" in step:
+                cmd = _render(step["shell"], ctx)
+                log(f"$ {cmd}")
+                async for line in c.run_stream(cmd, use_sudo=True):
+                    log(line)
+            elif "apt" in step:
+                a = _render(step["apt"], ctx)
+                if a.get("update"):
+                    log("$ apt-get update")
+                    r = await c.sudo("DEBIAN_FRONTEND=noninteractive apt-get update", 900)
+                    log(r.stdout[-1500:])
+                if a.get("upgrade"):
+                    kind = "dist-upgrade" if a["upgrade"] == "dist" else "upgrade"
+                    log(f"$ apt-get {kind} -y")
+                    async for line in c.run_stream(
+                        f"DEBIAN_FRONTEND=noninteractive apt-get {kind} -y", use_sudo=True
+                    ):
+                        log(line)
+                if a.get("install"):
+                    pkgs = " ".join(a["install"])
+                    log(f"$ apt-get install -y {pkgs}")
+                    async for line in c.run_stream(
+                        f"DEBIAN_FRONTEND=noninteractive apt-get install -y {pkgs}",
+                        use_sudo=True,
+                    ):
+                        log(line)
+                if a.get("remove"):
+                    pkgs = " ".join(a["remove"])
+                    log(f"$ apt-get remove -y {pkgs}")
+                    async for line in c.run_stream(
+                        f"DEBIAN_FRONTEND=noninteractive apt-get remove -y {pkgs}",
+                        use_sudo=True,
+                    ):
+                        log(line)
+                if a.get("autoremove"):
+                    async for line in c.run_stream(
+                        "DEBIAN_FRONTEND=noninteractive apt-get autoremove -y", use_sudo=True
+                    ):
+                        log(line)
+            elif "ufw" in step:
+                from app.core import firewall
+                u = _render(step["ufw"], ctx)
+                if "preset" in u:
+                    log(await firewall.apply_preset(c, u["preset"], int(ctx["ssh_port"])))
+                if u.get("enable"):
+                    log(await firewall.enable(c, int(ctx["ssh_port"])))
+            elif "systemd" in step:
+                from app.core import systemd_svc
+                sd = _render(step["systemd"], ctx)
+                log(await systemd_svc.action(c, sd["unit"], sd["action"]))
+            elif "docker" in step:
+                d = _render(step["docker"], ctx)
+                workdir = d.get("workdir", "/opt/stacks/app")
+                log(await _docker_compose(c, workdir, d.get("action", "up -d")))
+            elif "reboot" in step:
+                from app.core.ssh import wait_online
+                import asyncio
+                log("перезагрузка...")
+                await c.sudo("(sleep 1; reboot) &", timeout=10)
+                if step["reboot"].get("wait", True):
+                    await asyncio.sleep(10)
+                    if not await wait_online(srv, 300):
+                        raise RuntimeError("сервер не вернулся после reboot")
+                    log("сервер снова онлайн — переподключение")
+                    c.close()
+                    await c.connect()
+            else:
+                log(f"неизвестный тип шага: {list(step.keys())}")
+        except Exception as e:
+            if step.get("ignore_errors"):
+                log(f"[ошибка проигнорирована] {e}")
+            else:
+                raise RuntimeError(f"шаг «{name}» упал: {e}")
+    log("\n=== Плейбук завершён ===")
+
+
+async def _docker_compose(c: SSHClient, workdir: str, action: str) -> str:
+    r = await c.sudo(f"docker compose -f {workdir}/docker-compose.yml {action}", 900)
+    return r.stdout + r.stderr

app/core/proxmox.py

@@ -0,0 +1,132 @@
+"""Proxmox VE: API через proxmoxer, ноды, VM/LXC, управление питанием."""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from app.db.database import get_session
+from app.db.models import Setting
+
+
+def _get(key: str) -> str:
+    with get_session() as s:
+        row = s.get(Setting, key)
+        return row.value if row else ""
+
+
+def _set(key: str, value: str) -> None:
+    with get_session() as s:
+        row = s.get(Setting, key) or Setting(key=key)
+        row.value = value
+        s.add(row)
+        s.commit()
+
+
+def get_config() -> dict:
+    return {
+        "host": _get("pve_host"),
+        "user": _get("pve_user") or "root@pam",
+        "token_name": _get("pve_token_name"),
+        "token_value": _get("pve_token_value"),
+        "verify_ssl": _get("pve_verify_ssl") == "1",
+    }
+
+
+def save_config(host: str, user: str, token_name: str, token_value: str,
+                verify_ssl: bool) -> None:
+    _set("pve_host", host.rstrip("/"))
+    _set("pve_user", user)
+    _set("pve_token_name", token_name)
+    _set("pve_token_value", token_value)
+    _set("pve_verify_ssl", "1" if verify_ssl else "0")
+
+
+def _client():
+    """Создать proxmoxer-клиент. Бросает если не настроено."""
+    from proxmoxer import ProxmoxAPI
+    cfg = get_config()
+    if not cfg["host"] or not cfg["token_name"] or not cfg["token_value"]:
+        raise RuntimeError("Proxmox не настроен — заполните хост и API-токен")
+    # убрать http:// или https:// если пользователь ввёл
+    host = cfg["host"].replace("http://", "").replace("https://", "").rstrip("/")
+    return ProxmoxAPI(
+        host, user=cfg["user"],
+        token_name=cfg["token_name"], token_value=cfg["token_value"],
+        verify_ssl=cfg["verify_ssl"], timeout=15,
+    )
+
+
+def test_connection() -> tuple[bool, str]:
+    try:
+        pve = _client()
+        version = pve.version.get()
+        return True, f"Proxmox VE {version.get('version', '?')}"
+    except Exception as e:
+        return False, str(e)
+
+
+def nodes() -> List[dict]:
+    return _client().nodes.get()
+
+
+def node_status(node: str) -> dict:
+    return _client().nodes(node).status.get()
+
+
+def vms(node: str) -> List[dict]:
+    """Все VM и LXC на ноде."""
+    pve = _client()
+    qemu = [{"type": "qemu", **x} for x in pve.nodes(node).qemu.get()]
+    lxc = [{"type": "lxc", **x} for x in pve.nodes(node).lxc.get()]
+    return qemu + lxc
+
+
+def vm_status(node: str, vmid: int, vm_type: str) -> dict:
+    pve = _client()
+    if vm_type == "qemu":
+        return pve.nodes(node).qemu(vmid).status.current.get()
+    return pve.nodes(node).lxc(vmid).status.current.get()
+
+
+def vm_action(node: str, vmid: int, vm_type: str, action: str) -> str:
+    """start/stop/shutdown/reboot/reset. Возвращает UPID задачи."""
+    assert action in ("start", "stop", "shutdown", "reboot", "reset")
+    pve = _client()
+    api = pve.nodes(node).qemu(vmid) if vm_type == "qemu" else pve.nodes(node).lxc(vmid)
+    return getattr(api.status, action).post()
+
+
+def vm_config(node: str, vmid: int, vm_type: str) -> dict:
+    pve = _client()
+    if vm_type == "qemu":
+        return pve.nodes(node).qemu(vmid).config.get()
+    return pve.nodes(node).lxc(vmid).config.get()
+
+
+def vm_rrd(node: str, vmid: int, vm_type: str, timeframe: str = "hour") -> list:
+    """Метрики из RRD (cpu, mem, netin, netout...)."""
+    pve = _client()
+    api = pve.nodes(node).qemu(vmid) if vm_type == "qemu" else pve.nodes(node).lxc(vmid)
+    return api.rrd.get(timeframe=timeframe, cf="AVERAGE")
+
+
+def get_vm_ip(node: str, vmid: int, vm_type: str) -> Optional[str]:
+    """IP из QEMU Guest Agent или из конфига LXC."""
+    try:
+        pve = _client()
+        if vm_type == "qemu":
+            data = pve.nodes(node).qemu(vmid).agent("network-get-interfaces").get()
+            for iface in data.get("result", []):
+                for addr in iface.get("ip-addresses", []):
+                    ip = addr.get("ip-address", "")
+                    if addr.get("ip-address-type") == "ipv4" and not ip.startswith("127."):
+                        return ip
+        else:
+            cfg = pve.nodes(node).lxc(vmid).config.get()
+            net0 = cfg.get("net0", "")
+            # "name=eth0,bridge=vmbr0,ip=192.168.1.10/24,gw=..."
+            for part in net0.split(","):
+                if part.startswith("ip=") and part != "ip=dhcp":
+                    return part[3:].split("/")[0]
+    except Exception:
+        pass
+    return None

app/core/reports.py

@@ -0,0 +1,58 @@
+"""Экспорт отчётов: CSV по серверам, метрикам, задачам."""
+from __future__ import annotations
+
+import csv
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from sqlmodel import select
+
+from app.core.ssh import check_server
+from app.db.database import get_session
+from app.db.models import MetricSnapshot, Server, TaskRecord
+
+REPORTS_DIR = Path.home() / ".debian-manager" / "reports"
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+async def generate() -> str:
+    """Сводный CSV-отчёт. Возвращает путь к файлу."""
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    path = REPORTS_DIR / f"report_{ts}.csv"
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        w = csv.writer(f)
+        w.writerow(["=== ОТЧЁТ ПО СЕРВЕРАМ", datetime.now().isoformat(), "==="])
+        w.writerow([])
+        w.writerow(["Сервер", "Хост", "Порт", "Пользователь", "Теги",
+                    "Онлайн", "ОС", "Uptime", "CPU%", "RAM%", "Диск%"])
+        with get_session() as s:
+            servers = list(s.exec(select(Server)).all())
+        for srv in servers:
+            info = await check_server(srv)
+            cpu = ram = disk = ""
+            if info.get("online"):
+                with get_session() as s:
+                    m = s.exec(select(MetricSnapshot)
+                               .where(MetricSnapshot.server_id == srv.id)
+                               .order_by(MetricSnapshot.id.desc()).limit(1)).first()
+                    if m:
+                        cpu, ram, disk = m.cpu_percent, m.mem_percent, m.disk_percent
+            w.writerow([srv.name, srv.host, srv.port, srv.username, srv.tags,
+                        "да" if info.get("online") else "нет",
+                        info.get("os", ""), info.get("uptime", ""), cpu, ram, disk])
+        w.writerow([])
+        w.writerow(["=== ПОСЛЕДНИЕ ЗАДАЧИ ==="])
+        w.writerow(["Время", "Сервер", "Тип", "Название", "Статус"])
+        with get_session() as s:
+            tasks = list(s.exec(select(TaskRecord)
+                                .order_by(TaskRecord.id.desc()).limit(100)).all())
+            srv_names = {x.id: x.name for x in servers}
+            for t in tasks:
+                w.writerow([t.created_at, srv_names.get(t.server_id, "?"),
+                            t.kind, t.title, t.status])
+    return str(path)
+
+
+def list_reports() -> list[Path]:
+    return sorted(REPORTS_DIR.glob("report_*.csv"), reverse=True)

app/core/scheduler.py

@@ -0,0 +1,193 @@
+"""Планировщик: запуск задач по cron-расписанию внутри приложения."""
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Optional
+
+from croniter import croniter
+from sqlmodel import select
+
+from app.db.database import get_session
+from app.db.models import ScheduledTask, Server
+
+CHECK_INTERVAL = 30  # секунд между проверками
+
+_next_run: dict[int, datetime] = {}
+_loop_task: Optional[asyncio.Task] = None
+
+
+# ---------- CRUD ----------
+
+def list_tasks() -> list[ScheduledTask]:
+    with get_session() as s:
+        return list(s.exec(select(ScheduledTask).order_by(ScheduledTask.id)).all())
+
+
+def add_task(**fields) -> ScheduledTask:
+    with get_session() as s:
+        t = ScheduledTask(**fields)
+        s.add(t)
+        s.commit()
+        s.refresh(t)
+        return t
+
+
+def update_task(task_id: int, **fields) -> None:
+    with get_session() as s:
+        t = s.get(ScheduledTask, task_id)
+        if t:
+            for k, v in fields.items():
+                setattr(t, k, v)
+            s.add(t)
+            s.commit()
+    _next_run.pop(task_id, None)  # пересчитать расписание
+
+
+def delete_task(task_id: int) -> None:
+    with get_session() as s:
+        t = s.get(ScheduledTask, task_id)
+        if t:
+            s.delete(t)
+            s.commit()
+    _next_run.pop(task_id, None)
+
+
+# ---------- выполнение ----------
+
+def _target_servers(target: str) -> list[Server]:
+    with get_session() as s:
+        servers = list(s.exec(select(Server)).all())
+    if target == "all":
+        return servers
+    return [srv for srv in servers if target in (srv.tags or "").split(",")
+            or target.strip() in [t.strip() for t in (srv.tags or "").split(",")]]
+
+
+async def execute_task(task_id: int) -> str:
+    """Выполнить задачу немедленно. Возвращает статус."""
+    from app.core import servers as servers_core
+    from app.core.group_ops import op_apt_update, op_upgrade, op_shell, run_group
+    from app.core.tasks import tasks as tm
+
+    with get_session() as s:
+        t = s.get(ScheduledTask, task_id)
+        if not t:
+            return "error: задача не найдена"
+        action, target, params, name = t.action, t.target, t.params, t.name
+        t.last_run = datetime.now(timezone.utc)
+        t.last_status = "running"
+        s.add(t)
+        s.commit()
+
+    status = "success"
+    log_lines: list[str] = []
+    try:
+        if action == "cleanup_metrics":
+            from app.db.models import MetricSnapshot
+            from datetime import timedelta
+            cutoff = datetime.now(timezone.utc) - timedelta(days=7)
+            with get_session() as s:
+                old = s.exec(select(MetricSnapshot).where(MetricSnapshot.ts < cutoff)).all()
+                for m in old:
+                    s.delete(m)
+                s.commit()
+                log_lines.append(f"удалено {len(old)} снапшотов")
+        elif action == "report":
+            from app.core import reports
+            path = await reports.generate()
+            log_lines.append(f"отчёт: {path}")
+        else:
+            servers = _target_servers(target)
+            if not servers:
+                raise RuntimeError(f"нет серверов для target='{target}'")
+            if action == "apt_update":
+                op = op_apt_update()
+            elif action == "upgrade":
+                op = op_upgrade(False)
+            elif action == "dist_upgrade":
+                op = op_upgrade(True)
+            elif action == "shell":
+                op = op_shell(params)
+            elif action == "backup":
+                from app.core.backup import run_backup
+                for srv in servers:
+                    rec = await run_backup(srv, params or "/etc")
+                    log_lines.append(f"{srv.name}: {rec.status}")
+                op = None
+            elif action == "playbook":
+                from app.core import playbooks as pb
+                from app.core.ssh import SSHClient
+                data = pb.load(params)
+                for srv in servers:
+                    async with SSHClient(srv) as c:
+                        await pb.run_playbook(c, srv, data, log_lines.append)
+                op = None
+            else:
+                raise RuntimeError(f"неизвестное действие: {action}")
+
+            if op is not None:
+                res = await run_group(servers, op)
+                log_lines.append(f"ok={res.ok_count} err={res.err_count}")
+                for r in res.results.values():
+                    if r.status == "error":
+                        status = "error"
+                        log_lines.append(f"{r.name}: {r.log[-300:]}")
+    except Exception as e:
+        status = "error"
+        log_lines.append(f"[ОШИБКА] {e}")
+
+    with get_session() as s:
+        t = s.get(ScheduledTask, task_id)
+        if t:
+            t.last_status = status
+            s.add(t)
+            s.commit()
+    # Telegram-уведомление
+    try:
+        from app.core import notify
+        await notify.task_done(f"планировщик", name, status)
+    except Exception:
+        pass
+    return status
+
+
+# ---------- цикл ----------
+
+async def _loop():
+    while True:
+        try:
+            now = datetime.now(timezone.utc)
+            for t in list_tasks():
+                if not t.enabled:
+                    continue
+                nxt = _next_run.get(t.id)
+                if nxt is None:
+                    nxt = croniter(t.cron, now).get_next(datetime)
+                    _next_run[t.id] = nxt
+                if now >= nxt:
+                    _next_run[t.id] = croniter(t.cron, now).get_next(datetime)
+                    asyncio.ensure_future(execute_task(t.id))
+        except Exception:
+            pass
+        await asyncio.sleep(CHECK_INTERVAL)
+
+
+def start() -> None:
+    global _loop_task
+    if _loop_task is None or _loop_task.done():
+        _loop_task = asyncio.ensure_future(_loop())
+
+
+# ---------- пресеты ----------
+
+PRESETS = [
+    ("Ежедневный apt update (03:00)", "0 3 * * *", "apt_update", "all", ""),
+    ("Еженедельный upgrade (вс 04:00)", "0 4 * * 0", "upgrade", "all", ""),
+    ("Ежедневный бэкап /etc (02:00)", "0 2 * * *", "backup", "all", "/etc"),
+    ("Бэкап /etc и /home (02:30)", "30 2 * * *", "backup", "all", "/etc /home"),
+    ("Очистка старых метрик (ежечасно)", "7 * * * *", "cleanup_metrics", "all", ""),
+    ("Ежедневный отчёт (08:00)", "0 8 * * *", "report", "all", ""),
+    ("Docker prune (вс 05:00)", "0 5 * * 0", "shell", "all", "docker system prune -f"),
+    ("Проверка диска (каждые 6 ч)", "13 */6 * * *", "shell", "all", "df -h"),
+]

app/core/servers.py

@@ -0,0 +1,47 @@
+"""CRUD серверов."""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from sqlmodel import select
+
+from app.db.database import get_session
+from app.db.models import Server
+
+
+def list_servers() -> List[Server]:
+    with get_session() as s:
+        return list(s.exec(select(Server).order_by(Server.name)).all())
+
+
+def get_server(server_id: int) -> Optional[Server]:
+    with get_session() as s:
+        return s.get(Server, server_id)
+
+
+def add_server(**fields) -> Server:
+    with get_session() as s:
+        srv = Server(**fields)
+        s.add(srv)
+        s.commit()
+        s.refresh(srv)
+        return srv
+
+
+def update_server(server_id: int, **fields) -> None:
+    with get_session() as s:
+        srv = s.get(Server, server_id)
+        if not srv:
+            return
+        for k, v in fields.items():
+            setattr(srv, k, v)
+        s.add(srv)
+        s.commit()
+
+
+def delete_server(server_id: int) -> None:
+    with get_session() as s:
+        srv = s.get(Server, server_id)
+        if srv:
+            s.delete(srv)
+            s.commit()

app/core/ssh.py

@@ -0,0 +1,130 @@
+"""SSH-слой: подключения, выполнение команд, sudo, потоковый вывод."""
+from __future__ import annotations
+
+import asyncio
+import shlex
+from dataclasses import dataclass
+from typing import AsyncIterator, Optional
+
+import asyncssh
+
+from app.db.models import Server
+
+CONNECT_TIMEOUT = 15
+
+
+@dataclass
+class CmdResult:
+    stdout: str
+    stderr: str
+    returncode: int
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+
+class SSHClient:
+    """Одно SSH-подключение к серверу с помощниками sudo."""
+
+    def __init__(self, server: Server):
+        self.server = server
+        self._conn: Optional[asyncssh.SSHClientConnection] = None
+
+    async def __aenter__(self) -> "SSHClient":
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *exc) -> None:
+        self.close()
+
+    async def connect(self) -> None:
+        kwargs: dict = dict(
+            host=self.server.host,
+            port=self.server.port,
+            username=self.server.username,
+            known_hosts=None,
+            connect_timeout=CONNECT_TIMEOUT,
+        )
+        if self.server.auth_type == "key" and self.server.key_path:
+            kwargs["client_keys"] = [self.server.key_path]
+            if self.server.password:
+                kwargs["passphrase"] = self.server.password
+        else:
+            kwargs["password"] = self.server.password
+        self._conn = await asyncssh.connect(**kwargs)
+
+    def close(self) -> None:
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+    @property
+    def conn(self) -> asyncssh.SSHClientConnection:
+        if not self._conn:
+            raise RuntimeError("SSH not connected")
+        return self._conn
+
+    # ---------- выполнение ----------
+
+    async def run(self, cmd: str, timeout: int = 120) -> CmdResult:
+        r = await self.conn.run(cmd, timeout=timeout)
+        return CmdResult(r.stdout or "", r.stderr or "", r.returncode)
+
+    def sudo_wrap(self, cmd: str) -> str:
+        """Обернуть команду в sudo -S с передачей пароля по stdin."""
+        pw = self.server.sudo_password or self.server.password or ""
+        if self.server.username == "root":
+            return cmd
+        return f"echo {shlex.quote(pw)} | sudo -S -p '' bash -c {shlex.quote(cmd)}"
+
+    async def sudo(self, cmd: str, timeout: int = 600) -> CmdResult:
+        return await self.run(self.sudo_wrap(cmd), timeout=timeout)
+
+    async def run_stream(self, cmd: str, use_sudo: bool = False) -> AsyncIterator[str]:
+        """Строки вывода по мере поступления (для лог-панели)."""
+        full = self.sudo_wrap(cmd) if use_sudo else cmd
+        async with self.conn.create_process(full, term_type="dumb") as proc:
+            async for line in proc.stdout:
+                yield line.rstrip("\n")
+            await proc.wait()
+
+    async def is_alive(self) -> bool:
+        try:
+            r = await self.run("echo ok", timeout=10)
+            return r.ok
+        except Exception:
+            return False
+
+
+async def check_server(server: Server) -> dict:
+    """Быстрый health-check: онлайн, ОС, uptime."""
+    try:
+        async with SSHClient(server) as c:
+            r = await c.run(
+                "hostname; . /etc/os-release && echo $PRETTY_NAME; "
+                "uptime -p; nproc; free -m | awk 'NR==2{print $2}'",
+                timeout=20,
+            )
+            lines = (r.stdout or "").splitlines()
+            return {
+                "online": True,
+                "hostname": lines[0] if len(lines) > 0 else "",
+                "os": lines[1] if len(lines) > 1 else "",
+                "uptime": lines[2] if len(lines) > 2 else "",
+                "cpu_cores": lines[3] if len(lines) > 3 else "?",
+                "mem_mb": lines[4] if len(lines) > 4 else "?",
+            }
+    except Exception as e:
+        return {"online": False, "error": str(e)}
+
+
+async def wait_online(server: Server, timeout_s: int = 300, interval: int = 5) -> bool:
+    """Ждать возврата сервера после reboot."""
+    deadline = asyncio.get_event_loop().time() + timeout_s
+    while asyncio.get_event_loop().time() < deadline:
+        info = await check_server(server)
+        if info.get("online"):
+            return True
+        await asyncio.sleep(interval)
+    return False

app/core/systemd_svc.py

@@ -0,0 +1,73 @@
+"""systemd: юниты, действия, journalctl."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List
+
+from app.core.ssh import SSHClient
+
+CRITICAL_UNITS = {"ssh.service", "sshd.service", "ssh.socket", "docker.service",
+                  "networking.service", "systemd-networkd.service", "dbus.service"}
+
+
+@dataclass
+class Unit:
+    name: str
+    load: str
+    active: str
+    sub: str
+    description: str
+    enabled: str = ""
+
+
+async def list_units(c: SSHClient) -> List[Unit]:
+    r = await c.sudo(
+        "systemctl list-units --type=service --all --no-legend --no-pager "
+        "--plain | awk '{$1=$1};1'", timeout=60
+    )
+    enabled_r = await c.sudo(
+        "systemctl list-unit-files --type=service --no-legend --no-pager", timeout=60
+    )
+    enabled_map = {}
+    for line in enabled_r.stdout.splitlines():
+        p = line.split()
+        if len(p) >= 2:
+            enabled_map[p[0]] = p[1]
+
+    units: List[Unit] = []
+    for line in r.stdout.splitlines():
+        p = line.split(None, 4)
+        if len(p) >= 4:
+            units.append(Unit(
+                name=p[0], load=p[1], active=p[2], sub=p[3],
+                description=p[4] if len(p) > 4 else "",
+                enabled=enabled_map.get(p[0], ""),
+            ))
+    return units
+
+
+async def failed_units(c: SSHClient) -> List[str]:
+    r = await c.sudo("systemctl --failed --no-legend --no-pager --plain", timeout=30)
+    return [l.split()[0] for l in r.stdout.splitlines() if l.strip() and not l.startswith("0 ")]
+
+
+async def action(c: SSHClient, unit: str, act: str) -> str:
+    assert act in ("start", "stop", "restart", "reload", "enable", "disable", "mask", "unmask")
+    r = await c.sudo(f"systemctl {act} {unit}", timeout=120)
+    if not r.ok:
+        raise RuntimeError(r.stderr.strip() or f"rc={r.returncode}")
+    return r.stdout
+
+
+async def logs(c: SSHClient, unit: str, lines: int = 200) -> str:
+    r = await c.sudo(f"journalctl -u {unit} -n {lines} --no-pager", timeout=60)
+    return r.stdout
+
+
+async def cat_unit(c: SSHClient, unit: str) -> str:
+    r = await c.sudo(f"systemctl cat {unit}", timeout=30)
+    return r.stdout
+
+
+async def daemon_reload(c: SSHClient) -> None:
+    await c.sudo("systemctl daemon-reload")

app/core/tasks.py

@@ -0,0 +1,81 @@
+"""Очередь длинных задач с журналом."""
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Awaitable, Callable, Coroutine, List, Optional
+
+from app.db.database import get_session
+from app.db.models import TaskRecord
+
+LogCallback = Callable[[str], None]
+
+
+class TaskManager:
+    def __init__(self):
+        self._running: dict[int, asyncio.Task] = {}
+
+    def start(self, kind: str, title: str, server_id: Optional[int],
+              coro_factory: Callable[[LogCallback], Coroutine],
+              on_log: Optional[LogCallback] = None,
+              on_done: Optional[Callable[[TaskRecord], None]] = None) -> int:
+        """Запустить задачу. coro_factory(log) — корутина, пишущая строки в log."""
+        with get_session() as s:
+            rec = TaskRecord(kind=kind, title=title, server_id=server_id, status="running")
+            s.add(rec)
+            s.commit()
+            s.refresh(rec)
+            task_id = rec.id
+
+        def log(line: str) -> None:
+            with get_session() as s:
+                r = s.get(TaskRecord, task_id)
+                if r:
+                    r.log += line + "\n"
+                    s.add(r)
+                    s.commit()
+            if on_log:
+                on_log(line)
+
+        async def runner():
+            status = "success"
+            try:
+                await coro_factory(log)
+            except asyncio.CancelledError:
+                status = "cancelled"
+                log("[отменено пользователем]")
+            except Exception as e:
+                status = "error"
+                log(f"[ОШИБКА] {e}")
+            with get_session() as s:
+                r = s.get(TaskRecord, task_id)
+                if r:
+                    r.status = status
+                    r.finished_at = datetime.now(timezone.utc)
+                    s.add(r)
+                    s.commit()
+                    s.refresh(r)
+                    if on_done:
+                        on_done(r)
+
+        self._running[task_id] = asyncio.ensure_future(runner())
+        return task_id
+
+    def cancel(self, task_id: int) -> None:
+        t = self._running.get(task_id)
+        if t and not t.done():
+            t.cancel()
+
+    def get(self, task_id: int) -> Optional[TaskRecord]:
+        with get_session() as s:
+            return s.get(TaskRecord, task_id)
+
+    def list_recent(self, limit: int = 50) -> List[TaskRecord]:
+        from sqlmodel import select
+        with get_session() as s:
+            return list(s.exec(
+                select(TaskRecord).order_by(TaskRecord.id.desc()).limit(limit)
+            ).all())
+
+
+tasks = TaskManager()

app/core/terminal.py

@@ -0,0 +1,69 @@
+"""Интерактивный терминал: PTY-сессия по SSH с потоковым вводом/выводом."""
+from __future__ import annotations
+
+import asyncio
+from typing import Callable, Optional
+
+import asyncssh
+
+from app.db.models import Server
+
+
+class TerminalSession:
+    """PTY-терминал к серверу. output_cb(str) вызывается для каждого куска вывода."""
+
+    def __init__(self, server: Server, output_cb: Callable[[str], None],
+                 cols: int = 120, rows: int = 30):
+        self.server = server
+        self.output_cb = output_cb
+        self.cols = cols
+        self.rows = rows
+        self._conn: Optional[asyncssh.SSHClientConnection] = None
+        self._proc: Optional[asyncssh.SSHClientProcess] = None
+        self._closed = False
+
+    async def open(self) -> None:
+        kwargs: dict = dict(
+            host=self.server.host, port=self.server.port,
+            username=self.server.username, known_hosts=None, connect_timeout=15,
+        )
+        if self.server.auth_type == "key" and self.server.key_path:
+            kwargs["client_keys"] = [self.server.key_path]
+            if self.server.password:
+                kwargs["passphrase"] = self.server.password
+        else:
+            kwargs["password"] = self.server.password
+        self._conn = await asyncssh.connect(**kwargs)
+        self._proc = await self._conn.create_process(
+            term_type="xterm-256color",
+            term_size=(self.cols, self.rows),
+        )
+        asyncio.ensure_future(self._reader())
+
+    async def _reader(self) -> None:
+        try:
+            while not self._closed and self._proc:
+                data = await self._proc.stdout.read(4096)
+                if not data:
+                    break
+                self.output_cb(data)
+        except Exception:
+            pass
+
+    def write(self, data: str) -> None:
+        if self._proc:
+            self._proc.stdin.write(data)
+
+    def resize(self, cols: int, rows: int) -> None:
+        if self._proc:
+            self._proc.change_terminal_size(cols, rows)
+
+    def close(self) -> None:
+        self._closed = True
+        try:
+            if self._proc:
+                self._proc.terminate()
+            if self._conn:
+                self._conn.close()
+        except Exception:
+            pass

app/core/webhook.py

@@ -0,0 +1,111 @@
+"""Webhook-сервер для автодеплоя из Gitea (push → redeploy)."""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Optional
+
+from sqlmodel import select
+
+from app.core import servers as servers_core
+from app.db.database import get_session
+from app.db.models import WebhookBinding
+
+_server = None
+
+
+def list_bindings() -> list[WebhookBinding]:
+    with get_session() as s:
+        return list(s.exec(select(WebhookBinding)).all())
+
+
+def add_binding(**fields) -> WebhookBinding:
+    with get_session() as s:
+        b = WebhookBinding(**fields)
+        s.add(b)
+        s.commit()
+        s.refresh(b)
+        return b
+
+
+def delete_binding(bid: int) -> None:
+    with get_session() as s:
+        b = s.get(WebhookBinding, bid)
+        if b:
+            s.delete(b)
+            s.commit()
+
+
+async def _handler(reader, writer):
+    """Минимальный HTTP-сервер для /webhooks/gitea."""
+    try:
+        req = await reader.readuntil(b"\r\n\r\n")
+        head = req.decode(errors="replace")
+        first = head.splitlines()[0] if head else ""
+        # тело
+        length = 0
+        for line in head.splitlines():
+            if line.lower().startswith("content-length:"):
+                length = int(line.split(":", 1)[1].strip())
+        body = await reader.readexactly(length) if length else b""
+
+        status, text = 200, "ok"
+        if first.startswith("POST /webhooks/gitea"):
+            try:
+                payload = json.loads(body or b"{}")
+                repo = payload.get("repository", {}).get("full_name", "")
+                ref = payload.get("ref", "")  # refs/heads/main
+                branch = ref.rsplit("/", 1)[-1]
+                asyncio.ensure_future(_deploy(repo, branch))
+                text = f"deploy scheduled: {repo}@{branch}"
+            except Exception as e:
+                status, text = 400, f"bad payload: {e}"
+        else:
+            status, text = 404, "not found"
+
+        writer.write(f"HTTP/1.1 {status} OK\r\nContent-Length: {len(text)}\r\n"
+                     f"Connection: close\r\n\r\n{text}".encode())
+        await writer.drain()
+    except Exception:
+        pass
+    finally:
+        try:
+            writer.close()
+        except Exception:
+            pass
+
+
+async def _deploy(repo: str, branch: str) -> None:
+    with get_session() as s:
+        bindings = list(s.exec(select(WebhookBinding)
+                               .where(WebhookBinding.repo == repo,
+                                      WebhookBinding.branch == branch,
+                                      WebhookBinding.enabled == True)).all())  # noqa: E712
+    for b in bindings:
+        srv = servers_core.get_server(b.server_id)
+        if not srv:
+            continue
+        try:
+            from app.core import gitea as g
+            from app.core.ssh import SSHClient
+            from app.core.tasks import tasks
+            async def job(log, srv=srv, b=b):
+                async with SSHClient(srv) as c:
+                    cfg = g.get_config()
+                    clone_url = f"{cfg['url']}/{repo}.git"
+                    await g.deploy(c, clone_url, repo.split("/")[-1],
+                                   b.branch, b.compose_path, b.env or None, log)
+            tasks.start("webhook", f"auto-deploy {repo}@{branch}", srv.id, job)
+        except Exception:
+            pass
+
+
+async def start(port: int = 9100) -> None:
+    global _server
+    if _server:
+        return
+    _server = await asyncio.start_server(_handler, "0.0.0.0", port)
+
+
+def is_running() -> bool:
+    return _server is not None

app/db/database.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from sqlmodel import SQLModel, Session, create_engine
+
+DB_PATH = Path.home() / ".debian-manager" / "data.db"
+DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+engine = create_engine(
+    f"sqlite:///{DB_PATH}",
+    echo=False,
+    connect_args={"check_same_thread": False},
+)
+# expire_on_commit=False — объекты остаются читаемыми после закрытия сессии
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import Session as _Session
+
+_SessionFactory = sessionmaker(bind=engine, class_=_Session, expire_on_commit=False)
+
+
+def init_db() -> None:
+    from app.db import models  # noqa: F401 — регистрация таблиц
+    SQLModel.metadata.create_all(engine)
+    _migrate()
+
+
+def _migrate() -> None:
+    """ALTER TABLE для колонок, добавленных после первого запуска."""
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    cols = [r[1] for r in conn.execute("PRAGMA table_info(server)").fetchall()]
+    if "note" not in cols:
+        conn.execute("ALTER TABLE server ADD COLUMN note TEXT DEFAULT ''")
+        conn.commit()
+    conn.close()
+
+
+def get_session() -> Session:
+    return _SessionFactory()

app/db/models.py

@@ -0,0 +1,96 @@
+from datetime import datetime, timezone
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+
+def utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class Server(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    name: str
+    host: str
+    port: int = 22
+    username: str = "root"
+    auth_type: str = "password"          # password | key
+    password: Optional[str] = None       # см. README: для продакшена — keyring
+    key_path: Optional[str] = None
+    sudo_password: Optional[str] = None  # если None — берётся password
+    tags: str = ""                       # через запятую
+    note: str = ""                       # пользовательская заметка
+    color: str = "blue"
+    read_only: bool = False
+    created_at: datetime = Field(default_factory=utcnow)
+
+
+class TaskRecord(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    server_id: Optional[int] = None
+    kind: str                            # update/upgrade/reboot/install/docker/...
+    title: str
+    status: str = "pending"              # pending/running/success/error/cancelled
+    log: str = ""
+    created_at: datetime = Field(default_factory=utcnow)
+    finished_at: Optional[datetime] = None
+
+
+class MetricSnapshot(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    server_id: int
+    cpu_percent: float = 0.0
+    mem_percent: float = 0.0
+    mem_used_mb: int = 0
+    mem_total_mb: int = 0
+    disk_percent: float = 0.0
+    load1: float = 0.0
+    net_rx_kbs: float = 0.0
+    net_tx_kbs: float = 0.0
+    ts: datetime = Field(default_factory=utcnow)
+
+
+class CronBackup(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    server_id: int
+    user: str
+    content: str
+    created_at: datetime = Field(default_factory=utcnow)
+
+
+class Setting(SQLModel, table=True):
+    key: str = Field(primary_key=True)
+    value: str = ""
+
+
+class ScheduledTask(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    name: str
+    cron: str                          # 5-полевое выражение
+    action: str                        # apt_update/upgrade/dist_upgrade/shell/backup/playbook/report/cleanup_metrics
+    target: str = "all"                # "all" или тег
+    params: str = ""                   # команда / пути бэкапа / имя плейбука
+    enabled: bool = True
+    last_run: Optional[datetime] = None
+    last_status: str = ""
+
+
+class BackupRecord(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    server_id: int
+    paths: str
+    file: str = ""                     # локальный путь скачанного архива
+    size: int = 0
+    status: str = "pending"            # pending/success/error
+    log: str = ""
+    created_at: datetime = Field(default_factory=utcnow)
+
+
+class WebhookBinding(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    repo: str                          # full_name, напр. dimon/myapp
+    server_id: int
+    branch: str = "main"
+    compose_path: str = "docker-compose.yml"
+    env: str = ""
+    enabled: bool = True

app/main.py

@@ -0,0 +1,177 @@
+"""Debian Manager — управление Debian-серверами."""
+import asyncio
+
+import flet as ft
+
+from app.db.database import init_db
+from app.core import servers as servers_core
+from app.core import scheduler
+from app.db.models import Setting
+from app.db.database import get_session
+from app.ui.pages.dashboard import DashboardPage
+from app.ui.pages.servers import ServersPage
+from app.ui.pages.server_detail import ServerDetailPage
+from app.ui.pages.group_ops import GroupOpsPage
+from app.ui.pages.playbooks import PlaybooksPage
+from app.ui.pages.diff import DiffPage
+from app.ui.pages.gitea import GiteaPage
+from app.ui.pages.scheduler import SchedulerPage
+from app.ui.pages.backups import BackupsPage
+from app.ui.pages.reports import ReportsPage
+from app.ui.pages.portainer import PortainerPage
+from app.ui.pages.agent import AgentPage
+from app.ui.pages.proxmox_page import ProxmoxPage
+from app.ui.pages.wizard import WizardPage
+from app.ui.pages.settings import SettingsPage
+from app.ui.pages.tasks import TasksPage
+
+
+def _get_setting(key: str) -> str:
+    with get_session() as s:
+        row = s.get(Setting, key)
+        return row.value if row else ""
+
+
+def _set_setting(key: str, value: str) -> None:
+    with get_session() as s:
+        row = s.get(Setting, key) or Setting(key=key)
+        row.value = value
+        s.add(row)
+        s.commit()
+
+
+def main(page: ft.Page):
+    page.title = "Debian Manager"
+    page.window.width = 1400
+    page.window.height = 900
+    page.padding = 0
+
+    init_db()
+
+    # тема из настроек
+    theme = _get_setting("theme")
+    page.theme_mode = (ft.ThemeMode.DARK if theme != "light" else ft.ThemeMode.LIGHT)
+
+    # seed тестового сервера при первом запуске
+    if not servers_core.list_servers():
+        servers_core.add_server(
+            name="Test VPS", host="132.243.17.164", port=2292,
+            username="dimon", password="123456789987654321", tags="удалённые",
+        )
+
+    # запуск планировщика и фоновых сервисов
+    async def _start_bg():
+        scheduler.start()
+        try:
+            from app.core import webhook, agent
+            await webhook.start()
+            await agent.start()
+        except Exception:
+            pass
+    page.run_task(_start_bg)
+
+    content = ft.Container(expand=True, padding=20)
+
+    PAGES = {
+        "dashboard": ("Дашборд", ft.Icons.DASHBOARD, DashboardPage),
+        "servers": ("Серверы", ft.Icons.DNS, ServersPage),
+        "wizard": ("Мастер настройки", ft.Icons.AUTO_FIX_HIGH, WizardPage),
+        "group": ("Групповые операции", ft.Icons.GROUPS, GroupOpsPage),
+        "scheduler": ("Планировщик", ft.Icons.SCHEDULE, SchedulerPage),
+        "playbooks": ("Плейбуки", ft.Icons.PLAYLIST_PLAY, PlaybooksPage),
+        "backups": ("Бэкапы", ft.Icons.BACKUP, BackupsPage),
+        "reports": ("Отчёты", ft.Icons.SUMMARIZE, ReportsPage),
+        "portainer": ("Portainer", ft.Icons.WIDGETS, PortainerPage),
+        "agent": ("Агент", ft.Icons.SENSORS, AgentPage),
+        "proxmox": ("Proxmox", ft.Icons.CLOUD_QUEUE, ProxmoxPage),
+        "diff": ("Сравнение", ft.Icons.COMPARE_ARROWS, DiffPage),
+        "gitea": ("Gitea Deploy", ft.Icons.ROCKET_LAUNCH, GiteaPage),
+        "tasks": ("Журнал задач", ft.Icons.TASK_ALT, TasksPage),
+        "settings": ("Настройки", ft.Icons.SETTINGS, SettingsPage),
+    }
+
+    state = {"route": "dashboard", "detail_server_id": None,
+             "group_filter": "Все"}
+
+    # top_bar объявлен до render, чтобы render мог его обновлять
+    top_bar = ft.Container(padding=ft.Padding.only(left=20, top=10))
+
+    def render():
+        top_bar.content = group_chips()
+        route = state["route"]
+        if route == "server_detail":
+            content.content = ServerDetailPage(page, state["detail_server_id"], go)
+        elif route == "dashboard":
+            content.content = DashboardPage(page, go, group_filter=state["group_filter"])
+        else:
+            cls = PAGES[route][2]
+            content.content = cls(page, go)
+        nav.selected_index = list(PAGES.keys()).index(route) if route in PAGES else 0
+        page.update()
+
+    def go(route: str, server_id=None, group_filter=None):
+        state["route"] = route
+        state["detail_server_id"] = server_id
+        if group_filter is not None:
+            state["group_filter"] = group_filter
+        render()
+
+    def toggle_theme(e):
+        new = "light" if page.theme_mode == ft.ThemeMode.DARK else "dark"
+        page.theme_mode = ft.ThemeMode.LIGHT if new == "light" else ft.ThemeMode.DARK
+        _set_setting("theme", new)
+        theme_btn.icon = ft.Icons.LIGHT_MODE if new == "dark" else ft.Icons.DARK_MODE
+        page.update()
+
+    # группы серверов для дашборда
+    def group_chips():
+        servers = servers_core.list_servers()
+        tags = sorted({t.strip() for s in servers for t in (s.tags or "").split(",") if t.strip()})
+        groups = ["Все"] + tags
+        return ft.Row([
+            ft.Chip(
+                label=ft.Text(g),
+                selected=state["group_filter"] == g,
+                on_select=lambda e, g=g: go("dashboard", group_filter=g),
+            ) for g in groups
+        ], spacing=6)
+
+    theme_btn = ft.IconButton(
+        ft.Icons.LIGHT_MODE if page.theme_mode == ft.ThemeMode.DARK else ft.Icons.DARK_MODE,
+        tooltip="Сменить тему", on_click=toggle_theme,
+    )
+
+    # NavigationRail — компактный режим (только иконки), tooltip через label
+    nav = ft.NavigationRail(
+        selected_index=0,
+        label_type=ft.NavigationRailLabelType.NONE,
+        min_width=60,
+        destinations=[
+            ft.NavigationRailDestination(
+                icon=ft.Icon(v[1], tooltip=v[0]),  # tooltip на самой иконке
+                label=v[0],
+            )
+            for v in PAGES.values()
+        ],
+        on_change=lambda e: go(list(PAGES.keys())[e.control.selected_index]),
+        trailing=ft.Column([theme_btn], alignment=ft.MainAxisAlignment.END),
+    )
+
+    # верхняя панель с группами (только на дашборде)
+    top_bar.content = group_chips()
+
+    page.add(
+        ft.Column([
+            top_bar,
+            ft.Row(
+                [nav, ft.VerticalDivider(width=1), content],
+                expand=True,
+                spacing=0,
+            ),
+        ], expand=True, spacing=0),
+    )
+    render()
+
+
+if __name__ == "__main__":
+    ft.app(target=main)

app/ui/components.py

@@ -0,0 +1,65 @@
+"""Общие UI-хелперы (Flet ≥ 0.80: show_dialog/pop_dialog, SnackBar через show_dialog)."""
+import asyncio
+
+import flet as ft
+
+
+def confirm_dialog(page: ft.Page, title: str, text: str, on_confirm, danger: bool = True):
+    """Модальный диалог подтверждения."""
+    def close(e=None):
+        page.pop_dialog()
+
+    def yes(e):
+        page.pop_dialog()
+        on_confirm()
+
+    dlg = ft.AlertDialog(
+        modal=True,
+        title=ft.Text(title),
+        content=ft.Text(text),
+        actions=[
+            ft.TextButton("Отмена", on_click=close),
+            ft.FilledButton(
+                "Подтвердить", on_click=yes,
+                style=ft.ButtonStyle(bgcolor=ft.Colors.RED_700 if danger else None),
+            ),
+        ],
+    )
+    page.show_dialog(dlg)
+
+
+def snack(page: ft.Page, text: str, error: bool = False):
+    page.show_dialog(ft.SnackBar(
+        ft.Text(text),
+        bgcolor=ft.Colors.RED_700 if error else ft.Colors.GREEN_700,
+        open=True,
+    ))
+
+
+def log_view(initial: str = "") -> ft.ListView:
+    """Скроллящаяся панель лога."""
+    return ft.ListView(expand=True, spacing=2, auto_scroll=True)
+
+
+def append_log(lv: ft.ListView, line: str):
+    lv.controls.append(
+        ft.Text(line, size=12, font_family="Consolas", selectable=True)
+    )
+    try:
+        lv.update()
+    except Exception:
+        pass
+
+
+def open_dialog(page: ft.Page, dlg: ft.AlertDialog):
+    page.show_dialog(dlg)
+
+
+def close_dialog(page: ft.Page):
+    page.pop_dialog()
+
+
+def fmt_mb(v: float) -> str:
+    if v >= 1024:
+        return f"{v/1024:.1f} ГБ"
+    return f"{v:.0f} МБ"

app/ui/pages/agent.py

@@ -0,0 +1,108 @@
+"""Агент-режим: установка/удаление агента, приём метрик."""
+import flet as ft
+
+from app.core import agent as ag
+from app.core import servers as servers_core
+from app.ui.components import confirm_dialog, snack
+
+
+class AgentPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        self.cards_col = ft.Column(spacing=10)
+        self.server_status = ft.Text("…", size=13)
+
+        self.controls = [
+            ft.Text("Агент-режим", size=28, weight=ft.FontWeight.BOLD),
+            ft.Text("Агент на сервере шлёт метрики каждые 5 сек по HTTP — "
+                    "real-time графики без SSH-поллинга. Приложение слушает порт "
+                    f"{ag.get_agent_port()}.",
+                    size=13, color=ft.Colors.GREY_500),
+            ft.Row([
+                ft.FilledButton("Запустить приёмник", icon=ft.Icons.PLAY_ARROW,
+                                on_click=self._start_server),
+                self.server_status,
+            ]),
+            ft.Divider(),
+            self.cards_col,
+        ]
+        self._reload()
+        self._update_server_status()
+
+    def _update_server_status(self):
+        self.server_status.value = (
+            f"✅ приёмник запущен на порту {ag.get_agent_port()}"
+            if ag.is_running() else "⚪ приёмник не запущен"
+        )
+        self._page.update()
+
+    def _start_server(self, e):
+        async def _s():
+            await ag.start()
+            self._update_server_status()
+        self._page.run_task(_s)
+
+    def _reload(self):
+        self.cards_col.controls = []
+        for srv in servers_core.list_servers():
+            self.cards_col.controls.append(self._card(srv))
+        self._page.update()
+        for srv, card in zip(servers_core.list_servers(), self.cards_col.controls):
+            self._page.run_task(self._fill, srv, card)
+
+    def _card(self, srv):
+        return ft.Card(content=ft.Container(
+            padding=14, width=560,
+            content=ft.Column([
+                ft.Text(srv.name, weight=ft.FontWeight.BOLD, size=16),
+                ft.ProgressBar(height=3),
+            ]),
+        ))
+
+    async def _fill(self, srv, card):
+        status = await ag.agent_status(srv)
+        metrics = ag.agent_metrics.get(srv.id)
+        running = status == "active"
+
+        rows = [ft.Text(f"статус: {status}", size=12,
+                        color=ft.Colors.GREEN_300 if running else ft.Colors.GREY_500)]
+        if metrics:
+            import time
+            age = time.time() - metrics.get("ts", 0)
+            rows.append(ft.Text(
+                f"CPU {metrics.get('cpu')}%  •  RAM {metrics.get('mem_pct')}%  •  "
+                f"Диск {metrics.get('disk')}%  •  load {metrics.get('load')}  •  "
+                f"обновлено {age:.0f} сек назад",
+                size=11, color=ft.Colors.BLUE_300))
+        btns = []
+        if not running:
+            btns.append(ft.FilledButton("Установить агента", icon=ft.Icons.DOWNLOAD,
+                                        on_click=lambda e, s=srv: self._install(s)))
+        else:
+            btns.append(ft.OutlinedButton("Удалить агента",
+                                          on_click=lambda e, s=srv: self._uninstall(s)))
+        rows.append(ft.Row(btns))
+        card.content.content.controls[1] = ft.Column(rows, spacing=4)
+        self._page.update()
+
+    def _install(self, srv):
+        from app.core.tasks import tasks
+        import socket
+        app_host = socket.gethostbyname(socket.gethostname())
+        async def job(log):
+            log(f"адрес приложения для агента: {app_host}:{ag.get_agent_port()}")
+            ok = await ag.install_agent(srv, app_host, log)
+            log("готово" if ok else "ошибка установки")
+        tasks.start("agent", "установка агента", srv.id, job,
+                    on_done=lambda r: self._reload())
+        snack(self._page, f"Установка агента на {srv.name}…")
+
+    def _uninstall(self, srv):
+        def do():
+            async def _d():
+                await ag.uninstall_agent(srv)
+                self._reload()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, "Удалить агента?",
+                       f"dm-agent будет остановлен и удалён с «{srv.name}».", do)

app/ui/pages/backups.py

@@ -0,0 +1,87 @@
+"""Резервное копирование: запуск, история, скачивание."""
+import flet as ft
+
+from app.core import backup as bk
+from app.core import servers as servers_core
+from app.core.tasks import tasks
+from app.ui.components import append_log, log_view, snack
+
+
+class BackupsPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+
+        self.srv_dd = ft.Dropdown(label="Сервер", width=250, options=[
+            ft.dropdown.Option(str(s.id), s.name) for s in servers_core.list_servers()
+        ])
+        self.paths_tf = ft.TextField(
+            label="Пути (через пробел)", value="/etc", width=400,
+            hint_text="/etc /home/user /var/www",
+        )
+        self.download_cb = ft.Checkbox(label="Скачать на этот ПК", value=True)
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=180, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False)
+        self.table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Дата")),
+            ft.DataColumn(ft.Text("Сервер")),
+            ft.DataColumn(ft.Text("Пути")),
+            ft.DataColumn(ft.Text("Размер")),
+            ft.DataColumn(ft.Text("Статус")),
+            ft.DataColumn(ft.Text("Файл")),
+        ], rows=[])
+
+        count, size = bk.stats()
+        self.stats_text = ft.Text(f"Всего бэкапов: {count}, суммарно {size/1048576:.1f} МБ",
+                                  size=13, color=ft.Colors.GREY_500)
+
+        self.controls = [
+            ft.Text("Резервное копирование", size=28, weight=ft.FontWeight.BOLD),
+            ft.Row([self.srv_dd, self.paths_tf, self.download_cb,
+                    ft.FilledButton("Создать бэкап", icon=ft.Icons.BACKUP,
+                                    on_click=self._run)]),
+            self.stats_text,
+            self.log_container,
+            ft.Text("История", weight=ft.FontWeight.BOLD, size=16),
+            ft.Card(content=ft.Container(padding=10, content=self.table)),
+        ]
+        self._reload()
+
+    def _reload(self):
+        servers = {s.id: s.name for s in servers_core.list_servers()}
+        self.table.rows = []
+        for r in bk.list_backups():
+            color = ft.Colors.GREEN_300 if r.status == "success" else \
+                    ft.Colors.RED_300 if r.status == "error" else ft.Colors.GREY_500
+            self.table.rows.append(ft.DataRow(cells=[
+                ft.DataCell(ft.Text(f"{r.created_at:%d.%m %H:%M}", size=11)),
+                ft.DataCell(ft.Text(servers.get(r.server_id, "?"), size=12)),
+                ft.DataCell(ft.Text(r.paths, size=11)),
+                ft.DataCell(ft.Text(f"{r.size/1048576:.1f} МБ" if r.size else "—", size=11)),
+                ft.DataCell(ft.Text(r.status, size=11, color=color)),
+                ft.DataCell(ft.Text(r.file or "—", size=10, color=ft.Colors.GREY_500)),
+            ]))
+        self._page.update()
+
+    def _run(self, e):
+        if not self.srv_dd.value:
+            snack(self._page, "Выберите сервер", error=True)
+            return
+        srv = servers_core.get_server(int(self.srv_dd.value))
+        paths = self.paths_tf.value.strip()
+        if not paths:
+            snack(self._page, "Укажите пути", error=True)
+            return
+        self.log_container.visible = True
+        self._page.update()
+
+        async def job(log):
+            rec = await bk.run_backup(srv, paths, self.download_cb.value, log)
+            log(f"=== {rec.status} ===" if rec else "=== error ===")
+
+        tasks.start("backup", f"бэкап {paths}", srv.id, job,
+                    on_log=lambda l: (append_log(self.log, l), self._page.update()),
+                    on_done=lambda r: self._reload())
+        snack(self._page, "Бэкап запущен")

app/ui/pages/dashboard.py

@@ -0,0 +1,128 @@
+"""Дашборд: карточки серверов с health-check и метриками."""
+import asyncio
+
+import flet as ft
+
+from app.core import servers as servers_core
+from app.core import monitor
+from app.core.ssh import SSHClient, check_server
+from app.ui.components import fmt_mb, snack
+
+
+class DashboardPage(ft.Column):
+    def __init__(self, page: ft.Page, go, group_filter: str = "Все"):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO)
+        self._page = page
+        self.go = go
+        self.group_filter = group_filter
+        self.cards = ft.Row(wrap=True, spacing=16, run_spacing=16)
+        self.controls = [
+            ft.Row([
+                ft.Text("Дашборд", size=28, weight=ft.FontWeight.BOLD),
+                ft.IconButton(ft.Icons.REFRESH, tooltip="Обновить",
+                              on_click=lambda e: self.refresh()),
+            ]),
+            self.cards,
+        ]
+        self.refresh()
+
+    def refresh(self):
+        servers = servers_core.list_servers()
+        if self.group_filter != "Все":
+            servers = [s for s in servers
+                       if self.group_filter in [t.strip() for t in (s.tags or "").split(",")]]
+        self.cards.controls = [self._placeholder(s) for s in servers]
+        self._page.update()
+        for srv, card in zip(servers, self.cards.controls):
+            self._page.run_task(self._fill, srv, card)
+
+    def _placeholder(self, srv):
+        note_preview = (srv.note[:60] + "…") if len(srv.note) > 60 else srv.note
+        return ft.Card(
+            content=ft.Container(
+                width=340, padding=16,
+                content=ft.Column([
+                    ft.Row([
+                        ft.Icon(ft.Icons.CIRCLE, color=ft.Colors.GREY, size=14),
+                        ft.Text(srv.name, size=18, weight=ft.FontWeight.BOLD),
+                        ft.Text(f"{srv.host}:{srv.port}", size=12,
+                                color=ft.Colors.GREY_500),
+                        ft.Container(expand=True),
+                        ft.IconButton(ft.Icons.NOTE_ALT_OUTLINED, icon_size=18,
+                                      tooltip="Заметка",
+                                      on_click=lambda e, s=srv: self._note_dialog(s)),
+                    ]),
+                    ft.Text(note_preview, size=11, color=ft.Colors.GREY_500,
+                            visible=bool(srv.note)),
+                    ft.ProgressBar(height=3),
+                ]),
+                on_click=lambda e: self.go("server_detail", srv.id),
+            )
+        )
+
+    def _note_dialog(self, srv):
+        tf = ft.TextField(label="Заметка", value=srv.note, multiline=True,
+                          min_lines=3, max_lines=5, width=400, autofocus=True)
+        def save(e):
+            servers_core.update_server(srv.id, note=tf.value)
+            self._page.pop_dialog()
+            self.refresh()
+            snack(self._page, "Заметка сохранена")
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text(f"Заметка: {srv.name}"), content=tf,
+            actions=[
+                ft.TextButton("Отмена", on_click=lambda e: self._page.pop_dialog()),
+                ft.FilledButton("Сохранить", on_click=save),
+            ],
+        )
+        self._page.show_dialog(dlg)
+
+    async def _fill(self, srv, card):
+        info = await check_server(srv)
+        if not info.get("online"):
+            card.content.content.controls[1] = ft.Text(
+                f"❌ {info.get('error', 'недоступен')}", color=ft.Colors.RED_400, size=13)
+            card.content.content.controls[0].controls[0] = ft.Icon(
+                ft.Icons.CIRCLE, color=ft.Colors.RED_400, size=14)
+            self._page.update()
+            return
+
+        # метрики
+        snap = monitor.latest(srv.id)
+        try:
+            async with SSHClient(srv) as c:
+                snap = await monitor.collect(c, srv.id)
+        except Exception:
+            pass
+
+        def bar(label, pct, color):
+            return ft.Column([
+                ft.Row([
+                    ft.Text(label, size=12, width=45),
+                    ft.ProgressBar(value=pct / 100, height=6, expand=True,
+                                   color=color, bgcolor=ft.Colors.GREY_800),
+                    ft.Text(f"{pct:.0f}%", size=12, width=40, text_align=ft.TextAlign.RIGHT),
+                ]),
+            ], spacing=2)
+
+        rows = [ft.Text(f"{info['os']}  •  {info['uptime']}", size=12,
+                        color=ft.Colors.GREY_400)]
+        if snap:
+            rows += [
+                ft.Container(height=4),
+                bar("CPU", snap.cpu_percent, ft.Colors.BLUE_400),
+                bar("RAM", snap.mem_percent, ft.Colors.PURPLE_300),
+                bar("Диск", snap.disk_percent,
+                    ft.Colors.RED_400 if snap.disk_percent > 85 else ft.Colors.GREEN_400),
+                ft.Text(
+                    f"RAM {fmt_mb(snap.mem_used_mb)} / {fmt_mb(snap.mem_total_mb)}"
+                    f"  •  load {snap.load1:.2f}",
+                    size=11, color=ft.Colors.GREY_500),
+            ]
+        card.content.content.controls[0].controls[0] = ft.Icon(
+            ft.Icons.CIRCLE, color=ft.Colors.GREEN_400, size=14)
+        # сохраняем заметку (controls[1]) — она идёт после заголовка
+        note_ctrl = card.content.content.controls[1]
+        card.content.content.controls[2:] = rows
+        card.content.content.controls[1] = note_ctrl
+        self._page.update()

app/ui/pages/diff.py

@@ -0,0 +1,84 @@
+"""Сравнение пакетов между серверами."""
+import flet as ft
+
+from app.core import servers as servers_core
+from app.core.diff import diff_servers
+from app.core.ssh import SSHClient
+from app.ui.components import snack
+
+
+class DiffPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        servers = servers_core.list_servers()
+        opts = [ft.dropdown.Option(str(s.id), s.name) for s in servers]
+
+        self.dd_a = ft.Dropdown(label="Сервер A", options=opts, width=250)
+        self.dd_b = ft.Dropdown(label="Сервер B", options=opts, width=250)
+        self.user_only = ft.Checkbox(label="только пользовательские пакеты", value=True)
+        self.result = ft.Column(spacing=8)
+
+        self.controls = [
+            ft.Text("Сравнение серверов", size=28, weight=ft.FontWeight.BOLD),
+            ft.Row([
+                self.dd_a, self.dd_b, self.user_only,
+                ft.FilledButton("Сравнить", icon=ft.Icons.COMPARE_ARROWS,
+                                on_click=self._compare),
+            ]),
+            self.result,
+        ]
+
+    def _compare(self, e):
+        if not self.dd_a.value or not self.dd_b.value or self.dd_a.value == self.dd_b.value:
+            snack(self._page, "Выберите два разных сервера", error=True)
+            return
+        self.result.controls = [ft.ProgressBar()]
+        self._page.update()
+
+        async def _do():
+            a = servers_core.get_server(int(self.dd_a.value))
+            b = servers_core.get_server(int(self.dd_b.value))
+            async with SSHClient(a) as ca, SSHClient(b) as cb:
+                diff = await diff_servers(ca, cb, self.user_only.value)
+
+            self.result.controls = [
+                ft.Row([
+                    self._section(f"Только на {a.name} ({len(diff.only_a)})",
+                                  [f"{p.name} {p.version}" for p in diff.only_a],
+                                  ft.Colors.BLUE_300),
+                    self._section(f"Только на {b.name} ({len(diff.only_b)})",
+                                  [f"{p.name} {p.version}" for p in diff.only_b],
+                                  ft.Colors.GREEN_300),
+                ], vertical_alignment=ft.CrossAxisAlignment.START),
+                ft.Text(f"Различаются версии ({len(diff.version_mismatch)})",
+                        weight=ft.FontWeight.BOLD, size=16),
+                ft.DataTable(columns=[
+                    ft.DataColumn(ft.Text("Пакет")),
+                    ft.DataColumn(ft.Text(a.name)),
+                    ft.DataColumn(ft.Text(b.name)),
+                ], rows=[
+                    ft.DataRow(cells=[
+                        ft.DataCell(ft.Text(m.name)),
+                        ft.DataCell(ft.Text(m.version_a, size=12)),
+                        ft.DataCell(ft.Text(m.version_b, size=12,
+                                            color=ft.Colors.ORANGE_300)),
+                    ]) for m in diff.version_mismatch[:100]
+                ]) if diff.version_mismatch else ft.Text("версии совпадают",
+                                                         color=ft.Colors.GREY_500),
+            ]
+            self._page.update()
+        self._page.run_task(_do)
+
+    def _section(self, title, items, color):
+        return ft.Container(expand=True, content=ft.Column([
+            ft.Text(title, weight=ft.FontWeight.BOLD, color=color),
+            ft.Container(
+                height=300, border=ft.Border.all(1, ft.Colors.GREY_800),
+                border_radius=8, padding=8,
+                content=ft.Column([
+                    ft.Text(i, size=11, font_family="Consolas") for i in items
+                ] or [ft.Text("—", color=ft.Colors.GREY_600)],
+                    scroll=ft.ScrollMode.AUTO, spacing=1),
+            ),
+        ]))

app/ui/pages/gitea.py

@@ -0,0 +1,168 @@
+"""Gitea: деплой compose-проектов."""
+import flet as ft
+
+from app.core import gitea
+from app.core import servers as servers_core
+from app.core.ssh import SSHClient
+from app.core.tasks import tasks
+from app.ui.components import append_log, log_view, snack
+
+
+class GiteaPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+
+        cfg = gitea.get_config()
+        self.url_tf = ft.TextField(label="URL Gitea", value=cfg["url"], width=350)
+        self.token_tf = ft.TextField(label="API-токен", value=cfg["token"],
+                                     password=True, width=350)
+        self.status = ft.Text("", size=12)
+
+        self.repos_dd = ft.Dropdown(label="Репозиторий", width=350, options=[])
+        self.srv_dd = ft.Dropdown(label="Сервер", width=250, options=[
+            ft.dropdown.Option(str(s.id), s.name) for s in servers_core.list_servers()
+        ])
+        self.branch_tf = ft.TextField(label="Ветка", value="main", width=150)
+        self.compose_tf = ft.TextField(label="Путь к compose", value="docker-compose.yml",
+                                       width=250)
+        self.env_tf = ft.TextField(label=".env (опционально)", multiline=True,
+                                   min_lines=3, max_lines=5, width=450,
+                                   hint_text="KEY=value")
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=200, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False)
+        self.bindings_col = ft.Column(spacing=4)
+
+        self.controls = [
+            ft.Text("Gitea Deploy", size=28, weight=ft.FontWeight.BOLD),
+            ft.Row([self.url_tf, self.token_tf,
+                    ft.FilledButton("Сохранить и проверить", on_click=self._save_cfg)]),
+            self.status,
+            ft.Divider(),
+            ft.Row([self.repos_dd,
+                    ft.IconButton(ft.Icons.REFRESH, tooltip="Загрузить репозитории",
+                                  on_click=self._load_repos)]),
+            ft.Row([self.srv_dd, self.branch_tf, self.compose_tf]),
+            self.env_tf,
+            ft.FilledButton("Деплой", icon=ft.Icons.ROCKET_LAUNCH,
+                            on_click=self._deploy),
+            self.log_container,
+            ft.Divider(),
+            ft.Text("Webhook-автодеплой (push → redeploy)", weight=ft.FontWeight.BOLD, size=16),
+            ft.Text("Приложение слушает порт 9100. В Gitea: репозиторий → Настройки → Webhooks → "
+                    "создать: http://<этот-ПК>:9100/webhooks/gitea, событие push.",
+                    size=12, color=ft.Colors.GREY_500),
+            ft.Row([
+                ft.FilledButton("Добавить привязку", icon=ft.Icons.ADD,
+                                on_click=self._binding_dialog),
+                ft.IconButton(ft.Icons.REFRESH, on_click=lambda e: self._load_bindings()),
+            ]),
+            self.bindings_col,
+        ]
+        self._load_bindings()
+
+    def _load_bindings(self):
+        from app.core import webhook as wh
+        from app.core import servers as servers_core
+        servers = {s.id: s.name for s in servers_core.list_servers()}
+        self.bindings_col.controls = []
+        for b in wh.list_bindings():
+            self.bindings_col.controls.append(ft.Card(content=ft.Container(
+                padding=10,
+                content=ft.Row([
+                    ft.Icon(ft.Icons.LINK, color=ft.Colors.BLUE_300),
+                    ft.Text(f"{b.repo}@{b.branch} → {servers.get(b.server_id, '?')}",
+                            size=13, expand=True),
+                    ft.Text(b.compose_path, size=11, color=ft.Colors.GREY_500),
+                    ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=16,
+                                  on_click=lambda e, bid=b.id: self._del_binding(bid)),
+                ]),
+            )))
+        if not self.bindings_col.controls:
+            self.bindings_col.controls.append(
+                ft.Text("привязок нет — push в репозиторий не будет триггерить деплой",
+                        size=12, color=ft.Colors.GREY_500))
+        self._page.update()
+
+    def _del_binding(self, bid):
+        from app.core import webhook as wh
+        wh.delete_binding(bid)
+        self._load_bindings()
+
+    def _binding_dialog(self, e):
+        from app.core import webhook as wh
+        from app.core import servers as servers_core
+        repo_tf = ft.TextField(label="Репозиторий (owner/name)", width=300,
+                               hint_text="dimon/myapp")
+        srv_dd = ft.Dropdown(label="Сервер", width=250, options=[
+            ft.dropdown.Option(str(s.id), s.name) for s in servers_core.list_servers()
+        ])
+        branch_tf = ft.TextField(label="Ветка", value="main", width=150)
+        compose_tf = ft.TextField(label="compose-файл", value="docker-compose.yml", width=250)
+        env_tf = ft.TextField(label=".env (опционально)", multiline=True,
+                              min_lines=2, max_lines=4, width=350)
+
+        def save(e):
+            if not repo_tf.value or not srv_dd.value:
+                return
+            wh.add_binding(repo=repo_tf.value.strip(),
+                           server_id=int(srv_dd.value),
+                           branch=branch_tf.value, compose_path=compose_tf.value,
+                           env=env_tf.value or "")
+            self._page.pop_dialog()
+            self._load_bindings()
+            snack(self._page, "Привязка добавлена")
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Привязка webhook"),
+            content=ft.Column([repo_tf, srv_dd, branch_tf, compose_tf, env_tf], tight=True),
+            actions=[
+                ft.TextButton("Отмена", on_click=lambda e: self._page.pop_dialog()),
+                ft.FilledButton("Сохранить", on_click=save),
+            ],
+        )
+        self._page.show_dialog(dlg)
+
+    def _save_cfg(self, e):
+        gitea.save_config(self.url_tf.value, self.token_tf.value)
+        async def _t():
+            ok, msg = await gitea.test_connection()
+            self.status.value = ("✅ " if ok else "❌ ") + msg
+            self.status.color = ft.Colors.GREEN_300 if ok else ft.Colors.RED_300
+            self._page.update()
+        self._page.run_task(_t)
+
+    def _load_repos(self, e):
+        async def _l():
+            try:
+                repos = await gitea.list_repos()
+                self.repos_dd.options = [
+                    ft.dropdown.Option(r["full_name"],
+                                       f"{r['full_name']} ({r['default_branch']})")
+                    for r in repos
+                ]
+                self._repos = {r["full_name"]: r for r in repos}
+                self.status.value = f"загружено {len(repos)} репозиториев"
+            except Exception as ex:
+                self.status.value = f"ошибка: {ex}"
+            self._page.update()
+        self._page.run_task(_l)
+
+    def _deploy(self, e):
+        if not self.repos_dd.value or not self.srv_dd.value:
+            snack(self._page, "Выберите репозиторий и сервер", error=True)
+            return
+        repo = self._repos[self.repos_dd.value]
+        srv = servers_core.get_server(int(self.srv_dd.value))
+        self.log_container.visible = True
+
+        async def job(log):
+            async with SSHClient(srv) as c:
+                await gitea.deploy(c, repo["clone_url"], repo["name"],
+                                   self.branch_tf.value, self.compose_tf.value,
+                                   self.env_tf.value or None, log)
+        tasks.start("gitea", f"deploy {repo['name']}", srv.id, job,
+                    on_log=lambda l: (append_log(self.log, l), self._page.update()))
+        snack(self._page, f"Деплой {repo['name']} запущен")

app/ui/pages/group_ops.py

@@ -0,0 +1,131 @@
+"""Групповые операции по серверам."""
+import flet as ft
+
+from app.core import servers as servers_core
+from app.core.group_ops import (GroupResult, op_apt_update, op_install_package,
+                                op_reboot, op_shell, op_upgrade, run_group)
+from app.ui.components import snack
+
+
+class GroupOpsPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        self.go = go
+
+        servers = servers_core.list_servers()
+        self.checks = {s.id: ft.Checkbox(label=f"{s.name} ({s.host})", value=False,
+                                         data=s.id) for s in servers}
+
+        self.op_dd = ft.Dropdown(
+            label="Операция", value="update", width=300,
+            options=[
+                ft.dropdown.Option("update", "apt update"),
+                ft.dropdown.Option("upgrade", "upgrade"),
+                ft.dropdown.Option("dist", "dist-upgrade"),
+                ft.dropdown.Option("reboot", "reboot (с ожиданием)"),
+                ft.dropdown.Option("shell", "произвольная команда"),
+                ft.dropdown.Option("install", "установить пакет"),
+            ],
+            on_select=lambda e: self._toggle_param(),
+        )
+        self.param_tf = ft.TextField(label="Команда / пакет", visible=False, width=400)
+        self.rolling_cb = ft.Checkbox(label="Rolling (по одному, ждать возврата)", value=False)
+        self.failfast_cb = ft.Checkbox(label="Остановиться при первой ошибке", value=False)
+        self.results_col = ft.Column(spacing=6)
+
+        self.controls = [
+            ft.Text("Групповые операции", size=28, weight=ft.FontWeight.BOLD),
+            ft.Row([
+                ft.Card(content=ft.Container(padding=14, width=380, content=ft.Column([
+                    ft.Text("Серверы", weight=ft.FontWeight.BOLD),
+                    *self.checks.values(),
+                    ft.TextButton("выбрать все", on_click=lambda e: self._select_all(True)),
+                    ft.TextButton("снять все", on_click=lambda e: self._select_all(False)),
+                ]))),
+                ft.Card(content=ft.Container(padding=14, expand=True, content=ft.Column([
+                    ft.Text("Операция", weight=ft.FontWeight.BOLD),
+                    self.op_dd,
+                    self.param_tf,
+                    self.rolling_cb,
+                    self.failfast_cb,
+                    ft.FilledButton("Запустить", icon=ft.Icons.PLAY_ARROW,
+                                    on_click=self._run),
+                ], spacing=10))),
+            ], vertical_alignment=ft.CrossAxisAlignment.START),
+            ft.Text("Результаты", size=18, weight=ft.FontWeight.BOLD),
+            self.results_col,
+        ]
+
+    def _select_all(self, v):
+        for cb in self.checks.values():
+            cb.value = v
+        self._page.update()
+
+    def _toggle_param(self):
+        self.param_tf.visible = self.op_dd.value in ("shell", "install")
+        self._page.update()
+
+    def _run(self, e):
+        selected = [s for s in servers_core.list_servers()
+                    if self.checks.get(s.id) and self.checks[s.id].value]
+        if not selected:
+            snack(self._page, "Выберите хотя бы один сервер", error=True)
+            return
+
+        op_name = self.op_dd.value
+        if op_name == "update":
+            op = op_apt_update()
+        elif op_name == "upgrade":
+            op = op_upgrade(False)
+        elif op_name == "dist":
+            op = op_upgrade(True)
+        elif op_name == "reboot":
+            op = op_reboot(wait=True)
+        elif op_name == "shell":
+            if not self.param_tf.value:
+                snack(self._page, "Введите команду", error=True)
+                return
+            op = op_shell(self.param_tf.value)
+        else:
+            if not self.param_tf.value:
+                snack(self._page, "Введите имя пакета", error=True)
+                return
+            op = op_install_package(self.param_tf.value.split())
+
+        self.results_col.controls = [
+            ft.Text(f"запущено на {len(selected)} серверах…", color=ft.Colors.GREY_500)]
+        self._page.update()
+
+        async def job():
+            def on_status(res: GroupResult):
+                self._render_results(res)
+            res = await run_group(
+                selected, op,
+                rolling=self.rolling_cb.value,
+                fail_fast=self.failfast_cb.value,
+                on_status=on_status,
+            )
+            self._render_results(res)
+            snack(self._page, f"готово: ✅{res.ok_count} ❌{res.err_count}")
+        self._page.run_task(job)
+
+    def _render_results(self, res: GroupResult):
+        self.results_col.controls = []
+        for r in res.results.values():
+            icon = {"pending": ft.Icons.HOURGLASS_EMPTY, "running": ft.Icons.SYNC,
+                    "success": ft.Icons.CHECK_CIRCLE, "error": ft.Icons.ERROR}.get(r.status)
+            color = {"success": ft.Colors.GREEN_400, "error": ft.Colors.RED_400,
+                     "running": ft.Colors.BLUE_300}.get(r.status, ft.Colors.GREY_500)
+            log_preview = r.log.strip().splitlines()[-3:] if r.log.strip() else []
+            self.results_col.controls.append(ft.Card(content=ft.Container(
+                padding=10,
+                content=ft.Column([
+                    ft.Row([ft.Icon(icon, color=color, size=18),
+                            ft.Text(r.name, weight=ft.FontWeight.BOLD),
+                            ft.Text(r.status, size=12, color=color)]),
+                    *[ft.Text(l, size=10, font_family="Consolas",
+                              color=ft.Colors.GREY_500) for l in log_preview],
+                ], spacing=2),
+            )))
+        self._page.update()

app/ui/pages/playbooks.py

@@ -0,0 +1,131 @@
+"""Плейбуки: список, редактор, запуск."""
+import flet as ft
+
+from app.core import playbooks as pb
+from app.core import servers as servers_core
+from app.core.ssh import SSHClient
+from app.core.tasks import tasks
+from app.ui.components import append_log, log_view, snack
+
+
+class PlaybooksPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, spacing=12)
+        self._page = page
+        self.go = go
+
+        self.list_col = ft.Column(spacing=6, scroll=ft.ScrollMode.AUTO)
+        self.editor = ft.TextField(multiline=True, min_lines=18, max_lines=18,
+                                   text_size=12,
+                                   text_style=ft.TextStyle(font_family="Consolas"),
+                                   expand=True)
+        self.editor_name = ft.Text("", weight=ft.FontWeight.BOLD)
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=180, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False)
+
+        self.controls = [
+            ft.Text("Плейбуки", size=28, weight=ft.FontWeight.BOLD),
+            ft.Row([
+                ft.Container(width=300, content=ft.Column([
+                    ft.FilledButton("Новый плейбук", icon=ft.Icons.ADD,
+                                    on_click=self._new),
+                    ft.Divider(),
+                    self.list_col,
+                ])),
+                ft.VerticalDivider(width=1),
+                ft.Container(expand=True, content=ft.Column([
+                    ft.Row([
+                        self.editor_name,
+                        ft.Container(expand=True),
+                        ft.OutlinedButton("Сохранить", icon=ft.Icons.SAVE,
+                                          on_click=self._save),
+                        ft.FilledButton("Запустить", icon=ft.Icons.PLAY_ARROW,
+                                        on_click=self._run_dialog),
+                    ]),
+                    self.editor,
+                    self.log_container,
+                ], expand=True)),
+            ], expand=True),
+        ]
+        self._current = None
+        self._reload_list()
+
+    def _reload_list(self):
+        self.list_col.controls = [
+            ft.ListTile(
+                title=ft.Text(name, size=13),
+                subtitle=ft.Text("встроенный" if name in pb.BUILTIN else "пользовательский",
+                                 size=10),
+                dense=True,
+                on_click=lambda e, n=name: self._open(n),
+            ) for name in pb.list_playbooks()
+        ]
+        self._page.update()
+
+    def _open(self, name):
+        import yaml
+        self._current = name
+        data = pb.load(name)
+        self.editor.value = pb.BUILTIN.get(name) or (
+            pb.PLAYBOOKS_DIR / f"{name}.yml").read_text(encoding="utf-8")
+        self.editor_name.value = name
+        self._page.update()
+
+    def _new(self, e):
+        name_tf = ft.TextField(label="Имя", autofocus=True)
+        def create(e):
+            self._current = name_tf.value
+            self.editor_name.value = name_tf.value
+            self.editor.value = 'name: "Новый плейбук"\nsteps:\n  - name: Проверка\n    shell: "uptime"\n'
+            self._page.pop_dialog()
+        dlg = ft.AlertDialog(modal=True, title=ft.Text("Имя плейбука"), content=name_tf,
+                             actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                                      ft.FilledButton("Создать", on_click=create)])
+        self._page.show_dialog(dlg)
+
+    def _save(self, e):
+        if not self._current or self._current in pb.BUILTIN:
+            snack(self._page, "Встроенный плейбук нельзя перезаписать — создайте копию",
+                  error=True)
+            return
+        try:
+            pb.save(self._current, self.editor.value)
+            snack(self._page, "Сохранено")
+            self._reload_list()
+        except Exception as ex:
+            snack(self._page, f"Ошибка YAML: {ex}", error=True)
+
+    def _run_dialog(self, e):
+        if not self._current:
+            return
+        servers = servers_core.list_servers()
+        checks = {s.id: ft.Checkbox(label=s.name, value=False) for s in servers}
+        def run(e):
+            selected = [s for s in servers if checks[s.id].value]
+            if not selected:
+                snack(self._page, "Выберите сервер", error=True)
+                return
+            self._page.pop_dialog()
+            self._run_on(selected)
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text(f"Запустить «{self._current}»"),
+            content=ft.Column(list(checks.values()), tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                     ft.FilledButton("Запустить", on_click=run)],
+        )
+        self._page.show_dialog(dlg)
+
+    def _run_on(self, servers):
+        self.log_container.visible = True
+        data = pb.load(self._current)
+        for srv in servers:
+            async def job(log, srv=srv):
+                async with SSHClient(srv) as c:
+                    await pb.run_playbook(c, srv, data, log)
+            tasks.start("playbook", f"плейбук {self._current}", srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()))
+
+    def _close(self, dlg):
+        self._page.pop_dialog()

app/ui/pages/portainer.py

@@ -0,0 +1,106 @@
+"""Portainer: статус, открытие в браузере, установка/перезапуск."""
+import flet as ft
+
+from app.core.ssh import SSHClient
+from app.core import docker_svc as d
+from app.db.models import Server
+from app.ui.components import snack
+
+PORTAINER_PORT = 9000
+
+
+class PortainerPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        self.go = go
+        self.cards_col = ft.Column(spacing=10)
+        self.controls = [
+            ft.Text("Portainer", size=28, weight=ft.FontWeight.BOLD),
+            ft.Row([
+                ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._reload()),
+            ]),
+            self.cards_col,
+        ]
+        self._reload()
+
+    def _reload(self):
+        from app.core import servers as servers_core
+        self.cards_col.controls = []
+        for srv in servers_core.list_servers():
+            self.cards_col.controls.append(self._card_placeholder(srv))
+        self._page.update()
+        from app.core import servers as servers_core
+        for srv, card in zip(servers_core.list_servers(), self.cards_col.controls):
+            self._page.run_task(self._fill, srv, card)
+
+    def _card_placeholder(self, srv):
+        return ft.Card(content=ft.Container(
+            padding=14, width=500,
+            content=ft.Column([
+                ft.Text(srv.name, weight=ft.FontWeight.BOLD, size=16),
+                ft.ProgressBar(height=3),
+            ]),
+        ))
+
+    async def _fill(self, srv, card):
+        url = f"http://{srv.host}:{PORTAINER_PORT}"
+        try:
+            async with SSHClient(srv) as c:
+                containers = await d.list_containers(c)
+                portainer = next((x for x in containers if "portainer" in x["Names"].lower()), None)
+                if not portainer:
+                    card.content.content.controls[1] = ft.Column([
+                        ft.Text("Portainer не установлен", color=ft.Colors.GREY_500),
+                        ft.FilledButton("Установить", icon=ft.Icons.DOWNLOAD,
+                                        on_click=lambda e, s=srv: self._install(s)),
+                    ])
+                else:
+                    running = "Up" in portainer["Status"]
+                    cid = portainer["ID"]
+                    card.content.content.controls[1] = ft.Column([
+                        ft.Row([
+                            ft.Icon(ft.Icons.CIRCLE, size=12,
+                                    color=ft.Colors.GREEN_400 if running else ft.Colors.RED_400),
+                            ft.Text(portainer["Status"], size=12),
+                        ]),
+                        ft.Row([
+                            ft.FilledButton("Открыть в браузере", icon=ft.Icons.OPEN_IN_BROWSER,
+                                            on_click=lambda e, u=url: self._page.launch_url(u)),
+                            ft.OutlinedButton(
+                                "Перезапустить" if running else "Запустить",
+                                on_click=lambda e, s=srv, c=cid, a="restart" if running else "start":
+                                self._action(s, c, a)),
+                        ]),
+                        ft.Text(url, size=11, color=ft.Colors.BLUE_300, selectable=True),
+                    ])
+        except Exception as e:
+            card.content.content.controls[1] = ft.Text(f"ошибка: {e}", size=12,
+                                                       color=ft.Colors.RED_300)
+        self._page.update()
+
+    def _install(self, srv):
+        from app.core.tasks import tasks
+        from app.ui.components import append_log, log_view
+        async def job(log):
+            async with SSHClient(srv) as c:
+                log("$ docker volume create portainer_data")
+                await c.sudo("docker volume create portainer_data 2>/dev/null || true")
+                log("$ docker run portainer")
+                r = await c.sudo(
+                    "docker rm -f portainer 2>/dev/null; "
+                    "docker run -d -p 9000:9000 --name portainer --restart=always "
+                    "-v /var/run/docker.sock:/var/run/docker.sock "
+                    "-v portainer_data:/data portainer/portainer-ce:lts", timeout=600)
+                log(r.stdout + r.stderr)
+        tasks.start("portainer", "установка Portainer", srv.id, job,
+                    on_done=lambda r: self._reload())
+        snack(self._page, f"Установка Portainer на {srv.name} запущена")
+
+    def _action(self, srv, cid, action):
+        async def _do():
+            async with SSHClient(srv) as c:
+                await d.container_action(c, cid, action)
+            self._reload()
+        self._page.run_task(_do)

app/ui/pages/proxmox_page.py

@@ -0,0 +1,243 @@
+"""Proxmox VE: ноды, VM/LXC, управление питанием, добавление в серверы."""
+import flet as ft
+
+from app.core import proxmox as pve_core
+from app.core import servers as servers_core
+from app.ui.components import confirm_dialog, snack
+
+
+class ProxmoxPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        self.go = go
+
+        cfg = pve_core.get_config()
+        self.host_tf = ft.TextField(
+            label="Хост (IP или FQDN)", value=cfg["host"],
+            width=280, hint_text="192.168.1.100  — без http://",
+        )
+        self.user_tf = ft.TextField(label="Пользователь", value=cfg["user"], width=200)
+        self.token_name_tf = ft.TextField(label="Token ID", value=cfg["token_name"],
+                                          width=200, hint_text="dm-manager")
+        self.token_val_tf = ft.TextField(label="Token Secret", value=cfg["token_value"],
+                                         password=True, width=350)
+        self.ssl_cb = ft.Checkbox(label="Проверять SSL", value=cfg["verify_ssl"])
+        self.conn_status = ft.Text("", size=12)
+
+        # подсказка про права токена
+        self.perm_hint = ft.Container(
+            visible=False,
+            content=ft.Column([
+                ft.Text("403 Forbidden — у API-токена нет прав.", weight=ft.FontWeight.BOLD,
+                        color=ft.Colors.ORANGE_300, size=13),
+                ft.Text(
+                    "В Proxmox: Datacenter → Permissions → API Tokens → ваш токен → "
+                    "убедитесь, что у токена есть роль PVEAuditor (или PVEAdmin) на пути /.\n"
+                    "Если используете «Privilege Separation» — добавьте права отдельно: "
+                    "Permissions → Add → API Token Permission.",
+                    size=12, color=ft.Colors.GREY_400),
+            ], spacing=4),
+            padding=10, border=ft.Border.all(1, ft.Colors.ORANGE_800), border_radius=6,
+        )
+
+        self.nodes_col = ft.Column(spacing=12)
+
+        self.controls = [
+            ft.Text("Proxmox VE", size=28, weight=ft.FontWeight.BOLD),
+            ft.Card(content=ft.Container(padding=14, content=ft.Column([
+                ft.Text("Подключение", weight=ft.FontWeight.BOLD),
+                ft.Row([self.host_tf, self.user_tf]),
+                ft.Row([self.token_name_tf, self.token_val_tf]),
+                ft.Row([
+                    self.ssl_cb,
+                    ft.FilledButton("Сохранить и проверить", icon=ft.Icons.CHECK,
+                                    on_click=self._save_cfg),
+                    ft.OutlinedButton("Обновить список", icon=ft.Icons.REFRESH,
+                                      on_click=lambda e: self._reload()),
+                ]),
+                self.conn_status,
+                self.perm_hint,
+            ], spacing=8))),
+            self.nodes_col,
+        ]
+
+    def _save_cfg(self, e):
+        pve_core.save_config(self.host_tf.value, self.user_tf.value,
+                             self.token_name_tf.value, self.token_val_tf.value,
+                             self.ssl_cb.value)
+        async def _t():
+            ok, msg = pve_core.test_connection()
+            self.conn_status.value = ("✅ " if ok else "❌ ") + msg
+            self.conn_status.color = ft.Colors.GREEN_300 if ok else ft.Colors.RED_300
+            self._page.update()
+            if ok:
+                self._reload()
+        self._page.run_task(_t)
+
+    def _reload(self):
+        self.nodes_col.controls = [ft.ProgressBar()]
+        self._page.update()
+        self._page.run_task(self._load_nodes)
+
+    async def _load_nodes(self):
+        try:
+            nodes = pve_core.nodes()
+        except Exception as e:
+            err = str(e)
+            self.nodes_col.controls = [ft.Text(f"❌ {err}", color=ft.Colors.RED_300)]
+            # показать подсказку при 403
+            if "403" in err or "Permission check failed" in err:
+                self.perm_hint.visible = True
+            self._page.update()
+            return
+
+        self.nodes_col.controls = []
+        for node in nodes:
+            name = node["node"]
+            self.nodes_col.controls.append(self._node_card(name, node))
+        self._page.update()
+        # загрузить VM каждой ноды
+        for i, node in enumerate(nodes):
+            self._page.run_task(self._fill_node, node["node"], i)
+
+    def _node_card(self, name, node):
+        return ft.Card(content=ft.Container(
+            padding=14,
+            content=ft.Column([
+                ft.Row([
+                    ft.Icon(ft.Icons.COMPUTER, size=20),
+                    ft.Text(name, size=18, weight=ft.FontWeight.BOLD),
+                    ft.Text(f"uptime: {node.get('uptime', 0)//3600}ч", size=11,
+                            color=ft.Colors.GREY_500),
+                ]),
+                ft.ProgressBar(height=3),
+            ]),
+        ))
+
+    async def _fill_node(self, node_name, card_idx):
+        try:
+            st = pve_core.node_status(node_name)
+            vms = pve_core.vms(node_name)
+        except Exception as e:
+            self.nodes_col.controls[card_idx].content.content.controls[1] = \
+                ft.Text(f"ошибка: {e}", size=12, color=ft.Colors.RED_300)
+            self._page.update()
+            return
+
+        cpu_pct = (st.get("cpu", 0) or 0) * 100
+        mem_used = st.get("memory", {}).get("used", 0) / 1073741824
+        mem_total = st.get("memory", {}).get("total", 1) / 1073741824
+
+        def bar(label, pct, color):
+            return ft.Row([
+                ft.Text(label, size=11, width=40),
+                ft.ProgressBar(value=min(pct / 100, 1.0), height=6, expand=True,
+                               color=color, bgcolor=ft.Colors.GREY_800),
+                ft.Text(f"{pct:.0f}%", size=11, width=38, text_align=ft.TextAlign.RIGHT),
+            ])
+
+        rows = [
+            bar("CPU", cpu_pct, ft.Colors.BLUE_400),
+            bar("RAM", mem_used * 100 / mem_total, ft.Colors.PURPLE_300),
+            ft.Text(f"RAM {mem_used:.1f}/{mem_total:.1f} ГБ", size=11,
+                    color=ft.Colors.GREY_500),
+            ft.Divider(),
+            ft.Text(f"Виртуальные машины ({len(vms)})", weight=ft.FontWeight.BOLD),
+        ]
+
+        for vm in vms:
+            rows.append(self._vm_row(node_name, vm))
+
+        self.nodes_col.controls[card_idx].content.content.controls[1] = \
+            ft.Column(rows, spacing=4)
+        self._page.update()
+
+    def _vm_row(self, node, vm):
+        vmid = vm["vmid"]
+        vm_type = vm["type"]
+        name = vm.get("name", f"vm-{vmid}")
+        running = vm.get("status") == "running"
+        cpu = (vm.get("cpu", 0) or 0) * 100
+        mem = (vm.get("mem", 0) or 0) / 1073741824
+        maxmem = (vm.get("maxmem", 1) or 1) / 1073741824
+
+        icon = ft.Icons.MONITOR if vm_type == "qemu" else ft.Icons.INVENTORY
+        status_color = ft.Colors.GREEN_400 if running else ft.Colors.GREY_500
+
+        return ft.Container(
+            border=ft.Border.all(1, ft.Colors.GREY_800), border_radius=6, padding=8,
+            content=ft.Column([
+                ft.Row([
+                    ft.Icon(icon, size=16, color=status_color),
+                    ft.Text(f"{vmid}  {name}", weight=ft.FontWeight.BOLD, size=13),
+                    ft.Text(f"{'VM' if vm_type == 'qemu' else 'LXC'}  •  "
+                            f"{vm.get('status', '?')}", size=11, color=status_color),
+                    ft.Container(expand=True),
+                    ft.IconButton(ft.Icons.PLAY_ARROW, icon_size=16, tooltip="start",
+                                  visible=not running,
+                                  on_click=lambda e: self._vm_act(node, vmid, vm_type, "start")),
+                    ft.IconButton(ft.Icons.RESTART_ALT, icon_size=16, tooltip="reboot",
+                                  visible=running,
+                                  on_click=lambda e, n=name: self._vm_confirm(node, vmid, vm_type, "reboot", n)),
+                    ft.IconButton(ft.Icons.STOP, icon_size=16, tooltip="shutdown",
+                                  visible=running,
+                                  on_click=lambda e, n=name: self._vm_confirm(node, vmid, vm_type, "shutdown", n)),
+                    ft.IconButton(ft.Icons.POWER_SETTINGS_NEW, icon_size=16, tooltip="stop (жёстко)",
+                                  visible=running,
+                                  on_click=lambda e, n=name: self._vm_confirm(node, vmid, vm_type, "stop", n)),
+                    ft.IconButton(ft.Icons.ADD_CIRCLE_OUTLINE, icon_size=16,
+                                  tooltip="Добавить как сервер",
+                                  on_click=lambda e: self._add_as_server(node, vmid, vm_type, name)),
+                ]),
+                ft.Text(f"CPU {cpu:.1f}%  •  RAM {mem:.1f}/{maxmem:.1f} ГБ",
+                        size=10, color=ft.Colors.GREY_500),
+            ], spacing=2),
+        )
+
+    def _vm_act(self, node, vmid, vm_type, action):
+        async def _do():
+            try:
+                pve_core.vm_action(node, vmid, vm_type, action)
+                snack(self._page, f"{action} отправлен")
+                self._reload()
+            except Exception as e:
+                snack(self._page, f"ошибка: {e}", error=True)
+        self._page.run_task(_do)
+
+    def _vm_confirm(self, node, vmid, vm_type, action, name):
+        def do():
+            self._vm_act(node, vmid, vm_type, action)
+        confirm_dialog(self._page, f"{action} {name}?",
+                       f"VMID {vmid} на ноде {node}", do)
+
+    def _add_as_server(self, node, vmid, vm_type, name):
+        async def _do():
+            ip = pve_core.get_vm_ip(node, vmid, vm_type)
+            if not ip:
+                snack(self._page,
+                      "Не удалось определить IP (установите qemu-guest-agent в VM)",
+                      error=True)
+                return
+            # диалог с предзаполненным IP
+            user_tf = ft.TextField(label="Пользователь SSH", value="root", width=250)
+            pass_tf = ft.TextField(label="Пароль", password=True, width=250)
+            port_tf = ft.TextField(label="Порт SSH", value="22", width=100)
+            def save(e):
+                servers_core.add_server(
+                    name=f"{name} (pve:{node})", host=ip,
+                    port=int(port_tf.value or 22), username=user_tf.value,
+                    password=pass_tf.value or None, tags="proxmox",
+                )
+                self._page.pop_dialog()
+                snack(self._page, f"Сервер {name} ({ip}) добавлен")
+            dlg = ft.AlertDialog(
+                modal=True, title=ft.Text(f"Добавить {name} ({ip})"),
+                content=ft.Column([user_tf, pass_tf, port_tf], tight=True),
+                actions=[
+                    ft.TextButton("Отмена", on_click=lambda e: self._page.pop_dialog()),
+                    ft.FilledButton("Добавить", on_click=save),
+                ],
+            )
+            self._page.show_dialog(dlg)
+        self._page.run_task(_do)

app/ui/pages/reports.py

@@ -0,0 +1,68 @@
+"""Экспорт отчётов: генерация CSV, история."""
+import subprocess
+
+import flet as ft
+
+from app.core import reports as rep
+from app.ui.components import snack
+
+
+class ReportsPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+
+        self.status = ft.Text("", size=13, color=ft.Colors.GREY_500)
+        self.list_col = ft.Column(spacing=4)
+
+        self.controls = [
+            ft.Text("Отчёты", size=28, weight=ft.FontWeight.BOLD),
+            ft.Text("CSV со списком серверов, статусом онлайн, метриками и последними задачами.",
+                    size=13, color=ft.Colors.GREY_500),
+            ft.Row([
+                ft.FilledButton("Сгенерировать отчёт", icon=ft.Icons.SUMMARIZE,
+                                on_click=self._generate),
+                ft.IconButton(ft.Icons.REFRESH, on_click=lambda e: self._reload()),
+            ]),
+            self.status,
+            ft.Divider(),
+            ft.Text("История отчётов", weight=ft.FontWeight.BOLD, size=16),
+            self.list_col,
+        ]
+        self._reload()
+
+    def _generate(self, e):
+        self.status.value = "генерация…"
+        self._page.update()
+
+        async def _do():
+            path = await rep.generate()
+            self.status.value = f"сохранён: {path}"
+            self._reload()
+        self._page.run_task(_do)
+
+    def _reload(self):
+        self.list_col.controls = []
+        for p in rep.list_reports():
+            size_kb = p.stat().st_size // 1024
+            self.list_col.controls.append(
+                ft.ListTile(
+                    leading=ft.Icon(ft.Icons.DESCRIPTION),
+                    title=ft.Text(p.name, size=13),
+                    subtitle=ft.Text(f"{size_kb} КБ", size=11),
+                    dense=True,
+                    trailing=ft.IconButton(
+                        ft.Icons.OPEN_IN_NEW, tooltip="Открыть",
+                        on_click=lambda e, p=p: self._open(p)),
+                )
+            )
+        if not self.list_col.controls:
+            self.list_col.controls.append(
+                ft.Text("отчётов пока нет", color=ft.Colors.GREY_500))
+        self._page.update()
+
+    def _open(self, path):
+        try:
+            subprocess.Popen(["explorer", "/select,", str(path)])
+        except Exception as ex:
+            snack(self._page, f"не удалось открыть: {ex}", error=True)

app/ui/pages/scheduler.py

@@ -0,0 +1,161 @@
+"""Планировщик: задачи по cron, пресеты, запуск."""
+import flet as ft
+from croniter import croniter
+
+from app.core import scheduler as sch
+from app.ui.components import confirm_dialog, snack
+
+
+class SchedulerPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        self.table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Вкл")),
+            ft.DataColumn(ft.Text("Название")),
+            ft.DataColumn(ft.Text("Расписание")),
+            ft.DataColumn(ft.Text("Действие")),
+            ft.DataColumn(ft.Text("Цель")),
+            ft.DataColumn(ft.Text("Последний запуск")),
+            ft.DataColumn(ft.Text("Статус")),
+            ft.DataColumn(ft.Text("")),
+        ], rows=[])
+        self.controls = [
+            ft.Row([
+                ft.Text("Планировщик", size=28, weight=ft.FontWeight.BOLD),
+                ft.FilledButton("Добавить задачу", icon=ft.Icons.ADD,
+                                on_click=self._add_dialog),
+                ft.OutlinedButton("Из пресета", icon=ft.Icons.LIST_ALT,
+                                  on_click=self._preset_dialog),
+                ft.IconButton(ft.Icons.REFRESH, on_click=lambda e: self._reload()),
+            ], alignment=ft.MainAxisAlignment.SPACE_BETWEEN),
+            ft.Card(content=ft.Container(padding=10, content=self.table)),
+        ]
+        self._reload()
+
+    def _reload(self):
+        self.table.rows = []
+        for t in sch.list_tasks():
+            try:
+                nxt = croniter(t.cron).get_next(__import__("datetime").datetime)
+                sched_txt = f"{t.cron}  →  {nxt:%d.%m %H:%M}"
+            except Exception:
+                sched_txt = f"{t.cron} (неверно)"
+            self.table.rows.append(ft.DataRow(cells=[
+                ft.DataCell(ft.Checkbox(value=t.enabled,
+                            on_change=lambda e, t=t: self._toggle(t))),
+                ft.DataCell(ft.Text(t.name, weight=ft.FontWeight.BOLD)),
+                ft.DataCell(ft.Text(sched_txt, size=11)),
+                ft.DataCell(ft.Text(t.action, size=11)),
+                ft.DataCell(ft.Text(t.target, size=11)),
+                ft.DataCell(ft.Text(f"{t.last_run:%d.%m %H:%M}" if t.last_run else "—",
+                                    size=11)),
+                ft.DataCell(ft.Text(t.last_status or "—", size=11,
+                                    color=ft.Colors.GREEN_300 if t.last_status == "success"
+                                    else ft.Colors.RED_300 if t.last_status == "error"
+                                    else ft.Colors.GREY_500)),
+                ft.DataCell(ft.Row([
+                    ft.IconButton(ft.Icons.PLAY_ARROW, icon_size=16, tooltip="Запустить сейчас",
+                                  on_click=lambda e, t=t: self._run_now(t)),
+                    ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=16,
+                                  on_click=lambda e, t=t: self._delete(t)),
+                ], spacing=0)),
+            ]))
+        self._page.update()
+
+    def _toggle(self, t):
+        sch.update_task(t.id, enabled=not t.enabled)
+        self._reload()
+
+    def _run_now(self, t):
+        async def _r():
+            status = await sch.execute_task(t.id)
+            snack(self._page, f"{t.name}: {status}",
+                  error=status != "success")
+            self._reload()
+        self._page.run_task(_r)
+
+    def _delete(self, t):
+        def do():
+            sch.delete_task(t.id)
+            self._reload()
+        confirm_dialog(self._page, f"Удалить задачу «{t.name}»?", "", do)
+
+    def _add_dialog(self, e):
+        self._form("Новая задача", None)
+
+    def _form(self, title, t):
+        name_tf = ft.TextField(label="Название", value=t.name if t else "", width=350)
+        cron_tf = ft.TextField(label="Cron (мин час день мес день_нед)",
+                               value=t.cron if t else "0 3 * * *", width=350)
+        hint = ft.Text("", size=11, color=ft.Colors.GREY_500)
+
+        def upd(e):
+            try:
+                nxt = croniter(cron_tf.value).get_next(__import__("datetime").datetime)
+                hint.value = f"следующий запуск: {nxt:%Y-%m-%d %H:%M}"
+                hint.color = ft.Colors.GREY_500
+            except Exception:
+                hint.value = "неверное выражение"
+                hint.color = ft.Colors.RED_300
+            dlg.content.update()
+        cron_tf.on_change = upd
+
+        action_dd = ft.Dropdown(label="Действие", value=t.action if t else "apt_update",
+                                width=350, options=[
+            ft.dropdown.Option("apt_update", "apt update"),
+            ft.dropdown.Option("upgrade", "upgrade"),
+            ft.dropdown.Option("dist_upgrade", "dist-upgrade"),
+            ft.dropdown.Option("shell", "команда"),
+            ft.dropdown.Option("backup", "бэкап"),
+            ft.dropdown.Option("playbook", "плейбук"),
+            ft.dropdown.Option("report", "отчёт"),
+            ft.dropdown.Option("cleanup_metrics", "очистка метрик"),
+        ])
+        target_tf = ft.TextField(label="Цель (all или тег)",
+                                 value=t.target if t else "all", width=350)
+        params_tf = ft.TextField(label="Параметры (команда / пути / плейбук)",
+                                 value=t.params if t else "", width=350)
+
+        def save(e):
+            if "неверное" in (hint.value or ""):
+                snack(self._page, "Исправьте cron-выражение", error=True)
+                return
+            fields = dict(name=name_tf.value, cron=cron_tf.value,
+                          action=action_dd.value, target=target_tf.value,
+                          params=params_tf.value)
+            if t:
+                sch.update_task(t.id, **fields)
+            else:
+                sch.add_task(**fields)
+            self._page.pop_dialog()
+            self._reload()
+            snack(self._page, "Сохранено")
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text(title),
+            content=ft.Column([name_tf, cron_tf, hint, action_dd, target_tf, params_tf],
+                              tight=True),
+            actions=[
+                ft.TextButton("Отмена", on_click=lambda e: self._page.pop_dialog()),
+                ft.FilledButton("Сохранить", on_click=save),
+            ],
+        )
+        self._page.show_dialog(dlg)
+
+    def _preset_dialog(self, e):
+        def add(idx):
+            name, cron, action, target, params = sch.PRESETS[idx]
+            sch.add_task(name=name, cron=cron, action=action, target=target, params=params)
+            self._page.pop_dialog()
+            self._reload()
+            snack(self._page, f"Добавлено: {name}")
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Пресеты"),
+            content=ft.Column([
+                ft.TextButton(f"{name}  ({cron})", on_click=lambda e, i=i: add(i))
+                for i, (name, cron, *_ ) in enumerate(sch.PRESETS)
+            ], tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._page.pop_dialog())],
+        )
+        self._page.show_dialog(dlg)

app/ui/pages/server_detail.py

@@ -0,0 +1,64 @@
+"""Страница сервера: вкладки Обзор / Пакеты / Docker / Файлы / Сервисы / Firewall / Cron."""
+import flet as ft
+
+from app.core import servers as servers_core
+from app.ui.tabs.overview import OverviewTab
+from app.ui.tabs.packages import PackagesTab
+from app.ui.tabs.docker_tab import DockerTab
+from app.ui.tabs.files_tab import FilesTab
+from app.ui.tabs.systemd_tab import SystemdTab
+from app.ui.tabs.firewall_tab import FirewallTab
+from app.ui.tabs.cron_tab import CronTab
+from app.ui.tabs.terminal_tab import TerminalTab
+
+
+class ServerDetailPage(ft.Column):
+    def __init__(self, page: ft.Page, server_id: int, go):
+        super().__init__(expand=True)
+        self._page = page
+        self.go = go
+        srv = servers_core.get_server(server_id)
+
+        tabs = ft.Tabs(
+            selected_index=0,
+            length=8,
+            expand=True,
+            content=ft.Column(
+                expand=True,
+                controls=[
+                    ft.TabBar(tabs=[
+                        ft.Tab(label="Обзор", icon=ft.Icons.INFO),
+                        ft.Tab(label="Пакеты", icon=ft.Icons.INVENTORY_2),
+                        ft.Tab(label="Docker", icon=ft.Icons.AC_UNIT),
+                        ft.Tab(label="Файлы", icon=ft.Icons.FOLDER),
+                        ft.Tab(label="Сервисы", icon=ft.Icons.SETTINGS_APPLICATIONS),
+                        ft.Tab(label="Firewall", icon=ft.Icons.SHIELD),
+                        ft.Tab(label="Cron", icon=ft.Icons.SCHEDULE),
+                        ft.Tab(label="Терминал", icon=ft.Icons.TERMINAL),
+                    ]),
+                    ft.TabBarView(
+                        expand=True,
+                        controls=[
+                            ft.Container(padding=10, content=OverviewTab(page, srv)),
+                            ft.Container(padding=10, content=PackagesTab(page, srv)),
+                            ft.Container(padding=10, content=DockerTab(page, srv)),
+                            ft.Container(padding=10, content=FilesTab(page, srv)),
+                            ft.Container(padding=10, content=SystemdTab(page, srv)),
+                            ft.Container(padding=10, content=FirewallTab(page, srv)),
+                            ft.Container(padding=10, content=CronTab(page, srv)),
+                            ft.Container(padding=0, content=TerminalTab(page, srv)),
+                        ],
+                    ),
+                ],
+            ),
+        )
+
+        self.controls = [
+            ft.Row([
+                ft.IconButton(ft.Icons.ARROW_BACK, on_click=lambda e: go("dashboard")),
+                ft.Text(srv.name, size=24, weight=ft.FontWeight.BOLD),
+                ft.Text(f"{srv.username}@{srv.host}:{srv.port}",
+                        size=13, color=ft.Colors.GREY_500),
+            ]),
+            tabs,
+        ]

app/ui/pages/servers.py

@@ -0,0 +1,158 @@
+"""Серверы: список, добавление, редактирование, удаление."""
+import flet as ft
+
+from app.core import servers as servers_core
+from app.core.ssh import check_server
+from app.ui.components import confirm_dialog, snack
+
+
+class ServersPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO)
+        self._page = page
+        self.go = go
+        self.table = ft.DataTable(
+            columns=[
+                ft.DataColumn(ft.Text("Имя")),
+                ft.DataColumn(ft.Text("Хост")),
+                ft.DataColumn(ft.Text("Пользователь")),
+                ft.DataColumn(ft.Text("Теги")),
+                ft.DataColumn(ft.Text("Статус")),
+                ft.DataColumn(ft.Text("Действия")),
+            ],
+            rows=[],
+        )
+        self.controls = [
+            ft.Row([
+                ft.Text("Серверы", size=28, weight=ft.FontWeight.BOLD),
+                ft.FilledButton("Добавить сервер", icon=ft.Icons.ADD,
+                                on_click=self._add_dialog),
+            ], alignment=ft.MainAxisAlignment.SPACE_BETWEEN),
+            ft.Card(content=ft.Container(padding=10, content=self.table)),
+        ]
+        self.reload()
+
+    def reload(self):
+        self.table.rows = []
+        for s in servers_core.list_servers():
+            self.table.rows.append(ft.DataRow(cells=[
+                ft.DataCell(ft.Text(s.name, weight=ft.FontWeight.BOLD)),
+                ft.DataCell(ft.Text(f"{s.host}:{s.port}")),
+                ft.DataCell(ft.Text(s.username)),
+                ft.DataCell(ft.Text(s.tags or "—")),
+                ft.DataCell(ft.Text("…", key=f"status_{s.id}")),
+                ft.DataCell(ft.Row([
+                    ft.IconButton(ft.Icons.OPEN_IN_NEW, tooltip="Открыть",
+                                  on_click=lambda e, sid=s.id: self.go("server_detail", sid)),
+                    ft.IconButton(ft.Icons.EDIT, tooltip="Изменить",
+                                  on_click=lambda e, s=s: self._edit_dialog(s)),
+                    ft.IconButton(ft.Icons.DELETE, tooltip="Удалить",
+                                  on_click=lambda e, s=s: self._delete(s)),
+                ])),
+            ]))
+        self._page.update()
+        for s in servers_core.list_servers():
+            self._page.run_task(self._check, s)
+
+    async def _check(self, s):
+        info = await check_server(s)
+        txt = "🟢 онлайн" if info.get("online") else "🔴 оффлайн"
+        self._statuses = getattr(self, "_statuses", {})
+        self._statuses[s.id] = txt
+        for i, srv in enumerate(servers_core.list_servers()):
+            if i < len(self.table.rows):
+                self.table.rows[i].cells[4].content = ft.Text(
+                    self._statuses.get(srv.id, "…"))
+        self._page.update()
+
+    # ---------- диалоги ----------
+
+    def _form(self, s=None):
+        return {
+            "name": ft.TextField(label="Имя", value=s.name if s else "", width=300),
+            "host": ft.TextField(label="Хост", value=s.host if s else "", width=300),
+            "port": ft.TextField(label="Порт", value=str(s.port) if s else "22", width=100),
+            "username": ft.TextField(label="Пользователь", value=s.username if s else "root", width=300),
+            "auth_type": ft.Dropdown(
+                label="Авторизация", width=300,
+                value=s.auth_type if s else "password",
+                options=[
+                    ft.dropdown.Option("password", "Пароль"),
+                    ft.dropdown.Option("key", "SSH-ключ"),
+                ],
+            ),
+            "password": ft.TextField(label="Пароль / passphrase", password=True,
+                                     value=s.password if s else "", width=300),
+            "key_path": ft.TextField(label="Путь к ключу", value=s.key_path or "" if s else "",
+                                     width=300),
+            "sudo_password": ft.TextField(label="Sudo-пароль (если отличается)", password=True,
+                                          value=s.sudo_password or "" if s else "", width=300),
+            "tags": ft.TextField(label="Теги (через запятую)", value=s.tags if s else "", width=300),
+        }
+
+    def _add_dialog(self, e):
+        self._open_form("Новый сервер", self._form(), None)
+
+    def _edit_dialog(self, s):
+        self._open_form(f"Изменить: {s.name}", self._form(s), s.id)
+
+    def _open_form(self, title, f, server_id):
+        def save(e):
+            fields = dict(
+                name=f["name"].value, host=f["host"].value,
+                port=int(f["port"].value or 22), username=f["username"].value,
+                auth_type=f["auth_type"].value,
+                password=f["password"].value or None,
+                key_path=f["key_path"].value or None,
+                sudo_password=f["sudo_password"].value or None,
+                tags=f["tags"].value,
+            )
+            if server_id:
+                servers_core.update_server(server_id, **fields)
+            else:
+                servers_core.add_server(**fields)
+            self._page.pop_dialog()
+            self.reload()
+            snack(self._page, "Сохранено")
+
+        def test(e):
+            async def _t():
+                fields = dict(
+                    id=0, name=f["name"].value or "test", host=f["host"].value,
+                    port=int(f["port"].value or 22), username=f["username"].value,
+                    auth_type=f["auth_type"].value,
+                    password=f["password"].value or None,
+                    key_path=f["key_path"].value or None,
+                    sudo_password=f["sudo_password"].value or None,
+                    tags="", color="blue", read_only=False,
+                )
+                from app.db.models import Server
+                info = await check_server(Server(**fields))
+                if info.get("online"):
+                    snack(self._page, f"✅ {info['os']} | {info['uptime']}")
+                else:
+                    snack(self._page, f"❌ {info.get('error')}", error=True)
+            self._page.run_task(_t)
+
+        dlg = ft.AlertDialog(
+            modal=True,
+            title=ft.Text(title),
+            content=ft.Column(list(f.values()), tight=True,
+                              scroll=ft.ScrollMode.AUTO, height=480),
+            actions=[
+                ft.TextButton("Проверить подключение", on_click=test),
+                ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                ft.FilledButton("Сохранить", on_click=save),
+            ],
+        )
+        self._page.show_dialog(dlg)
+
+    def _close(self, dlg):
+        self._page.pop_dialog()
+
+    def _delete(self, s):
+        confirm_dialog(
+            self._page, "Удалить сервер?",
+            f"Сервер «{s.name}» ({s.host}) будет удалён из приложения. На самом сервере ничего не изменится.",
+            lambda: (servers_core.delete_server(s.id), self.reload()),
+        )

app/ui/pages/settings.py

@@ -0,0 +1,76 @@
+"""Настройки: Telegram, Gitea."""
+import flet as ft
+
+from app.core import notify
+from app.ui.components import snack
+
+
+class SettingsPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+
+        cfg = notify.get_config()
+        self.tg_token = ft.TextField(label="Bot token", value=cfg["token"],
+                                     password=True, width=400)
+        self.tg_chat = ft.TextField(label="Chat ID", value=cfg["chat_id"], width=400)
+        self.tg_enabled = ft.Checkbox(label="Уведомления включены", value=cfg["enabled"])
+        self.tg_alert = ft.Checkbox(label="Алерты мониторинга", value=cfg["on_alert"])
+        self.tg_task = ft.Checkbox(label="Завершение задач", value=cfg["on_task_done"])
+        self.tg_status = ft.Text("", size=12)
+
+        self.controls = [
+            ft.Text("Настройки", size=28, weight=ft.FontWeight.BOLD),
+            ft.Card(content=ft.Container(padding=16, content=ft.Column([
+                ft.Text("Интерфейс", weight=ft.FontWeight.BOLD, size=16),
+                ft.Row([
+                    ft.Text("Тема:", size=13),
+                    ft.FilledButton(
+                        "Сменить тему (тёмная/светлая)",
+                        icon=ft.Icons.BRIGHTNESS_6,
+                        on_click=self._toggle_theme,
+                    ),
+                ]),
+            ], spacing=10))),
+            ft.Card(content=ft.Container(padding=16, content=ft.Column([
+                ft.Text("Telegram-уведомления", weight=ft.FontWeight.BOLD, size=16),
+                ft.Text("Создайте бота через @BotFather, узнайте chat_id через @userinfobot",
+                        size=12, color=ft.Colors.GREY_500),
+                self.tg_token,
+                self.tg_chat,
+                self.tg_enabled,
+                self.tg_alert,
+                self.tg_task,
+                ft.Row([
+                    ft.FilledButton("Сохранить", icon=ft.Icons.SAVE, on_click=self._save),
+                    ft.OutlinedButton("Тест", icon=ft.Icons.SEND, on_click=self._test),
+                ]),
+                self.tg_status,
+            ], spacing=10))),
+        ]
+
+    def _toggle_theme(self, e):
+        from app.db.database import get_session
+        from app.db.models import Setting
+        new = "light" if self._page.theme_mode == ft.ThemeMode.DARK else "dark"
+        self._page.theme_mode = ft.ThemeMode.LIGHT if new == "light" else ft.ThemeMode.DARK
+        with get_session() as s:
+            row = s.get(Setting, "theme") or Setting(key="theme")
+            row.value = new
+            s.add(row)
+            s.commit()
+        self._page.update()
+
+    def _save(self, e):
+        notify.save_config(self.tg_token.value, self.tg_chat.value,
+                           self.tg_enabled.value, self.tg_alert.value, self.tg_task.value)
+        snack(self._page, "Настройки сохранены")
+
+    def _test(self, e):
+        self._save(e)
+        async def _t():
+            ok, msg = await notify.test()
+            self.tg_status.value = ("✅ " if ok else "❌ ") + msg
+            self.tg_status.color = ft.Colors.GREEN_300 if ok else ft.Colors.RED_300
+            self._page.update()
+        self._page.run_task(_t)

app/ui/pages/tasks.py

@@ -0,0 +1,47 @@
+"""Журнал задач."""
+import flet as ft
+
+from app.core.tasks import tasks
+from app.core import servers as servers_core
+
+
+class TasksPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=8)
+        self._page = page
+        self.col = ft.Column(spacing=6)
+        self.controls = [
+            ft.Row([
+                ft.Text("Журнал задач", size=28, weight=ft.FontWeight.BOLD),
+                ft.IconButton(ft.Icons.REFRESH, on_click=lambda e: self._load()),
+            ]),
+            self.col,
+        ]
+        self._load()
+
+    def _load(self):
+        self.col.controls = []
+        servers = {s.id: s.name for s in servers_core.list_servers()}
+        for t in tasks.list_recent(50):
+            color = {"success": ft.Colors.GREEN_400, "error": ft.Colors.RED_400,
+                     "running": ft.Colors.BLUE_300, "cancelled": ft.Colors.ORANGE_300,
+                     }.get(t.status, ft.Colors.GREY_500)
+            self.col.controls.append(
+                ft.ExpansionTile(
+                    title=ft.Text(f"{t.title} — {servers.get(t.server_id, '?')}", size=14),
+                    subtitle=ft.Text(f"{t.created_at:%Y-%m-%d %H:%M}  •  {t.kind}",
+                                     size=11),
+                    leading=ft.Icon(ft.Icons.CIRCLE, color=color, size=14),
+                    controls=[
+                        ft.Container(
+                            padding=10,
+                            content=ft.Text(t.log[-5000:] or "(нет лога)",
+                                            size=11, font_family="Consolas",
+                                            selectable=True),
+                        )
+                    ],
+                )
+            )
+        if not self.col.controls:
+            self.col.controls.append(ft.Text("задач пока не было", color=ft.Colors.GREY_500))
+        self._page.update()

app/ui/pages/wizard.py

@@ -0,0 +1,190 @@
+"""Мастер первичной настройки сервера: чекбоксы → плейбук."""
+import flet as ft
+
+from app.core.ssh import SSHClient
+from app.core.tasks import tasks
+from app.core import playbooks as pb
+from app.db.models import Server
+from app.ui.components import append_log, log_view, snack
+
+# (id, название, описание, шаги)
+WIZARD_STEPS = [
+    ("hostname", "Изменить hostname", "Задать имя сервера",
+     lambda v: [{"name": "Hostname", "shell": f"hostnamectl set-hostname {v['hostname']}"}]),
+    ("timezone", "Часовой пояс", "timedatectl set-timezone (по умолчанию Asia/Ulaanbaatar)",
+     lambda v: [{"name": "Timezone", "shell": f"timedatectl set-timezone {v['timezone']}"}]),
+    ("ntp", "Синхронизация времени", "Включить NTP",
+     lambda v: [{"name": "NTP", "shell": "timedatectl set-ntp true"}]),
+    ("update", "Обновить систему", "apt update + dist-upgrade",
+     lambda v: [{"name": "Update", "apt": {"update": True, "upgrade": "dist"}}]),
+    ("user", "Создать пользователя", "Новый пользователь с sudo",
+     lambda v: [
+         {"name": "Создать пользователя",
+          "shell": f"useradd -m -s /bin/bash {v['new_user']} 2>/dev/null || true"},
+         {"name": "Пароль",
+          "shell": f"echo '{v['new_user']}:{v['new_pass']}' | chpasswd"},
+         {"name": "Sudo",
+          "shell": f"usermod -aG sudo {v['new_user']}"},
+     ]),
+    ("utils", "Базовые утилиты", "curl, wget, htop, git, mc, net-tools",
+     lambda v: [{"name": "Утилиты",
+                 "apt": {"install": ["curl", "wget", "htop", "git", "mc", "net-tools"]}}]),
+    ("docker", "Docker", "docker.io + docker-compose + автозапуск",
+     lambda v: [
+         {"name": "Установить Docker",
+          "apt": {"install": ["docker.io", "docker-compose"]}},
+         {"name": "Запустить Docker", "systemd": {"unit": "docker", "action": "enable --now"}},
+     ]),
+    ("portainer", "Portainer (порт 9000)", "Веб-интерфейс для Docker",
+     lambda v: [
+         {"name": "Portainer volume", "shell": "docker volume create portainer_data || true"},
+         {"name": "Portainer run",
+          "shell": "docker rm -f portainer 2>/dev/null; "
+                   "docker run -d -p 9000:9000 --name portainer --restart=always "
+                   "-v /var/run/docker.sock:/var/run/docker.sock "
+                   "-v portainer_data:/data portainer/portainer-ce:lts"},
+     ]),
+    ("ufw", "Firewall (ufw)", "Установить, разрешить SSH, включить",
+     lambda v: [
+         {"name": "Установить ufw", "apt": {"install": ["ufw"]}},
+         {"name": "Пресет", "ufw": {"preset": "Только SSH"}},
+         {"name": "Включить ufw", "shell": "yes | ufw enable"},
+     ]),
+    ("fail2ban", "Fail2ban", "Защита SSH от перебора",
+     lambda v: [
+         {"name": "Установить fail2ban", "apt": {"install": ["fail2ban"]}},
+         {"name": "Запустить", "systemd": {"unit": "fail2ban", "action": "enable --now"}},
+     ]),
+    ("unattended", "Автообновления безопасности", "unattended-upgrades",
+     lambda v: [
+         {"name": "Установить", "apt": {"install": ["unattended-upgrades"]}},
+         {"name": "Включить",
+          "shell": "echo 'unattended-upgrades unattended-upgrades/enable_auto_updates boolean true' "
+                   "| debconf-set-selections && dpkg-reconfigure -f noninteractive unattended-upgrades"},
+     ]),
+    ("agent", "Агент мониторинга", "dm-agent для real-time метрик (HTTP)",
+     None),  # обрабатывается отдельно
+]
+
+RECOMMENDED = {"update", "utils", "ufw", "fail2ban", "ntp"}
+
+
+class WizardPage(ft.Column):
+    def __init__(self, page: ft.Page, go):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+
+        from app.core import servers as servers_core
+        self.srv_dd = ft.Dropdown(label="Сервер", width=300, options=[
+            ft.dropdown.Option(str(s.id), s.name) for s in servers_core.list_servers()
+        ])
+
+        self.fields = {
+            "hostname": ft.TextField(label="hostname", width=250, visible=False, dense=True),
+            "timezone": ft.TextField(label="часовой пояс", value="Asia/Ulaanbaatar",
+                                     width=250, visible=False, dense=True),
+            "new_user": ft.TextField(label="имя пользователя", width=200, visible=False, dense=True),
+            "new_pass": ft.TextField(label="пароль", password=True, width=200,
+                                     visible=False, dense=True),
+        }
+
+        self.checks = {}
+        step_rows = []
+        for sid, name, desc, _ in WIZARD_STEPS:
+            cb = ft.Checkbox(label=name, value=sid in RECOMMENDED,
+                             on_change=lambda e, sid=sid: self._toggle_fields())
+            self.checks[sid] = cb
+            extra = []
+            if sid == "hostname":
+                extra = [self.fields["hostname"]]
+            elif sid == "timezone":
+                extra = [self.fields["timezone"]]
+            elif sid == "user":
+                extra = [ft.Row([self.fields["new_user"], self.fields["new_pass"]])]
+            step_rows.append(ft.Column([
+                ft.Row([cb, ft.Text(desc, size=12, color=ft.Colors.GREY_500)]),
+                ft.Container(content=ft.Row(extra), padding=ft.Padding.only(left=40))
+                if extra else ft.Container(),
+            ], spacing=2))
+
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=250, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False)
+
+        self.controls = [
+            ft.Text("Мастер первичной настройки", size=28, weight=ft.FontWeight.BOLD),
+            ft.Text("Отметьте что настроить, заполните поля, нажмите «Применить».",
+                    size=13, color=ft.Colors.GREY_500),
+            self.srv_dd,
+            ft.Card(content=ft.Container(padding=14, content=ft.Column(step_rows, spacing=6))),
+            ft.Row([
+                ft.FilledButton("Применить выбранное", icon=ft.Icons.PLAY_ARROW,
+                                on_click=self._apply),
+                ft.TextButton("Выбрать рекомендуемое", on_click=lambda e: self._preset()),
+            ]),
+            self.log_container,
+        ]
+
+    def _toggle_fields(self):
+        self.fields["hostname"].visible = self.checks["hostname"].value
+        self.fields["timezone"].visible = self.checks["timezone"].value
+        user_on = self.checks["user"].value
+        self.fields["new_user"].visible = user_on
+        self.fields["new_pass"].visible = user_on
+        self._page.update()
+
+    def _preset(self):
+        for sid, cb in self.checks.items():
+            cb.value = sid in RECOMMENDED
+        self._toggle_fields()
+
+    def _apply(self, e):
+        if not self.srv_dd.value:
+            snack(self._page, "Выберите сервер", error=True)
+            return
+        from app.core import servers as servers_core
+        srv = servers_core.get_server(int(self.srv_dd.value))
+
+        values = {
+            "hostname": self.fields["hostname"].value or "server",
+            "timezone": self.fields["timezone"].value or "Asia/Ulaanbaatar",
+            "new_user": self.fields["new_user"].value or "deploy",
+            "new_pass": self.fields["new_pass"].value or "changeme",
+            "ssh_port": str(srv.port),
+        }
+
+        steps = []
+        agent_selected = False
+        for sid, _, _, builder in WIZARD_STEPS:
+            if not self.checks[sid].value:
+                continue
+            if sid == "agent":
+                agent_selected = True
+                continue
+            steps.extend(builder(values))
+
+        if not steps and not agent_selected:
+            snack(self._page, "Ничего не выбрано", error=True)
+            return
+
+        self.log_container.visible = True
+        self._page.update()
+
+        playbook = {"name": "Мастер настройки", "vars": values, "steps": steps}
+
+        async def job(log):
+            async with SSHClient(srv) as c:
+                if steps:
+                    await pb.run_playbook(c, srv, playbook, log)
+                if agent_selected:
+                    from app.core import agent as agent_core
+                    import socket
+                    # определить IP приложения, доступный серверу
+                    app_host = socket.gethostbyname(socket.gethostname())
+                    log(f"установка агента (app_host={app_host})...")
+                    await agent_core.install_agent(srv, app_host, log)
+
+        tasks.start("wizard", "мастер настройки", srv.id, job,
+                    on_log=lambda l: (append_log(self.log, l), self._page.update()))
+        snack(self._page, "Мастер запущен — следите за логом")

app/ui/tabs/cron_tab.py

@@ -0,0 +1,172 @@
+"""Вкладка Cron: редактор crontab."""
+import flet as ft
+
+from app.core import cron_svc as cron
+from app.core.ssh import SSHClient
+from app.db.models import Server
+from app.ui.components import confirm_dialog, snack
+
+
+class CronTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8, scroll=ft.ScrollMode.AUTO)
+        self._page = page
+        self.srv = srv
+        self._lines: list[cron.CronLine] = []
+        self._user = ""  # пусто = текущий sudo-пользовательский контекст
+
+        self.entries_col = ft.Column(spacing=4)
+        self.controls = [
+            ft.Container(height=8),
+            ft.Row([
+                ft.FilledButton("Добавить задачу", icon=ft.Icons.ADD,
+                                on_click=self._add_dialog),
+                ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._page.run_task(self._load)),
+                ft.OutlinedButton("Откатить к бэкапу", icon=ft.Icons.HISTORY,
+                                  on_click=self._restore_dialog),
+            ]),
+            self.entries_col,
+        ]
+        self._page.run_task(self._load)
+
+    async def _load(self):
+        try:
+            async with SSHClient(self.srv) as c:
+                content = await cron.get_crontab(c)
+            self._lines = cron.parse_crontab(content)
+        except Exception as e:
+            snack(self._page, f"cron: {e}", error=True)
+        self._render()
+
+    def _render(self):
+        self.entries_col.controls = []
+        for i, l in enumerate(self._lines):
+            if not l.is_entry:
+                if l.raw.strip() and not l.raw.strip().startswith(("#", "SHELL", "PATH", "MAILTO")):
+                    self.entries_col.controls.append(
+                        ft.Text(l.raw, size=11, color=ft.Colors.GREY_600,
+                                font_family="Consolas"))
+                continue
+            self.entries_col.controls.append(
+                ft.Card(content=ft.Container(padding=8, content=ft.Row([
+                    ft.Checkbox(value=l.enabled,
+                                on_change=lambda e, idx=i: self._toggle(idx)),
+                    ft.Column([
+                        ft.Text(l.schedule, size=13, weight=ft.FontWeight.BOLD,
+                                font_family="Consolas"),
+                        ft.Text(l.command, size=12, font_family="Consolas"),
+                        ft.Text(cron.humanize(l.schedule), size=10,
+                                color=ft.Colors.GREY_500),
+                    ], spacing=1, expand=True),
+                    ft.IconButton(ft.Icons.EDIT, icon_size=16,
+                                  on_click=lambda e, idx=i: self._edit_dialog(idx)),
+                    ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=16,
+                                  on_click=lambda e, idx=i: self._delete(idx)),
+                ])))
+            )
+        if not any(l.is_entry for l in self._lines):
+            self.entries_col.controls.append(
+                ft.Text("crontab пуст", color=ft.Colors.GREY_500))
+        self._page.update()
+
+    async def _save(self):
+        content = cron.render(self._lines)
+        async with SSHClient(self.srv) as c:
+            await cron.set_crontab(c, content, self.srv.id)
+        snack(self._page, "crontab сохранён (бэкап записан)")
+
+    def _toggle(self, idx):
+        self._lines[idx].enabled = not self._lines[idx].enabled
+        self._page.run_task(self._save)
+
+    def _delete(self, idx):
+        def do():
+            del self._lines[idx]
+            self._page.run_task(self._save_and_reload)
+        confirm_dialog(self._page, "Удалить задачу?", self._lines[idx].command[:80], do)
+
+    async def _save_and_reload(self):
+        await self._save()
+        await self._load()
+
+    def _edit_dialog(self, idx):
+        l = self._lines[idx]
+        sched_tf = ft.TextField(label="Расписание (мин час день мес день_нед)",
+                                value=l.schedule, width=400)
+        cmd_tf = ft.TextField(label="Команда", value=l.command, width=400)
+        hint = ft.Text(cron.humanize(l.schedule), size=11, color=ft.Colors.GREY_500)
+
+        def upd_hint(e):
+            hint.value = cron.humanize(sched_tf.value)
+            dlg.content.update()
+        sched_tf.on_change = upd_hint
+
+        def save(e):
+            if "неверное" in hint.value:
+                snack(self._page, "Неверное cron-выражение", error=True)
+                return
+            self._lines[idx] = cron.CronLine("", l.enabled, sched_tf.value.strip(),
+                                             cmd_tf.value.strip())
+            self._page.pop_dialog()
+            self._page.run_task(self._save_and_reload)
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Редактировать задачу"),
+            content=ft.Column([sched_tf, cmd_tf, hint], tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                     ft.FilledButton("Сохранить", on_click=save)],
+        )
+        self._page.show_dialog(dlg)
+
+    def _add_dialog(self, e):
+        sched_tf = ft.TextField(label="Расписание", hint_text="0 3 * * *", width=400)
+        cmd_tf = ft.TextField(label="Команда", width=400)
+        hint = ft.Text("", size=11, color=ft.Colors.GREY_500)
+
+        def upd_hint(ev):
+            hint.value = cron.humanize(sched_tf.value)
+            dlg.content.update()
+        sched_tf.on_change = upd_hint
+
+        def save(e):
+            if not sched_tf.value or not cmd_tf.value:
+                return
+            self._lines.append(cron.CronLine("", True, sched_tf.value.strip(),
+                                             cmd_tf.value.strip()))
+            self._page.pop_dialog()
+            self._page.run_task(self._save_and_reload)
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Новая cron-задача"),
+            content=ft.Column([sched_tf, cmd_tf, hint], tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                     ft.FilledButton("Добавить", on_click=save)],
+        )
+        self._page.show_dialog(dlg)
+
+    def _restore_dialog(self, e):
+        backups = cron.backups(self.srv.id, "current")
+        if not backups:
+            snack(self._page, "Бэкапов пока нет", error=True)
+            return
+        def restore(b):
+            self._page.pop_dialog()
+            async def _r():
+                async with SSHClient(self.srv) as c:
+                    await cron.set_crontab(c, b.content, self.srv.id)
+                await self._load()
+            self._page.run_task(_r)
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Откатить к бэкапу"),
+            content=ft.Column([
+                ft.TextButton(f"{b.created_at:%Y-%m-%d %H:%M} ({len(b.content)} символов)",
+                              on_click=lambda e, b=b: restore(b))
+                for b in backups
+            ], tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg))],
+        )
+        self._page.show_dialog(dlg)
+
+    def _close(self, dlg):
+        self._page.pop_dialog()

app/ui/tabs/docker_tab.py

@@ -0,0 +1,296 @@
+"""Вкладка Docker: контейнеры, образы, тома, сети, compose."""
+import flet as ft
+
+from app.core import docker_svc as d
+from app.core.ssh import SSHClient
+from app.core.tasks import tasks
+from app.db.models import Server
+from app.ui.components import append_log, confirm_dialog, log_view, snack
+
+
+class DockerTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8)
+        self._page = page
+        self.srv = srv
+        self.inner_tabs = ft.Tabs(
+            selected_index=0, length=5, expand=True,
+            content=ft.Column(
+                expand=True,
+                controls=[
+                    ft.TabBar(tabs=[
+                        ft.Tab(label="Контейнеры"),
+                        ft.Tab(label="Образы"),
+                        ft.Tab(label="Тома"),
+                        ft.Tab(label="Сети"),
+                        ft.Tab(label="Система"),
+                    ]),
+                    ft.TabBarView(
+                        expand=True,
+                        controls=[
+                            self._containers_view(),
+                            self._images_view(),
+                            self._volumes_view(),
+                            self._networks_view(),
+                            self._system_view(),
+                        ],
+                    ),
+                ],
+            ),
+        )
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=200, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False)
+        self.controls = [ft.Container(height=8), self.inner_tabs, self.log_container]
+        self._page.run_task(self._check)
+
+    async def _check(self):
+        try:
+            async with SSHClient(self.srv) as c:
+                if not await d.available(c):
+                    snack(self._page, "Docker не установлен на сервере", error=True)
+                    return
+                await self._load_containers()
+                await self._load_images()
+                await self._load_volumes()
+                await self._load_networks()
+                await self._load_system()
+        except Exception as e:
+            snack(self._page, f"Docker: {e}", error=True)
+
+    # ---------- контейнеры ----------
+
+    def _containers_view(self):
+        self.ct_table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Имя")), ft.DataColumn(ft.Text("Образ")),
+            ft.DataColumn(ft.Text("Статус")), ft.DataColumn(ft.Text("Порты")),
+            ft.DataColumn(ft.Text("Действия")),
+        ], rows=[])
+        self.stats_row = ft.Row(spacing=16, wrap=True)
+        return ft.Column([
+            ft.Row([
+                ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._page.run_task(self._load_containers)),
+            ]),
+            ft.Container(expand=True, content=ft.Column(
+                [self.ct_table, ft.Divider(), ft.Text("Нагрузка:", weight=ft.FontWeight.BOLD), self.stats_row],
+                scroll=ft.ScrollMode.AUTO)),
+        ], expand=True)
+
+    async def _load_containers(self):
+        async with SSHClient(self.srv) as c:
+            containers = await d.list_containers(c)
+            try:
+                stats = {s["Name"]: s for s in await d.container_stats(c)}
+            except Exception:
+                stats = {}
+        self.ct_table.rows = []
+        for ct in containers:
+            running = "Up" in ct.get("Status", "")
+            cid = ct["ID"]
+            name = ct["Names"]
+            self.ct_table.rows.append(ft.DataRow(cells=[
+                ft.DataCell(ft.Text(name, weight=ft.FontWeight.BOLD)),
+                ft.DataCell(ft.Text(ct["Image"], size=12)),
+                ft.DataCell(ft.Text(ct["Status"], size=12,
+                                    color=ft.Colors.GREEN_300 if running else ft.Colors.GREY_500)),
+                ft.DataCell(ft.Text(ct.get("Ports", "") or "—", size=11)),
+                ft.DataCell(ft.Row([
+                    ft.IconButton(ft.Icons.PLAY_ARROW if not running else ft.Icons.STOP,
+                                  icon_size=18, tooltip="start" if not running else "stop",
+                                  on_click=lambda e, c=cid, a="start" if not running else "stop": self._ct_action(c, a)),
+                    ft.IconButton(ft.Icons.RESTART_ALT, icon_size=18, tooltip="restart",
+                                  on_click=lambda e, c=cid: self._ct_action(c, "restart")),
+                    ft.IconButton(ft.Icons.ARTICLE, icon_size=18, tooltip="логи",
+                                  on_click=lambda e, c=cid, n=name: self._show_logs(c, n)),
+                    ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=18, tooltip="удалить",
+                                  on_click=lambda e, c=cid, n=name: self._remove_ct(c, n)),
+                ], spacing=0)),
+            ]))
+        self.stats_row.controls = [
+            ft.Chip(label=ft.Text(f"{n}: CPU {s.get('CPUPerc','?')} MEM {s.get('MemPerc','?')}"))
+            for n, s in stats.items()
+        ] or [ft.Text("нет запущенных", size=12, color=ft.Colors.GREY_500)]
+        self._page.update()
+
+    def _ct_action(self, cid, action):
+        async def _do():
+            async with SSHClient(self.srv) as c:
+                await d.container_action(c, cid, action)
+            await self._load_containers()
+        self._page.run_task(_do)
+
+    def _show_logs(self, cid, name):
+        self.log_container.visible = True
+        append_log(self.log, f"=== логи {name} ===")
+        self._page.update()
+        async def _do():
+            async with SSHClient(self.srv) as c:
+                out = await d.container_logs(c, cid)
+            for line in out.splitlines()[-100:]:
+                append_log(self.log, line)
+            self._page.update()
+        self._page.run_task(_do)
+
+    def _remove_ct(self, cid, name):
+        def do():
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    await d.container_action(c, cid, "rm")
+                await self._load_containers()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, f"Удалить контейнер {name}?", "Действие необратимо.", do)
+
+    # ---------- образы ----------
+
+    def _images_view(self):
+        self.img_table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Репозиторий")), ft.DataColumn(ft.Text("Тег")),
+            ft.DataColumn(ft.Text("Размер")), ft.DataColumn(ft.Text("Создан")),
+            ft.DataColumn(ft.Text("")),
+        ], rows=[])
+        pull_tf = ft.TextField(hint_text="образ для pull (напр. nginx:alpine)", width=300, dense=True)
+        return ft.Column([
+            ft.Row([
+                pull_tf,
+                ft.FilledButton("Pull", icon=ft.Icons.DOWNLOAD,
+                                on_click=lambda e: self._pull(pull_tf.value)),
+                ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._page.run_task(self._load_images)),
+            ]),
+            ft.Container(expand=True, content=ft.Column([self.img_table], scroll=ft.ScrollMode.AUTO)),
+        ], expand=True)
+
+    async def _load_images(self):
+        async with SSHClient(self.srv) as c:
+            images = await d.list_images(c)
+        self.img_table.rows = [
+            ft.DataRow(cells=[
+                ft.DataCell(ft.Text(i["Repository"])),
+                ft.DataCell(ft.Text(i["Tag"])),
+                ft.DataCell(ft.Text(i["Size"])),
+                ft.DataCell(ft.Text(i.get("CreatedSince", ""), size=11)),
+                ft.DataCell(ft.IconButton(
+                    ft.Icons.DELETE_OUTLINE, icon_size=18,
+                    on_click=lambda e, ref=f"{i['Repository']}:{i['Tag']}": self._rmi(ref))),
+            ]) for i in images
+        ]
+        self._page.update()
+
+    def _pull(self, image):
+        if not image:
+            return
+        self.log_container.visible = True
+        async def job(log):
+            async with SSHClient(self.srv) as c:
+                stream = await d.pull(c, image)
+                async for line in stream:
+                    log(line)
+        tasks.start("docker", f"docker pull {image}", self.srv.id, job,
+                    on_log=lambda l: (append_log(self.log, l), self._page.update()),
+                    on_done=lambda r: self._page.run_task(self._load_images))
+
+    def _rmi(self, ref):
+        def do():
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    await d.remove_image(c, ref)
+                await self._load_images()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, f"Удалить образ {ref}?", "", do)
+
+    # ---------- тома ----------
+
+    def _volumes_view(self):
+        self.vol_table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Имя")), ft.DataColumn(ft.Text("Драйвер")),
+            ft.DataColumn(ft.Text("")),
+        ], rows=[])
+        return ft.Column([
+            ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                              on_click=lambda e: self._page.run_task(self._load_volumes)),
+            ft.Container(expand=True, content=ft.Column([self.vol_table], scroll=ft.ScrollMode.AUTO)),
+        ], expand=True)
+
+    async def _load_volumes(self):
+        async with SSHClient(self.srv) as c:
+            vols = await d.list_volumes(c)
+        self.vol_table.rows = [
+            ft.DataRow(cells=[
+                ft.DataCell(ft.Text(v["Name"])),
+                ft.DataCell(ft.Text(v.get("Driver", ""))),
+                ft.DataCell(ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=18,
+                    on_click=lambda e, n=v["Name"]: self._rm_vol(n))),
+            ]) for v in vols
+        ]
+        self._page.update()
+
+    def _rm_vol(self, name):
+        def do():
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    await d.remove_volume(c, name)
+                await self._load_volumes()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, f"Удалить том {name}?", "Данные будут потеряны.", do)
+
+    # ---------- сети ----------
+
+    def _networks_view(self):
+        self.net_table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Имя")), ft.DataColumn(ft.Text("Драйвер")),
+            ft.DataColumn(ft.Text("Scope")),
+        ], rows=[])
+        return ft.Column([
+            ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                              on_click=lambda e: self._page.run_task(self._load_networks)),
+            ft.Container(expand=True, content=ft.Column([self.net_table], scroll=ft.ScrollMode.AUTO)),
+        ], expand=True)
+
+    async def _load_networks(self):
+        async with SSHClient(self.srv) as c:
+            nets = await d.list_networks(c)
+        self.net_table.rows = [
+            ft.DataRow(cells=[
+                ft.DataCell(ft.Text(n["Name"])),
+                ft.DataCell(ft.Text(n.get("Driver", ""))),
+                ft.DataCell(ft.Text(n.get("Scope", ""))),
+            ]) for n in nets
+        ]
+        self._page.update()
+
+    # ---------- система ----------
+
+    def _system_view(self):
+        self.sys_text = ft.Text("…", selectable=True, size=12, font_family="Consolas")
+        return ft.Column([
+            ft.Row([
+                ft.OutlinedButton("Обновить df", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._page.run_task(self._load_system)),
+                ft.FilledButton("System prune", icon=ft.Icons.CLEANING_SERVICES,
+                                style=ft.ButtonStyle(bgcolor=ft.Colors.ORANGE_800),
+                                on_click=self._prune),
+            ]),
+            ft.Container(padding=8, content=self.sys_text),
+        ])
+
+    async def _load_system(self):
+        async with SSHClient(self.srv) as c:
+            ver = await d.server_version(c)
+            df = await d.system_df(c)
+        self.sys_text.value = f"Docker {ver}\n\n{df}"
+        self._page.update()
+
+    def _prune(self, e):
+        def do():
+            self.log_container.visible = True
+            async def job(log):
+                async with SSHClient(self.srv) as c:
+                    log(await d.system_prune(c))
+            tasks.start("docker", "docker system prune", self.srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()),
+                        on_done=lambda r: self._page.run_task(self._load_system))
+        confirm_dialog(self._page, "Docker system prune?",
+                       "Будут удалены остановленные контейнеры, неиспользуемые сети, "
+                       "висячие образы и кэш сборки.", do)

app/ui/tabs/files_tab.py

@@ -0,0 +1,229 @@
+"""Вкладка Файлы: SFTP-браузер с upload/download/редактором."""
+import os
+from pathlib import PurePosixPath
+
+import flet as ft
+
+from app.core import files as fcore
+from app.core.ssh import SSHClient
+from app.db.models import Server
+from app.ui.components import confirm_dialog, snack
+
+
+class FilesTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8)
+        self._page = page
+        self.srv = srv
+        self._path = f"/home/{srv.username}" if srv.username != "root" else "/root"
+        self._client = None
+
+        self.path_text = ft.Text(self._path, size=13, weight=ft.FontWeight.BOLD)
+        self.list_col = ft.Column(scroll=ft.ScrollMode.AUTO, expand=True, spacing=0)
+        self.progress = ft.ProgressBar(visible=False, height=4)
+        self.status = ft.Text("", size=12, color=ft.Colors.GREY_500)
+
+        self.controls = [
+            ft.Container(height=8),
+            ft.Row([
+                ft.IconButton(ft.Icons.ARROW_UPWARD, tooltip="Вверх",
+                              on_click=self._up),
+                ft.IconButton(ft.Icons.HOME, tooltip="Домой", on_click=self._home),
+                ft.IconButton(ft.Icons.REFRESH, on_click=lambda e: self._reload()),
+                self.path_text,
+                ft.Container(expand=True),
+                ft.IconButton(ft.Icons.CREATE_NEW_FOLDER, tooltip="Новая папка",
+                              on_click=self._mkdir_dialog),
+                ft.IconButton(ft.Icons.UPLOAD_FILE, tooltip="Загрузить файл",
+                              on_click=self._upload_dialog),
+            ]),
+            self.progress,
+            ft.Container(expand=True, border=ft.Border.all(1, ft.Colors.GREY_800),
+                         border_radius=8, padding=4, content=self.list_col),
+            self.status,
+        ]
+        # file picker для upload/download (async API flet ≥0.80)
+        self.picker = ft.FilePicker()
+        page.services.append(self.picker)
+        self._page.run_task(self._connect)
+
+    async def _connect(self):
+        try:
+            self._client = SSHClient(self.srv)
+            await self._client.connect()
+            await self._load()
+        except Exception as e:
+            snack(self._page, f"SFTP: {e}", error=True)
+
+    async def _load(self):
+        if not self._client:
+            return
+        try:
+            entries = await fcore.list_dir(self._client, self._path)
+        except PermissionError as e:
+            self.status.value = f"нет доступа: {e}"
+            self._page.update()
+            return
+        self.path_text.value = self._path
+        self.list_col.controls = []
+        for en in entries:
+            icon = ft.Icons.FOLDER if en.is_dir else ft.Icons.INSERT_DRIVE_FILE
+            size = "" if en.is_dir else self._fmt_size(en.size)
+            self.list_col.controls.append(
+                ft.ListTile(
+                    leading=ft.Icon(icon, size=20,
+                                    color=ft.Colors.AMBER_300 if en.is_dir else None),
+                    title=ft.Text(en.name, size=13),
+                    subtitle=ft.Text(en.permissions, size=10,
+                                     color=ft.Colors.GREY_600),
+                    trailing=ft.Row([
+                        ft.Text(size, size=11, color=ft.Colors.GREY_500),
+                        ft.IconButton(ft.Icons.DOWNLOAD, icon_size=16, tooltip="Скачать",
+                                      visible=not en.is_dir,
+                                      on_click=lambda e, p=en.path: self._download(p)),
+                        ft.IconButton(ft.Icons.EDIT, icon_size=16, tooltip="Редактировать",
+                                      visible=not en.is_dir,
+                                      on_click=lambda e, p=en.path: self._edit(p)),
+                        ft.IconButton(ft.Icons.DRIVE_FILE_RENAME_OUTLINE, icon_size=16,
+                                      tooltip="Переименовать",
+                                      on_click=lambda e, en=en: self._rename_dialog(en)),
+                        ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=16, tooltip="Удалить",
+                                      on_click=lambda e, en=en: self._delete(en)),
+                    ], spacing=0, tight=True),
+                    dense=True,
+                    on_click=lambda e, en=en: self._enter(en),
+                )
+            )
+        self.status.value = f"{len(entries)} объектов"
+        self._page.update()
+
+    def _fmt_size(self, s):
+        for unit in ("Б", "КБ", "МБ", "ГБ"):
+            if s < 1024 or unit == "ГБ":
+                return f"{s:.0f} {unit}" if unit == "Б" else f"{s:.1f} {unit}"
+            s /= 1024
+
+    def _reload(self):
+        self._page.run_task(self._load)
+
+    def _enter(self, en):
+        if en.is_dir:
+            self._path = en.path
+            self._reload()
+        else:
+            self._edit(en.path)
+
+    def _up(self, e):
+        parent = str(PurePosixPath(self._path).parent)
+        self._path = parent or "/"
+        self._reload()
+
+    def _home(self, e):
+        self._path = f"/home/{self.srv.username}" if self.srv.username != "root" else "/root"
+        self._reload()
+
+    # ---------- действия ----------
+
+    def _delete(self, en):
+        def do():
+            async def _d():
+                await fcore.delete(self._client, en.path, en.is_dir)
+                await self._load()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, f"Удалить {en.name}?",
+                       f"{'Папка и всё содержимое' if en.is_dir else 'Файл'} будет удалён с сервера.", do)
+
+    def _rename_dialog(self, en):
+        tf = ft.TextField(label="Новое имя", value=en.name, autofocus=True)
+        def do(e):
+            async def _r():
+                new = str(PurePosixPath(self._path) / tf.value)
+                await fcore.rename(self._client, en.path, new)
+                self._page.pop_dialog()
+                await self._load()
+            self._page.run_task(_r)
+        dlg = ft.AlertDialog(modal=True, title=ft.Text("Переименовать"), content=tf,
+                             actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                                      ft.FilledButton("Ок", on_click=do)])
+        self._page.show_dialog(dlg)
+
+    def _mkdir_dialog(self, e):
+        tf = ft.TextField(label="Имя папки", autofocus=True)
+        def do(e):
+            async def _m():
+                await fcore.mkdir(self._client, str(PurePosixPath(self._path) / tf.value))
+                self._page.pop_dialog()
+                await self._load()
+            self._page.run_task(_m)
+        dlg = ft.AlertDialog(modal=True, title=ft.Text("Новая папка"), content=tf,
+                             actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                                      ft.FilledButton("Создать", on_click=do)])
+        self._page.show_dialog(dlg)
+
+    def _close(self, dlg):
+        self._page.pop_dialog()
+
+    def _download(self, remote_path):
+        async def _do():
+            local = await self.picker.save_file(
+                dialog_title="Сохранить как",
+                file_name=PurePosixPath(remote_path).name,
+            )
+            if not local:
+                return
+            self.progress.visible = True
+            self._page.update()
+            def prog(done, total):
+                self.progress.value = done / total if total else None
+                self.status.value = f"скачивание… {done//1024}/{total//1024} КБ"
+                self._page.update()
+            await fcore.download(self._client, remote_path, local, prog)
+            self.progress.visible = False
+            self.status.value = f"скачано: {local}"
+            self._page.update()
+        self._page.run_task(_do)
+
+    def _upload_dialog(self, e):
+        async def _do():
+            files = await self.picker.pick_files(dialog_title="Выберите файл для загрузки")
+            if not files:
+                return
+            f = files[0]
+            remote = str(PurePosixPath(self._path) / f.name)
+            self.progress.visible = True
+            self._page.update()
+            def prog(done, total):
+                self.progress.value = done / total if total else None
+                self.status.value = f"загрузка… {done//1024}/{total//1024} КБ"
+                self._page.update()
+            await fcore.upload(self._client, f.path, remote, prog)
+            self.progress.visible = False
+            await self._load()
+        self._page.run_task(_do)
+
+    def _edit(self, path):
+        tf = ft.TextField(multiline=True, min_lines=20, max_lines=20,
+                          text_size=12, text_style=ft.TextStyle(font_family="Consolas"),
+                          expand=True)
+        sudo_cb = ft.Checkbox(label="sudo (root-файл)", value=False)
+        async def _load_text():
+            try:
+                tf.value = await fcore.read_text(self._client, path)
+                dlg.content.update()
+            except Exception as ex:
+                tf.value = f"// ошибка чтения: {ex}"
+                dlg.content.update()
+        def save(e):
+            async def _s():
+                await fcore.write_text(self._client, path, tf.value, sudo_cb.value)
+                self._page.pop_dialog()
+                snack(self._page, "Сохранено")
+            self._page.run_task(_s)
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text(path, size=13),
+            content=ft.Container(width=700, content=ft.Column([sudo_cb, tf], tight=True)),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                     ft.FilledButton("Сохранить", on_click=save)],
+        )
+        self._page.show_dialog(dlg)
+        self._page.run_task(_load_text)

app/ui/tabs/firewall_tab.py

@@ -0,0 +1,155 @@
+"""Вкладка Firewall: ufw."""
+import flet as ft
+
+from app.core import firewall as fw
+from app.core.ssh import SSHClient
+from app.db.models import Server
+from app.ui.components import confirm_dialog, snack
+
+
+class FirewallTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8, scroll=ft.ScrollMode.AUTO)
+        self._page = page
+        self.srv = srv
+
+        self.status_text = ft.Text("…", size=13)
+        self.table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("#")),
+            ft.DataColumn(ft.Text("Куда")),
+            ft.DataColumn(ft.Text("Действие")),
+            ft.DataColumn(ft.Text("Откуда")),
+            ft.DataColumn(ft.Text("")),
+        ], rows=[])
+        self.listen_text = ft.Column(spacing=1)
+
+        self.controls = [
+            ft.Container(height=8),
+            ft.Row([
+                ft.FilledButton("Включить ufw", icon=ft.Icons.SHIELD,
+                                on_click=self._enable),
+                ft.OutlinedButton("Выключить", on_click=self._disable),
+                ft.FilledButton("Добавить правило", icon=ft.Icons.ADD,
+                                on_click=self._add_dialog),
+                ft.OutlinedButton("Пресет", icon=ft.Icons.LIST_ALT,
+                                  on_click=self._preset_dialog),
+                ft.IconButton(ft.Icons.REFRESH, on_click=lambda e: self._page.run_task(self._load)),
+            ]),
+            self.status_text,
+            ft.Card(content=ft.Container(padding=10, content=self.table)),
+            ft.Text("Прослушиваемые порты (ss -tlnp):", weight=ft.FontWeight.BOLD, size=13),
+            self.listen_text,
+        ]
+        self._page.run_task(self._load)
+
+    async def _load(self):
+        try:
+            async with SSHClient(self.srv) as c:
+                if not await fw.is_installed(c):
+                    self.status_text.value = "ufw не установлен (apt install ufw)"
+                    self._page.update()
+                    return
+                active, raw = await fw.status(c)
+                rules = await fw.list_rules(c)
+                listening = await fw.listening_ports(c)
+            self.status_text.value = "🟢 ufw активен" if active else "⚪ ufw выключен"
+            self.table.rows = [
+                ft.DataRow(cells=[
+                    ft.DataCell(ft.Text(str(r.number))),
+                    ft.DataCell(ft.Text(r.to)),
+                    ft.DataCell(ft.Text(r.action,
+                                        color=ft.Colors.GREEN_300 if "ALLOW" in r.action.upper()
+                                        else ft.Colors.RED_300)),
+                    ft.DataCell(ft.Text(r.from_)),
+                    ft.DataCell(ft.IconButton(ft.Icons.DELETE_OUTLINE, icon_size=16,
+                                on_click=lambda e, n=r.number: self._del_rule(n))),
+                ]) for r in rules
+            ]
+            self.listen_text.controls = [
+                ft.Text(l, size=11, font_family="Consolas", color=ft.Colors.GREY_500)
+                for l in listening
+            ]
+        except Exception as e:
+            self.status_text.value = f"ошибка: {e}"
+        self._page.update()
+
+    def _enable(self, e):
+        def do():
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    out = await fw.enable(c, self.srv.port)
+                snack(self._page, out.strip().splitlines()[-1] if out.strip() else "ufw включён")
+                await self._load()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, "Включить ufw?",
+                       f"Порт {self.srv.port} (текущий SSH) будет автоматически разрешён.", do,
+                       danger=False)
+
+    def _disable(self, e):
+        def do():
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    await fw.disable(c)
+                await self._load()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, "Выключить ufw?", "Файрвол будет полностью отключён.", do)
+
+    def _del_rule(self, number):
+        def do():
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    await fw.delete_rule(c, number)
+                await self._load()
+            self._page.run_task(_d)
+        confirm_dialog(self._page, f"Удалить правило #{number}?", "", do)
+
+    def _add_dialog(self, e):
+        port_tf = ft.TextField(label="Порт (22, 80, 8000:8010)", width=250)
+        action_dd = ft.Dropdown(label="Действие", value="allow", width=150, options=[
+            ft.dropdown.Option("allow"), ft.dropdown.Option("deny"),
+            ft.dropdown.Option("limit"), ft.dropdown.Option("reject"),
+        ])
+        proto_dd = ft.Dropdown(label="Протокол", value="tcp", width=120, options=[
+            ft.dropdown.Option("tcp"), ft.dropdown.Option("udp"), ft.dropdown.Option("any"),
+        ])
+        from_tf = ft.TextField(label="От адреса (пусто = любой)", width=250)
+
+        def do(e):
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    out = await fw.add_rule(c, port_tf.value, action_dd.value,
+                                            proto_dd.value, from_tf.value.strip())
+                self._page.pop_dialog()
+                snack(self._page, out.strip() or "правило добавлено")
+                await self._load()
+            self._page.run_task(_d)
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Новое правило"),
+            content=ft.Column([port_tf, action_dd, proto_dd, from_tf], tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                     ft.FilledButton("Добавить", on_click=do)],
+        )
+        self._page.show_dialog(dlg)
+
+    def _preset_dialog(self, e):
+        def apply(name):
+            self._page.pop_dialog()
+            async def _d():
+                async with SSHClient(self.srv) as c:
+                    out = await fw.apply_preset(c, name, self.srv.port)
+                snack(self._page, "пресет применён")
+                await self._load()
+            self._page.run_task(_d)
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Применить пресет"),
+            content=ft.Column([
+                ft.FilledButton(n, on_click=lambda e, n=n: apply(n), width=250)
+                for n in fw.PRESETS
+            ], tight=True),
+            actions=[ft.TextButton("Отмена", on_click=lambda e: self._close(dlg))],
+        )
+        self._page.show_dialog(dlg)
+
+    def _close(self, dlg):
+        self._page.pop_dialog()

app/ui/tabs/overview.py

@@ -0,0 +1,158 @@
+"""Вкладка Обзор: метрики, update/upgrade/reboot, история."""
+import flet as ft
+
+from app.core import monitor
+from app.core.packages import apt_update, list_upgradable
+from app.core.ssh import SSHClient, check_server
+from app.core.tasks import tasks
+from app.db.models import Server
+from app.ui.components import append_log, confirm_dialog, fmt_mb, log_view, snack
+
+
+class OverviewTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, scroll=ft.ScrollMode.AUTO, spacing=12)
+        self._page = page
+        self.srv = srv
+
+        self.info_text = ft.Text("загрузка…", size=13)
+        self.upg_text = ft.Text("", size=13, color=ft.Colors.ORANGE_300)
+        self.metrics_col = ft.Column(spacing=4)
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=220, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False,
+        )
+
+        self.controls = [
+            ft.Container(height=8),
+            ft.Row([
+                ft.FilledButton("apt update", icon=ft.Icons.REFRESH,
+                                on_click=self._update),
+                ft.FilledButton("Upgrade", icon=ft.Icons.UPGRADE,
+                                on_click=lambda e: self._upgrade(False)),
+                ft.OutlinedButton("Dist-upgrade",
+                                  on_click=lambda e: self._upgrade(True)),
+                ft.FilledButton("Reboot", icon=ft.Icons.RESTART_ALT,
+                                style=ft.ButtonStyle(bgcolor=ft.Colors.RED_800),
+                                on_click=self._reboot),
+                self.upg_text,
+            ], spacing=10),
+            ft.Card(content=ft.Container(padding=14, content=ft.Column([
+                ft.Text("Система", weight=ft.FontWeight.BOLD),
+                self.info_text,
+                ft.Container(height=6),
+                self.metrics_col,
+            ]))),
+            self.log_container,
+            ft.Text("История метрик", weight=ft.FontWeight.BOLD),
+            self._chart(),
+        ]
+        self._page.run_task(self._load)
+
+    # ---------- данные ----------
+
+    async def _load(self):
+        info = await check_server(self.srv)
+        if info.get("online"):
+            self.info_text.value = (
+                f"🟢 {info['hostname']}  •  {info['os']}\n"
+                f"{info['uptime']}  •  CPU: {info['cpu_cores']} ядер  •  RAM: {info['mem_mb']} МБ"
+            )
+            try:
+                async with SSHClient(self.srv) as c:
+                    upg = await list_upgradable(c)
+                    self.upg_text.value = (
+                        f"доступно обновлений: {len(upg)}" if upg else "система обновлена"
+                    )
+                    snap = await monitor.collect(c, self.srv.id)
+                    self._show_metrics(snap)
+            except Exception as e:
+                self.info_text.value += f"\n⚠ {e}"
+        else:
+            self.info_text.value = f"🔴 {info.get('error')}"
+        self._page.update()
+
+    def _show_metrics(self, snap):
+        def bar(label, pct, color):
+            return ft.Row([
+                ft.Text(label, size=12, width=45),
+                ft.ProgressBar(value=pct / 100, height=8, expand=True, color=color,
+                               bgcolor=ft.Colors.GREY_800),
+                ft.Text(f"{pct:.0f}%", size=12, width=42,
+                        text_align=ft.TextAlign.RIGHT),
+            ])
+        self.metrics_col.controls = [
+            bar("CPU", snap.cpu_percent, ft.Colors.BLUE_400),
+            bar("RAM", snap.mem_percent, ft.Colors.PURPLE_300),
+            bar("Диск", snap.disk_percent,
+                ft.Colors.RED_400 if snap.disk_percent > 85 else ft.Colors.GREEN_400),
+            ft.Text(f"RAM {fmt_mb(snap.mem_used_mb)} / {fmt_mb(snap.mem_total_mb)}"
+                    f"  •  load {snap.load1:.2f}"
+                    f"  •  net ↓{snap.net_rx_kbs:.0f} ↑{snap.net_tx_kbs:.0f} КБ/с",
+                    size=11, color=ft.Colors.GREY_500),
+        ]
+
+    def _chart(self):
+        hist = monitor.history(self.srv.id, 30)
+        if len(hist) < 2:
+            return ft.Text("данных пока мало — график появится после нескольких замеров",
+                           size=12, color=ft.Colors.GREY_500)
+        # простое текстовое представление истории (LineChart недоступен в flet 0.86)
+        cpu_vals = [h.cpu_percent for h in hist]
+        ram_vals = [h.mem_percent for h in hist]
+        rows = []
+        for i, h in enumerate(hist[-15:]):
+            bar_cpu = "█" * int(h.cpu_percent / 5) + "░" * (20 - int(h.cpu_percent / 5))
+            bar_ram = "█" * int(h.mem_percent / 5) + "░" * (20 - int(h.mem_percent / 5))
+            rows.append(ft.Text(
+                f"{h.ts:%H:%M}  CPU {bar_cpu} {h.cpu_percent:5.1f}%  RAM {bar_ram} {h.mem_percent:5.1f}%",
+                size=10, font_family="Consolas", color=ft.Colors.GREY_400,
+            ))
+        return ft.Column(rows, spacing=1, scroll=ft.ScrollMode.AUTO, height=180)
+
+    # ---------- действия ----------
+
+    def _show_log(self, show=True):
+        self.log_container.visible = show
+        self._page.update()
+
+    def _update(self, e):
+        self._show_log()
+        async def job(log):
+            async with SSHClient(self.srv) as c:
+                log("$ apt-get update")
+                out = await apt_update(c)
+                for line in out.splitlines()[-30:]:
+                    log(line)
+        tasks.start("update", "apt update", self.srv.id, job,
+                    on_log=lambda l: (append_log(self.log, l), self._page.update()))
+        snack(self._page, "apt update запущен")
+
+    def _upgrade(self, dist: bool):
+        label = "dist-upgrade" if dist else "upgrade"
+        def do():
+            self._show_log()
+            async def job(log):
+                async with SSHClient(self.srv) as c:
+                    log(f"$ apt-get {label} -y")
+                    stream = await __import__("app.core.packages", fromlist=["apt_upgrade"]).apt_upgrade(c, dist)
+                    async for line in stream:
+                        log(line)
+            tasks.start("upgrade", label, self.srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()))
+        confirm_dialog(self._page, f"Запустить {label}?",
+                       f"На сервере «{self.srv.name}» будут обновлены пакеты.", do)
+
+    def _reboot(self, e):
+        def do():
+            self._show_log()
+            from app.core.group_ops import op_reboot
+            async def job(log):
+                async with SSHClient(self.srv) as c:
+                    await op_reboot(wait=True)(c, self.srv, log)
+            tasks.start("reboot", "reboot", self.srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()))
+        confirm_dialog(self._page, "Перезагрузить сервер?",
+                       f"Сервер «{self.srv.name}» будет перезагружен. Приложение дождётся его возврата.",
+                       do)

app/ui/tabs/packages.py

@@ -0,0 +1,216 @@
+"""Вкладка Пакеты: список с разбивкой, установка/удаление."""
+import flet as ft
+
+from app.core.packages import (Package, apt_search, install, list_packages,
+                               remove, split_packages)
+from app.core.ssh import SSHClient
+from app.core.tasks import tasks
+from app.db.models import Server
+from app.ui.components import append_log, confirm_dialog, log_view, snack
+
+
+class PackagesTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8)
+        self._page = page
+        self.srv = srv
+        self._all: list[Package] = []
+        self._filter = "user"  # all/system/user/deps
+
+        self.search = ft.TextField(
+            hint_text="Поиск по имени…", prefix_icon=ft.Icons.SEARCH,
+            on_change=lambda e: self._render_table(), expand=True, dense=True,
+        )
+        self.chips = ft.Row([
+            ft.Chip(label=ft.Text("Пользовательские"), on_select=lambda e: self._set_filter("user"), selected=True),
+            ft.Chip(label=ft.Text("Системные"), on_select=lambda e: self._set_filter("system")),
+            ft.Chip(label=ft.Text("Зависимости"), on_select=lambda e: self._set_filter("deps")),
+            ft.Chip(label=ft.Text("Все"), on_select=lambda e: self._set_filter("all")),
+        ])
+        self.count_text = ft.Text("", size=12, color=ft.Colors.GREY_500)
+        self.table = ft.DataTable(
+            columns=[
+                ft.DataColumn(ft.Text("Пакет")),
+                ft.DataColumn(ft.Text("Версия")),
+                ft.DataColumn(ft.Text("Тип")),
+                ft.DataColumn(ft.Text("")),
+            ],
+            rows=[], expand=True,
+        )
+        self.table_col = ft.Column([self.table], scroll=ft.ScrollMode.AUTO, expand=True)
+        self.log = log_view()
+        self.log_container = ft.Container(
+            height=200, border=ft.Border.all(1, ft.Colors.GREY_800),
+            border_radius=8, padding=8, content=self.log, visible=False)
+
+        self.controls = [
+            ft.Container(height=8),
+            ft.Row([
+                ft.FilledButton("Установить пакет", icon=ft.Icons.ADD,
+                                on_click=self._install_dialog),
+                ft.OutlinedButton("Обновить список", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._reload()),
+                ft.OutlinedButton("Autoremove", icon=ft.Icons.CLEANING_SERVICES,
+                                  on_click=self._autoremove),
+                self.count_text,
+            ]),
+            ft.Row([self.search], spacing=10),
+            self.chips,
+            ft.Container(expand=True, content=self.table_col),
+            self.log_container,
+        ]
+        self._page.run_task(self._load)
+
+    def _set_filter(self, f):
+        self._filter = f
+        for c in self.chips.controls:
+            c.selected = False
+        idx = {"user": 0, "system": 1, "deps": 2, "all": 3}[f]
+        self.chips.controls[idx].selected = True
+        self._render_table()
+
+    async def _load(self):
+        try:
+            async with SSHClient(self.srv) as c:
+                self._all = await list_packages(c)
+        except Exception as e:
+            snack(self._page, f"Ошибка загрузки: {e}", error=True)
+        self._render_table()
+
+    def _reload(self):
+        self.count_text.value = "загрузка…"
+        self._page.update()
+        self._page.run_task(self._load)
+
+    def _render_table(self):
+        groups = split_packages(self._all)
+        items = self._all if self._filter == "all" else groups.get(self._filter, [])
+        q = (self.search.value or "").lower()
+        if q:
+            items = [p for p in items if q in p.name.lower()]
+        self.count_text.value = f"показано {len(items)} из {len(self._all)}"
+
+        kind_label = lambda p: ("системный" if p.is_system else
+                                "пользовательский" if p.manual else "зависимость")
+        kind_color = lambda p: (ft.Colors.BLUE_300 if p.is_system else
+                                ft.Colors.GREEN_300 if p.manual else ft.Colors.GREY_500)
+
+        self.table.rows = [
+            ft.DataRow(cells=[
+                ft.DataCell(ft.Text(p.name, selectable=True)),
+                ft.DataCell(ft.Text(p.version, size=12)),
+                ft.DataCell(ft.Text(kind_label(p), size=12, color=kind_color(p))),
+                ft.DataCell(ft.IconButton(
+                    ft.Icons.DELETE_OUTLINE, icon_size=18, tooltip="Удалить",
+                    on_click=lambda e, p=p: self._remove(p),
+                )),
+            ]) for p in items[:300]
+        ]
+        if len(items) > 300:
+            self.count_text.value += " (первые 300)"
+        self._page.update()
+
+    # ---------- действия ----------
+
+    def _show_log(self):
+        self.log_container.visible = True
+        self._page.update()
+
+    def _install_dialog(self, e):
+        name_tf = ft.TextField(label="Имя пакета (или несколько через пробел)",
+                               autofocus=True, width=400)
+        results = ft.Column(tight=True, spacing=2)
+
+        def search(e):
+            async def _s():
+                results.controls = [ft.Text("поиск…", size=12)]
+                dlg.content.update()
+                try:
+                    async with SSHClient(self.srv) as c:
+                        lines = await apt_search(c, name_tf.value)
+                    results.controls = [
+                        ft.TextButton(
+                            l[:90],
+                            on_click=lambda e, n=l.split(" ")[0]: setattr(
+                                name_tf, "value", n) or dlg.content.update(),
+                            style=ft.ButtonStyle(padding=2),
+                        ) for l in lines[:15]
+                    ] or [ft.Text("ничего не найдено", size=12)]
+                except Exception as ex:
+                    results.controls = [ft.Text(f"ошибка: {ex}", size=12)]
+                dlg.content.update()
+            self._page.run_task(_s)
+
+        def do_install(e):
+            names = name_tf.value.split()
+            if not names:
+                return
+            self._page.pop_dialog()
+            self._show_log()
+            async def job(log):
+                async with SSHClient(self.srv) as c:
+                    log(f"$ apt-get install -y {' '.join(names)}")
+                    stream = await install(c, names)
+                    async for line in stream:
+                        log(line)
+            tasks.start("install", f"install {' '.join(names)}", self.srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()),
+                        on_done=lambda r: self._reload())
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text("Установить пакет"),
+            content=ft.Column([name_tf, results], tight=True, height=350, width=450),
+            actions=[
+                ft.TextButton("Найти", on_click=search),
+                ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                ft.FilledButton("Установить", on_click=do_install),
+            ],
+        )
+        self._page.show_dialog(dlg)
+
+    def _close(self, dlg):
+        self._page.pop_dialog()
+
+    def _remove(self, p: Package):
+        if p.is_system:
+            snack(self._page, f"«{p.name}» — системный пакет, удаление заблокировано",
+                  error=True)
+            return
+        purge_cb = ft.Checkbox(label="Очистить конфигурацию (purge)", value=False)
+
+        def do():
+            self._page.pop_dialog()
+            self._show_log()
+            async def job(log):
+                async with SSHClient(self.srv) as c:
+                    stream = await remove(c, [p.name], purge_cb.value)
+                    async for line in stream:
+                        log(line)
+            tasks.start("remove", f"remove {p.name}", self.srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()),
+                        on_done=lambda r: self._reload())
+
+        dlg = ft.AlertDialog(
+            modal=True, title=ft.Text(f"Удалить {p.name}?"),
+            content=purge_cb,
+            actions=[
+                ft.TextButton("Отмена", on_click=lambda e: self._close(dlg)),
+                ft.FilledButton("Удалить", on_click=lambda e: do(),
+                                style=ft.ButtonStyle(bgcolor=ft.Colors.RED_700)),
+            ],
+        )
+        self._page.show_dialog(dlg)
+
+    def _autoremove(self, e):
+        def do():
+            self._show_log()
+            from app.core.packages import autoremove
+            async def job(log):
+                async with SSHClient(self.srv) as c:
+                    stream = await autoremove(c)
+                    async for line in stream:
+                        log(line)
+            tasks.start("autoremove", "autoremove", self.srv.id, job,
+                        on_log=lambda l: (append_log(self.log, l), self._page.update()))
+        confirm_dialog(self._page, "Autoremove?",
+                       "Будут удалены неиспользуемые зависимости.", do)

app/ui/tabs/systemd_tab.py

@@ -0,0 +1,116 @@
+"""Вкладка Сервисы: systemd-юниты, журнал."""
+import flet as ft
+
+from app.core import systemd_svc as sd
+from app.core.ssh import SSHClient
+from app.db.models import Server
+from app.ui.components import confirm_dialog, snack
+
+
+class SystemdTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8)
+        self._page = page
+        self.srv = srv
+        self._units = []
+
+        self.search = ft.TextField(hint_text="Поиск юнита…", prefix_icon=ft.Icons.SEARCH,
+                                   on_change=lambda e: self._render(), expand=True, dense=True)
+        self.only_failed = ft.Checkbox(label="только failed", value=False,
+                                       on_change=lambda e: self._render())
+        self.table = ft.DataTable(columns=[
+            ft.DataColumn(ft.Text("Юнит")),
+            ft.DataColumn(ft.Text("Состояние")),
+            ft.DataColumn(ft.Text("Enabled")),
+            ft.DataColumn(ft.Text("Описание")),
+            ft.DataColumn(ft.Text("Действия")),
+        ], rows=[])
+        self.log_text = ft.Column(scroll=ft.ScrollMode.AUTO, spacing=1)
+
+        self.controls = [
+            ft.Container(height=8),
+            ft.Row([
+                ft.OutlinedButton("Обновить", icon=ft.Icons.REFRESH,
+                                  on_click=lambda e: self._page.run_task(self._load)),
+                self.search, self.only_failed,
+            ]),
+            ft.Row([
+                ft.Container(expand=3, content=ft.Column([self.table],
+                             scroll=ft.ScrollMode.AUTO)),
+                ft.VerticalDivider(width=1),
+                ft.Container(expand=2, content=self.log_text),
+            ], expand=True),
+        ]
+        self._page.run_task(self._load)
+
+    async def _load(self):
+        try:
+            async with SSHClient(self.srv) as c:
+                self._units = await sd.list_units(c)
+        except Exception as e:
+            snack(self._page, f"systemd: {e}", error=True)
+        self._render()
+
+    def _render(self):
+        q = (self.search.value or "").lower()
+        units = self._units
+        if self.only_failed.value:
+            units = [u for u in units if u.active == "failed"]
+        if q:
+            units = [u for u in units if q in u.name.lower() or q in u.description.lower()]
+
+        def state_color(u):
+            return {"active": ft.Colors.GREEN_300, "failed": ft.Colors.RED_400,
+                    "inactive": ft.Colors.GREY_500}.get(u.active, ft.Colors.GREY_500)
+
+        self.table.rows = [
+            ft.DataRow(cells=[
+                ft.DataCell(ft.Text(u.name, size=12, selectable=True)),
+                ft.DataCell(ft.Text(f"{u.active}/{u.sub}", size=12, color=state_color(u))),
+                ft.DataCell(ft.Text(u.enabled or "—", size=11)),
+                ft.DataCell(ft.Text(u.description[:50], size=11)),
+                ft.DataCell(ft.Row([
+                    ft.IconButton(ft.Icons.PLAY_ARROW, icon_size=16, tooltip="start",
+                                  on_click=lambda e, n=u.name: self._act(n, "start")),
+                    ft.IconButton(ft.Icons.STOP, icon_size=16, tooltip="stop",
+                                  on_click=lambda e, n=u.name: self._act(n, "stop")),
+                    ft.IconButton(ft.Icons.RESTART_ALT, icon_size=16, tooltip="restart",
+                                  on_click=lambda e, n=u.name: self._act(n, "restart")),
+                    ft.IconButton(ft.Icons.ARTICLE, icon_size=16, tooltip="логи",
+                                  on_click=lambda e, n=u.name: self._logs(n)),
+                ], spacing=0)),
+            ]) for u in units[:200]
+        ]
+        self._page.update()
+
+    def _act(self, name, action):
+        def do():
+            async def _d():
+                try:
+                    async with SSHClient(self.srv) as c:
+                        await sd.action(c, name, action)
+                    snack(self._page, f"{name}: {action} ✓")
+                    await self._load()
+                except Exception as ex:
+                    snack(self._page, f"{ex}", error=True)
+            self._page.run_task(_d)
+        if name in sd.CRITICAL_UNITS and action in ("stop", "restart"):
+            confirm_dialog(self._page, f"⚠ {action} {name}?",
+                           "Это критичный системный сервис! Можно потерять связь с сервером.", do)
+        else:
+            do()
+
+    def _logs(self, name):
+        async def _l():
+            self.log_text.controls = [ft.Text(f"journalctl -u {name}", weight=ft.FontWeight.BOLD, size=12)]
+            self._page.update()
+            try:
+                async with SSHClient(self.srv) as c:
+                    out = await sd.logs(c, name)
+                for line in out.splitlines()[-80:]:
+                    self.log_text.controls.append(
+                        ft.Text(line, size=10, font_family="Consolas", selectable=True))
+            except Exception as ex:
+                self.log_text.controls.append(ft.Text(f"ошибка: {ex}", size=11))
+            self._page.update()
+        self._page.run_task(_l)

app/ui/tabs/terminal_tab.py

@@ -0,0 +1,272 @@
+"""Вкладка Терминал: PTY-сессия + библиотека команд обслуживания."""
+import flet as ft
+
+from app.core.terminal import TerminalSession
+from app.db.models import Server
+
+# Категории → [(название, команда), ...]
+# {server} — подстановка не нужна, команды выполняются на самом сервере
+COMMANDS = {
+    "Пользователи": [
+        ("Список пользователей", "cat /etc/passwd | awk -F: '$3>=1000{print $1}'"),
+        ("Кто залогинен", "who -a"),
+        ("Добавить пользователя", "sudo adduser"),
+        ("Удалить пользователя", "sudo deluser --remove-home"),
+        ("Сменить пароль пользователя", "sudo passwd"),
+        ("Дать sudo", "sudo usermod -aG sudo"),
+        ("Убрать sudo", "sudo deluser $(whoami) sudo"),
+        ("Список групп", "getent group | awk -F: '$3>=1000{print $1}'"),
+        ("Добавить в группу", "sudo usermod -aG"),
+        ("Сессии пользователя", "last -n 20"),
+    ],
+    "Система": [
+        ("Аптайм и нагрузка", "uptime"),
+        ("Инфо о системе", "hostnamectl"),
+        ("Версия ядра", "uname -a"),
+        ("Время и часовой пояс", "timedatectl"),
+        ("Установить часовой пояс", "sudo timedatectl set-timezone Asia/Ulaanbaatar"),
+        ("Синхронизация времени", "sudo timedatectl set-ntp true"),
+        ("Обновить locale", "sudo dpkg-reconfigure locales"),
+        ("Память", "free -h"),
+        ("Диски", "lsblk"),
+        ("SMART дисков", "sudo smartctl -a /dev/sda 2>/dev/null || echo 'smartmontools не установлен'"),
+    ],
+    "Процессы": [
+        ("Топ процессов", "ps aux --sort=-%cpu | head -20"),
+        ("Дерево процессов", "pstree -p"),
+        ("Найти процесс", "ps aux | grep"),
+        ("Убить по имени", "pkill -f"),
+        ("Открытые файлы процесса", "sudo lsof -p"),
+    ],
+    "Сеть": [
+        ("IP-адреса", "ip a"),
+        ("Маршруты", "ip r"),
+        ("Открытые порты", "sudo ss -tlnp"),
+        ("Соединения", "sudo ss -tnp"),
+        ("DNS", "cat /etc/resolv.conf"),
+        ("Проверить связь", "ping -c 4 8.8.8.8"),
+        ("Скачать файл", "wget"),
+        ("Открыть порт в ufw", "sudo ufw allow"),
+    ],
+    "Логи": [
+        ("Системный журнал", "sudo journalctl -n 100 --no-pager"),
+        ("Ошибки за час", "sudo journalctl -p err -S '1 hour ago' --no-pager"),
+        ("Логи сервиса", "sudo journalctl -u"),
+        ("dmesg", "sudo dmesg | tail -30"),
+        ("Авторизации", "sudo last -n 20"),
+        ("Неудачные логины", "sudo lastb -n 20 2>/dev/null || sudo journalctl _COMM=sshd | grep -i fail | tail -20"),
+    ],
+    "Пакеты": [
+        ("Обновить индекс", "sudo apt update"),
+        ("Обновить систему", "sudo apt upgrade -y"),
+        ("Найти пакет", "apt-cache search"),
+        ("Инфо о пакете", "apt-cache show"),
+        ("Установленные вручную", "apt-mark showmanual"),
+        ("Очистка", "sudo apt autoremove -y && sudo apt autoclean"),
+        ("История apt", "grep -h ' install \\| upgrade ' /var/log/apt/history.log* | tail -20"),
+    ],
+    "Безопасность": [
+        ("Статус fail2ban", "sudo fail2ban-client status 2>/dev/null || echo 'не установлен'"),
+        ("Правила ufw", "sudo ufw status numbered"),
+        ("Открытые сокеты", "sudo lsof -i -P -n | grep LISTEN"),
+        ("SUID-файлы", "sudo find / -perm -4000 -type f 2>/dev/null | head -20"),
+        ("Пользователи с shell", "grep -E '/bin/(bash|sh|zsh)' /etc/passwd"),
+    ],
+}
+
+
+class TerminalTab(ft.Column):
+    def __init__(self, page: ft.Page, srv: Server):
+        super().__init__(expand=True, spacing=8)
+        self._page = page
+        self.srv = srv
+        self._term: TerminalSession | None = None
+        self._connected = False
+
+        # вывод терминала
+        self.output = ft.Column(
+            scroll=ft.ScrollMode.AUTO, spacing=0, expand=True,
+            auto_scroll=True,
+        )
+        self.output_container = ft.Container(
+            expand=True, bgcolor=ft.Colors.BLACK, border_radius=6, padding=8,
+            content=self.output,
+        )
+
+        # строка ввода
+        self.input = ft.TextField(
+            hint_text="команда… (Enter — отправить)",
+            dense=True, expand=True, text_size=13,
+            text_style=ft.TextStyle(font_family="Consolas"),
+            on_submit=self._send,
+            disabled=True,
+        )
+
+        # статус подключения
+        self.status_icon = ft.Icon(ft.Icons.CIRCLE, color=ft.Colors.GREY, size=12)
+        self.status_text = ft.Text("не подключено", size=12, color=ft.Colors.GREY_500)
+
+        # селектор команд
+        cat_names = list(COMMANDS.keys())
+        self.cat_dd = ft.Dropdown(
+            label="Категория", value=cat_names[0], width=180,
+            options=[ft.dropdown.Option(c) for c in cat_names],
+            on_select=lambda e: self._fill_cmd_dd(),
+        )
+        self.cmd_dd = ft.Dropdown(
+            label="Команда", width=350,
+            options=[ft.dropdown.Option(n) for n, _ in COMMANDS[cat_names[0]]],
+            on_select=lambda e: self._on_cmd_selected(),
+        )
+        self.param_tf = ft.TextField(
+            hint_text="параметр (если нужен)", width=200, dense=True, visible=False,
+        )
+
+        self.controls = [
+            ft.Container(height=8),
+            # панель подключения
+            ft.Row([
+                ft.FilledButton("Подключиться", icon=ft.Icons.TERMINAL,
+                                on_click=self._connect),
+                ft.OutlinedButton("Отключиться", icon=ft.Icons.CLOSE,
+                                  on_click=self._disconnect),
+                self.status_icon, self.status_text,
+                ft.Container(expand=True),
+                ft.TextButton("Очистить вывод", on_click=lambda e: self._clear()),
+            ]),
+            # селектор команд
+            ft.Row([
+                self.cat_dd, self.cmd_dd, self.param_tf,
+                ft.FilledButton("Выполнить", icon=ft.Icons.PLAY_ARROW,
+                                on_click=self._run_selected),
+            ]),
+            # терминал
+            ft.Container(expand=True, content=self.output_container),
+            # ввод
+            ft.Row([self.input]),
+        ]
+
+    # ---------- подключение ----------
+
+    def _connect(self, e=None):
+        if self._connected:
+            return
+        self._set_status("подключение…", ft.Colors.ORANGE_300)
+        self._page.run_task(self._do_connect)
+
+    async def _do_connect(self):
+        try:
+            self._term = TerminalSession(self.srv, self._on_output)
+            await self._term.open()
+            self._connected = True
+            self.input.disabled = False
+            self._set_status(f"подключено: {self.srv.username}@{self.srv.host}",
+                             ft.Colors.GREEN_400)
+            # приглашение
+            self._term.write(f"echo '--- Debian Manager Terminal | {self.srv.name} ---'\n")
+        except Exception as ex:
+            self._set_status(f"ошибка: {ex}", ft.Colors.RED_400)
+
+    def _disconnect(self, e=None):
+        if self._term:
+            self._term.close()
+            self._term = None
+        self._connected = False
+        self.input.disabled = True
+        self._set_status("не подключено", ft.Colors.GREY_500)
+
+    def _set_status(self, text, color):
+        self.status_text.value = text
+        self.status_icon.color = color
+        self._page.update()
+
+    def _on_output(self, data: str):
+        # разбиваем ANSI-строки на Text-строки (упрощённо — без цветов)
+        for line in data.splitlines():
+            # убираем ANSI escape-коды
+            clean = self._strip_ansi(line)
+            if clean is not None:
+                self.output.controls.append(
+                    ft.Text(clean, size=12, font_family="Consolas",
+                            color=ft.Colors.GREEN_100, selectable=True)
+                )
+        # ограничиваем буфер
+        if len(self.output.controls) > 500:
+            self.output.controls = self.output.controls[-400:]
+        self._page.update()
+
+    @staticmethod
+    def _strip_ansi(s: str) -> str:
+        import re
+        return re.sub(r"\x1b\[[0-9;]*[a-zA-Z]", "", s)
+
+    def _clear(self):
+        self.output.controls = []
+        self._page.update()
+
+    # ---------- ввод ----------
+
+    def _send(self, e=None):
+        if self._term and self._connected and self.input.value:
+            self._term.write(self.input.value + "\n")
+            self.input.value = ""
+            self._page.update()
+
+    # ---------- библиотека команд ----------
+
+    def _fill_cmd_dd(self):
+        cat = self.cat_dd.value
+        self.cmd_dd.options = [
+            ft.dropdown.Option(n) for n, _ in COMMANDS[cat]
+        ]
+        self.cmd_dd.value = None
+        self.param_tf.visible = False
+        self._page.update()
+
+    def _on_cmd_selected(self):
+        """Показать поле параметра, если команда его требует."""
+        cat = self.cat_dd.value
+        name = self.cmd_dd.value
+        if not name:
+            return
+        cmd = next((c for n, c in COMMANDS[cat] if n == name), "")
+        # команды, заканчивающиеся на пробел/утилиту без аргумента — нужен параметр
+        needs_param = cmd.endswith((" ", "adduser", "passwd", "deluser", "usermod -aG",
+                                    "journalctl -u", "grep", "pkill -f", "lsof -p",
+                                    "allow", "search", "show", "wget"))
+        self.param_tf.visible = needs_param
+        self._page.update()
+
+    def _run_selected(self, e=None):
+        if not self._connected:
+            self._connect()
+            # повторим после подключения
+            self._page.run_task(self._run_after_connect)
+            return
+        self._execute_selected()
+
+    async def _run_after_connect(self):
+        import asyncio
+        for _ in range(30):
+            await asyncio.sleep(0.2)
+            if self._connected:
+                break
+        if self._connected:
+            self._execute_selected()
+
+    def _execute_selected(self):
+        cat = self.cat_dd.value
+        name = self.cmd_dd.value
+        if not name:
+            return
+        cmd = next((c for n, c in COMMANDS[cat] if n == name), "")
+        param = (self.param_tf.value or "").strip()
+        full = f"{cmd} {param}".rstrip() if param else cmd
+        # подсветим выполняемую команду в выводе
+        self.output.controls.append(
+            ft.Text(f"$ {full}", size=12, font_family="Consolas",
+                    color=ft.Colors.YELLOW_300, weight=ft.FontWeight.BOLD)
+        )
+        self._term.write(full + "\n")
+        self.param_tf.value = ""
+        self._page.update()