gpu-server-setup 0.4.0__py3-none-any.whl

gpu_server_setup-0.4.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: gpu-server-setup
+Version: 0.4.0
+Summary: Один клик — удалённый GPU-сервер с Ollama + VS Code Remote
+Author: The Fool
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]>=0.12
+Requires-Dist: rich>=13.7
+Requires-Dist: paramiko>=3.4
+Requires-Dist: pydantic-settings>=2.5
+Requires-Dist: tomli>=2.0; python_version >= "3.9"
+Dynamic: license-file
+
+```markdown
+# Gpu-setup — один клик до удалённого GPU-сервера с Ollama и VS Code Remote
+
+Автоматическая настройка SSH, установка [Ollama](https://ollama.com/), загрузка LLM-моделей и открытие VS Code Remote на удалённом GPU-сервере — всё одной командой.
+
+---
+
+## Возможности
+
+- **Генерация SSH-ключей** (ed25519 / RSA) и автоматическое копирование публичного ключа на сервер.
+- **Настройка `~/.ssh/config`** с алиасом для удобного подключения.
+- **Установка Ollama** (через официальный скрипт) с запуском сервиса.
+- **Загрузка моделей** (например, `llama3.2`, `gemma2`) с живым выводом прогресса.
+- **Автоматический запуск VS Code Remote** (если установлен `code` CLI).
+- **Режим `--dry-run`** для безопасного просмотра плана действий.
+- **Красивый вывод** с помощью `rich`.
+
+---
+
+## Предварительные требования
+
+- Python 3.8+ (рекомендуется 3.10)
+- Удалённый сервер с Linux (Ubuntu/Debian/CentOS) и предустановленным Python
+- Доступ по SSH с паролем (для первого копирования ключа)
+- На локальной машине:
+  - `ssh-keygen` (обычно уже есть)
+  - `ssh` клиент
+  - (опционально) `code` для VS Code Remote (если планируете открывать редактор)
+
+---
+
+## Установка
+
+```bash
+# Клонируем репозиторий
+git clone https://github.com/your-username/gpu-setup.git
+cd gpu-setup
+
+# Устанавливаем в виртуальное окружение (рекомендуется)
+python -m venv venv
+source venv/bin/activate   # или venv\Scripts\activate на Windows
+
+# Устанавливаем зависимости
+pip install -r requirements.txt
+
+# Устанавливаем пакет в режиме разработки (опционально)
+pip install -e .
+```
+
+После этого команда `gpu-setup` будет доступна в терминале.
+
+---
+
+## Использование
+
+Общий синтаксис:
+
+```bash
+gpu-setup [команда] [опции]
+```
+
+### Доступные команды
+
+| Команда           | Описание |
+|-------------------|----------|
+| `setup`           | **Полная настройка:** SSH, Ollama, модель, VS Code |
+| `ssh`             | Только настройка SSH-ключей и алиаса |
+| `ollama-install`  | Установка Ollama на сервер |
+| `model-pull`      | Загрузка указанной модели (после установки Ollama) |
+| `vscode`          | Открытие VS Code Remote (если `code` установлен) |
+| `plan`            | Показать план действий без выполнения (dry-run) |
+
+---
+
+## Подробное описание команд
+
+### `gpu-setup setup`
+
+Выполняет все шаги: генерация ключа, копирование, настройка SSH-конфига, установка Ollama, загрузка модели, открытие VS Code.
+
+**Опции:**
+
+- `--ip` (обязательный) — IP сервера
+- `--user` (обязательный) — имя пользователя
+- `--password` (обязательный для первого подключения) — пароль (можно ввести интерактивно)
+- `--model` — модель для скачивания (например `llama3.2`)
+- `--install-ollama` / `--no-install` — устанавливать Ollama (по умолчанию `--install-ollama`)
+- `--no-vscode` — не открывать VS Code (по умолчанию открывает)
+- `--dry-run` — только показать план
+- `--key-type` — тип ключа: `ed25519` (по умолчанию) или `rsa`
+
+---
+
+### `gpu-setup ssh`
+
+Только настройка SSH-доступа по ключу.
+
+**Опции:**
+
+- `--ip` (обязательный)
+- `--user` (обязательный)
+- `--password` (обязательный для первого копирования)
+- `--dry-run`
+- `--key-type`
+
+---
+
+### `gpu-setup ollama-install`
+
+Устанавливает Ollama на сервер (требуется пароль для sudo).
+
+**Опции:**
+
+- `--ip` (обязательный)
+- `--user` (обязательный)
+- `--password` (обязательный, т.к. нужен sudo)
+- `--dry-run`
+
+---
+
+### `gpu-setup model-pull MODEL`
+
+Скачивает указанную модель через Ollama. Если сервис Ollama не запущен, пытается запустить его автоматически.
+
+**Аргументы:**
+
+- `MODEL` — имя модели (например `llama3.2`)
+
+**Опции:**
+
+- `--ip` (обязательный)
+- `--user` (обязательный)
+- `--password` (необязателен, если SSH уже настроен; нужен только для запуска сервиса)
+- `--dry-run`
+
+---
+
+### `gpu-setup vscode`
+
+Открывает текущую сессию в VS Code Remote.
+
+**Опции:**
+
+- `--ip` (обязательный)
+- `--user` (обязательный)
+- `--password` (не требуется, если ключ настроен)
+- `--dry-run`
+
+---
+
+### `gpu-setup plan`
+
+Показывает, какие шаги будут выполнены при вызове `setup` с указанными параметрами.
+
+**Опции:**
+
+- `--ip` (обязательный)
+- `--user` (обязательный)
+- `--model`
+- `--install-ollama` / `--no-install`
+- `--no-vscode`
+
+---
+
+## Примеры использования
+
+### 1. Полная настройка (самый частый вариант)
+
+```bash
+gpu-setup setup --ip 195.208.16.2 --user user --password sWDoAVym --model llama3.2
+```
+
+### 2. Только SSH-ключи + config
+
+```bash
+gpu-setup ssh --ip 195.208.16.2 --user user --password sWDoAVym
+```
+
+### 3. Только установить Ollama
+
+```bash
+gpu-setup ollama-install --ip 195.208.16.2 --user user --password sWDoAVym
+```
+
+### 4. Только скачать модель (пароль уже не нужен, если SSH настроен)
+
+```bash
+gpu-setup model-pull llama3.2 --ip 195.208.16.2 --user user
+```
+
+### 5. Только открыть VS Code Remote
+
+```bash
+gpu-setup vscode --ip 195.208.16.2 --user user
+```
+
+### 6. Посмотреть план перед запуском
+
+```bash
+gpu-setup plan --ip 195.208.16.2 --user user --model llama3.2
+```
+
+---
+
+## Dry-run
+
+Любая команда поддерживает флаг `--dry-run`.  
+В этом режиме ничего не изменяется, а только выводится, что было бы сделано.
+
+```bash
+gpu-setup setup --ip 195.208.16.2 --user user --dry-run
+```
+---
+
+## Устранение неполадок
+
+- **`ssh: Could not resolve hostname`** — проверьте IP и доступность сервера.
+- **Ошибка при копировании ключа** — убедитесь, что пароль верный и на сервере разрешена аутентификация по паролю (`PasswordAuthentication yes` в `/etc/ssh/sshd_config`).
+- **Ollama не устанавливается** — возможно, требуется вручную разрешить `sudo` без пароля или передать пароль в опции.
+- **VS Code не открывается** — установите CLI-команду `code` (в VS Code: `Shift+Ctrl+P` → `Install 'code' command in PATH`).
+
+---
+
+## Лицензия
+
+MIT License. См. файл [LICENSE](LICENSE).
+
+---
+
+## Вклад
+
+PR и issues приветствуются!

gpu_server_setup-0.4.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+gpu_server_setup-0.4.0.dist-info/licenses/LICENSE,sha256=ZWAZzQVUVtlMdFelTjFhMd-K8y2T9tFK4EyLxMkU9Ao,201
+gpu_setup/__init__.py,sha256=avsbCKip30Rpzp1Xah_6nKWzTTTDXCoqG1vbJXEEE3Q,39
+gpu_setup/__version__.py,sha256=pVYhOkVS5PHJd_cIEx6PTaY6VggXFTC3pqWdf0I8zao,21
+gpu_setup/cli.py,sha256=Gc27DVPWoXkwPWpwAhrs4fQeMT69raWotldJOJPSldg,4548
+gpu_setup/config.py,sha256=sYh7ZrKciweVoG_KcRZhepNTD9llPIhsUvkF6LRsp6U,405
+gpu_setup/core.py,sha256=VdRztX4hOz8T05cikhRspC41-zlfdyyGWO6sHpb02Hw,12718
+gpu_setup/rich_console.py,sha256=UgTfBq3w-okFmC0sfMKrOikHE5SbhQ6cc-xjoaw0-xY,1135
+gpu_setup/utils.py,sha256=_d4frRgb1oWSFFKp4tjjfyfCWjx1JiPgdtlyOI_4fXo,609
+gpu_server_setup-0.4.0.dist-info/METADATA,sha256=PZl4NIx0QszbnyQgk6ZNd5V5z9RyG4ycC4JdhOncq7c,8686
+gpu_server_setup-0.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gpu_server_setup-0.4.0.dist-info/entry_points.txt,sha256=CfPLHuqN1W6kaaKXckZAxW4KGfM_yKb1_v4uQ8ps8is,55
+gpu_server_setup-0.4.0.dist-info/top_level.txt,sha256=hEATDPSHJ8aD3B1_Txg94aJsKavZXMFQbaJHEst5WqY,10
+gpu_server_setup-0.4.0.dist-info/RECORD,,

gpu_server_setup-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gpu_server_setup-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gpu-server-setup = gpu_setup.cli:app

gpu_server_setup-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+
+### 3. `LICENSE`
+```text
+MIT License
+
+Copyright (c) 2025 Твой Ник
+
+Permission is hereby granted, free of charge...
+(стандартный MIT — можешь оставить как есть)

gpu_server_setup-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gpu_setup

gpu_setup/__init__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+__all__ = ["app"]

gpu_setup/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

gpu_setup/cli.py

@@ -0,0 +1,138 @@
+import typer
+from typing import Optional
+
+from .core import GPUServer, get_plan
+from .rich_console import header, plan_table, success, error
+
+app = typer.Typer(
+    name="gpu-setup",
+    help="Один клик — удалённый GPU-сервер с Ollama + VS Code Remote",
+    rich_markup_mode="rich",
+    add_completion=True,
+)
+
+
+@app.command()
+def plan(
+    ip: str = typer.Option(..., "--ip", help="IP-адрес сервера"),
+    user: str = typer.Option(..., "--user", help="Имя пользователя"),
+    model: Optional[str] = typer.Option(None, "--model", help="Модель Ollama"),
+    install_ollama: bool = typer.Option(True, "--install-ollama/--no-install"),
+    no_vscode: bool = typer.Option(False, "--no-vscode"),
+):
+    """Показать план выполнения (dry-run)"""
+    server = GPUServer(ip=ip, user=user, dry_run=True)
+    plan_list = get_plan(server, install_ollama, model, no_vscode)
+    header(f"План для сервера {ip}")
+    plan_table(plan_list)
+
+
+@app.command()
+def setup(
+    ip: str = typer.Option(..., "--ip", help="IP-адрес сервера"),
+    user: str = typer.Option(..., "--user", help="Имя пользователя"),
+    password: str = typer.Option(
+        None,
+        "--password",
+        prompt=True,
+        hide_input=True,
+        help="Пароль (только для первого подключения и sudo)",
+    ),
+    model: Optional[str] = typer.Option(None, "--model", help="Модель Ollama (например llama3.2)"),
+    install_ollama: bool = typer.Option(True, "--install-ollama/--no-install"),
+    no_vscode: bool = typer.Option(False, "--no-vscode"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+    key_type: str = typer.Option("ed25519", "--key-type"),
+):
+    if dry_run:
+        plan(ip=ip, user=user, model=model, install_ollama=install_ollama, no_vscode=no_vscode)
+        return
+
+    server = GPUServer(
+        ip=ip, user=user, password=password, key_type=key_type, dry_run=False
+    )
+
+    server.generate_key()
+    server.copy_pubkey()
+    server.setup_ssh_config()
+    server.test_connection()
+
+    if install_ollama:
+        server.install_ollama()
+
+    if model:
+        server.pull_model(model)
+
+    if not no_vscode:
+        server.open_vscode()
+
+    success("Готово! 🎉")
+    if model:
+        typer.echo(f"\nЗапуск модели: [bold]ollama run {model}[/bold]")
+
+
+
+@app.command()
+def ssh(
+    ip: str = typer.Option(..., "--ip", help="IP-адрес сервера"),
+    user: str = typer.Option(..., "--user", help="Имя пользователя"),
+    password: str = typer.Option(
+        None,
+        "--password",
+        prompt=True,
+        hide_input=True,
+        help="Пароль для первого копирования ключа",
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+    key_type: str = typer.Option("ed25519", "--key-type"),
+):
+    server = GPUServer(ip=ip, user=user, password=password, key_type=key_type, dry_run=dry_run)
+    server.generate_key()
+    server.copy_pubkey()
+    server.setup_ssh_config()
+    server.test_connection()
+    success("SSH полностью настроен!")
+
+
+@app.command("ollama-install")
+def ollama_install(
+    ip: str = typer.Option(..., "--ip"),
+    user: str = typer.Option(..., "--user"),
+    password: str = typer.Option(
+        None,
+        "--password",
+        prompt=True,
+        hide_input=True,
+        help="Пароль для sudo",
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+):
+    server = GPUServer(ip=ip, user=user, password=password, dry_run=dry_run)
+    server.install_ollama()
+
+
+@app.command("model-pull")
+def model_pull(
+    model: str = typer.Argument(..., help="Название модели (llama3.2, gemma2 и т.д.)"),
+    ip: str = typer.Option(..., "--ip"),
+    user: str = typer.Option(..., "--user"),
+    password: Optional[str] = typer.Option(None, "--password", hide_input=True),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+):
+    server = GPUServer(ip=ip, user=user, password=password, dry_run=dry_run)
+    server.pull_model(model)
+
+
+@app.command()
+def vscode(
+    ip: str = typer.Option(..., "--ip"),
+    user: str = typer.Option(..., "--user"),
+    password: Optional[str] = typer.Option(None, "--password", hide_input=True),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+):
+    server = GPUServer(ip=ip, user=user, password=password, dry_run=dry_run)
+    server.open_vscode()
+
+
+if __name__ == "__main__":
+    app()

gpu_setup/config.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="GPU_SETUP_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    default_key_type: str = "ed25519"
+    config_dir: Path = Path.home() / ".config" / "gpu-setup"
+
+
+settings = Settings()

gpu_setup/core.py

@@ -0,0 +1,331 @@
+from pathlib import Path
+import sys
+from typing import Optional
+
+import paramiko
+from paramiko import SSHClient, AutoAddPolicy, SSHException
+
+from .utils import run_local, console
+from .rich_console import header, success, error, warning
+from .config import settings
+
+import subprocess
+import shutil
+import time
+
+
+class GPUServer:
+    def __init__(
+        self,
+        ip: str,
+        user: str,
+        password: Optional[str] = None,
+        key_type: str = "ed25519",
+        dry_run: bool = False,
+    ):
+        self.ip = ip
+        self.user = user
+        self.password = password
+        self.dry_run = dry_run
+        self.key_type = key_type
+        self.alias = f"gpu-server-{ip.replace('.', '-')}"
+        self.key_path = Path.home() / f".ssh/id_{key_type}_gpu"
+        self.pub_path = self.key_path.with_suffix(".pub")
+        self.config_file = Path.home() / ".ssh/config"
+
+    def generate_key(self) -> None:
+        header("Генерация SSH-ключа")
+        if self.key_path.exists():
+            success("SSH-ключ уже существует")
+            return
+
+        if self.dry_run:
+            console.print("[dim]DRY-RUN: ssh-keygen[/dim]")
+            return
+
+        cmd = (
+            ["ssh-keygen", "-t", self.key_type, "-f", str(self.key_path), "-N", "", "-q"]
+            if self.key_type == "ed25519"
+            else ["ssh-keygen", "-t", "rsa", "-b", "4096", "-f", str(self.key_path), "-N", "", "-q"]
+        )
+        run_local(cmd)
+        success(f"Ключ {self.key_type} создан")
+
+    def copy_pubkey(self) -> None:
+        header("Копирование публичного ключа на сервер")
+        if self.dry_run:
+            console.print("[dim]DRY-RUN: копирование ключа через paramiko[/dim]")
+            return
+
+        if not self.password:
+            error("Для первого подключения нужен пароль")
+            sys.exit(1)
+
+        try:
+            client = SSHClient()
+            client.set_missing_host_key_policy(AutoAddPolicy())
+            client.connect(
+                hostname=self.ip,
+                username=self.user,
+                password=self.password,
+                timeout=15,
+                look_for_keys=False,
+                allow_agent=False,
+            )
+
+            pubkey = self.pub_path.read_text().strip()
+            cmd = (
+                f"mkdir -p ~/.ssh && chmod 700 ~/.ssh && "
+                f"echo '{pubkey}' >> ~/.ssh/authorized_keys && "
+                f"chmod 600 ~/.ssh/authorized_keys"
+            )
+
+            _, stdout, stderr = client.exec_command(cmd)
+            stdout.read()
+            stderr.read()
+            client.close()
+            success("Публичный ключ добавлен")
+        except SSHException as e:
+            error(f"Не удалось скопировать ключ: {e}")
+            sys.exit(1)
+
+    def setup_ssh_config(self) -> None:
+        header("Настройка ~/.ssh/config")
+        if self.dry_run:
+            console.print("[dim]DRY-RUN: запись алиаса[/dim]")
+            return
+
+        entry = f"""
+Host {self.alias}
+    HostName {self.ip}
+    User {self.user}
+    IdentityFile {self.key_path}
+    StrictHostKeyChecking no
+"""
+
+        self.config_file.parent.mkdir(exist_ok=True)
+        self.config_file.touch(exist_ok=True)
+
+        content = self.config_file.read_text()
+        if f"Host {self.alias}" not in content:
+            with open(self.config_file, "a", encoding="utf-8") as f:
+                f.write(entry)
+            success(f"Алиас {self.alias} добавлен")
+        else:
+            success("Алиас уже существует")
+
+    def test_connection(self) -> None:
+        header("Тест SSH-подключения по ключу")
+        if self.dry_run:
+            console.print("[dim]DRY-RUN: тест SSH[/dim]")
+            return
+
+        try:
+            client = SSHClient()
+            client.set_missing_host_key_policy(AutoAddPolicy())
+            client.connect(
+                hostname=self.ip,
+                username=self.user,
+                key_filename=str(self.key_path),
+                timeout=10,
+                look_for_keys=False,
+                allow_agent=False,
+            )
+            client.exec_command("exit")
+            client.close()
+            success("SSH по ключу работает")
+        except Exception as e:
+            error(f"Тест SSH провалился: {e}")
+            sys.exit(1)
+
+    def install_ollama(self) -> None:
+        header("Установка Ollama")
+        if self.dry_run:
+            console.print("[dim]DRY-RUN: установка Ollama[/dim]")
+            return
+
+        client = SSHClient()
+        client.set_missing_host_key_policy(AutoAddPolicy())
+        client.connect(hostname=self.ip, username=self.user, key_filename=str(self.key_path))
+
+        _, stdout, _ = client.exec_command("command -v ollama")
+        if stdout.read().decode().strip():
+            success("Ollama уже установлен")
+            client.close()
+            return
+
+        if not self.password:
+            error("Для установки Ollama нужен пароль (sudo)")
+            sys.exit(1)
+
+        sudo_client = SSHClient()
+        sudo_client.set_missing_host_key_policy(AutoAddPolicy())
+        sudo_client.connect(
+            hostname=self.ip,
+            username=self.user,
+            password=self.password,
+            timeout=15,
+        )
+
+        install_cmd = "bash -c 'curl -fsSL https://ollama.com/install.sh | sh'"
+        _, stdout, stderr = sudo_client.exec_command(f"sudo -S {install_cmd}")
+        stdout.channel.send(self.password + "\n")
+        stdout.channel.flush()
+    
+        output = stdout.read().decode()
+        err_output = stderr.read().decode()
+        if err_output:
+            console.print(err_output, end="")
+            
+        console.print("[bold blue]Запускаем Ollama сервис...[/bold blue]")
+        start_cmd = "sudo systemctl enable ollama && sudo systemctl start ollama"
+        _, stdout, stderr = sudo_client.exec_command(start_cmd)
+        
+        stdout.read()
+        err_output = stderr.read().decode()
+
+        if err_output:
+            console.print(err_output, end="")
+
+        success("Ollama сервис запущен")
+
+        sudo_client.close()
+        client.close()
+        success("Ollama успешно установлен")
+
+    def pull_model(self, model: str) -> None:
+        header(f"Скачивание модели {model}")
+        if self.dry_run:
+            console.print(f"[dim]DRY-RUN: ollama pull {model}[/dim]")
+            return
+
+        client = SSHClient()
+        client.set_missing_host_key_policy(AutoAddPolicy())
+        client.connect(hostname=self.ip, username=self.user, key_filename=str(self.key_path))
+
+        _, stdout, _ = client.exec_command("command -v ollama")
+        if not stdout.read().decode().strip():
+            error("Ollama не установлен. Добавь --install-ollama")
+            sys.exit(1)
+
+        def check_ollama_service():
+            _, stdout, stderr = client.exec_command("ollama list")
+            exit_code = stdout.channel.recv_exit_status()
+            if exit_code != 0:
+                err_output = stderr.read().decode()
+                if "could not connect to ollama server" in err_output:
+                    return False, err_output
+            return True, None
+
+        service_ok, err_msg = check_ollama_service()
+        if not service_ok:
+            warning("Ollama сервис не отвечает. Пытаемся запустить...")
+
+            if self.password:
+                sudo_client = SSHClient()
+                sudo_client.set_missing_host_key_policy(AutoAddPolicy())
+                sudo_client.connect(
+                    hostname=self.ip,
+                    username=self.user,
+                    password=self.password,
+                    timeout=15,
+                )
+
+                console.print("[dim]Запуск через systemctl...[/dim]")
+                stdin, stdout, stderr = sudo_client.exec_command("sudo -S systemctl start ollama")
+                stdin.write(self.password + "\n")
+                stdin.flush()
+                stdout.read()
+                stderr.read()
+                sudo_client.close()
+
+                console.print("[dim]Даём 5 секунд на запуск...[/dim]")
+                time.sleep(5)
+
+                service_ok, err_msg = check_ollama_service()
+                if not service_ok:
+                    warning(f"systemctl не помог: {err_msg}")
+                    console.print("[dim]Пробуем запустить ollama serve в фоне...[/dim]")
+                    sudo_client2 = SSHClient()
+                    sudo_client2.set_missing_host_key_policy(AutoAddPolicy())
+                    sudo_client2.connect(
+                        hostname=self.ip,
+                        username=self.user,
+                        password=self.password,
+                        timeout=15,
+                    )
+                    start_cmd = f"nohup ollama serve > /tmp/ollama.log 2>&1 &"
+                    stdin, stdout, stderr = sudo_client2.exec_command(f"sudo -S -u {self.user} bash -c '{start_cmd}'")
+                    stdin.write(self.password + "\n")
+                    stdin.flush()
+                    stdout.read()
+                    stderr.read()
+                    sudo_client2.close()
+
+                    console.print("[dim]Даём 10 секунд на запуск...[/dim]")
+                    time.sleep(10)
+
+                    # Последняя проверка
+                    service_ok, err_msg = check_ollama_service()
+                    if not service_ok:
+                        error(f"Не удалось запустить сервис: {err_msg}")
+                        sys.exit(1)
+                    else:
+                        success("Сервис Ollama успешно запущен (через nohup)")
+                else:
+                    success("Сервис Ollama успешно запущен (через systemctl)")
+            else:
+                error("Пароль не задан, невозможно автоматически запустить сервис.")
+                console.print("Запустите вручную: ssh {} 'sudo systemctl start ollama' или 'ollama serve'".format(self.alias))
+                sys.exit(1)
+
+        _, stdout, _ = client.exec_command(f"ollama list | grep -q '{model}'")
+        if stdout.channel.recv_exit_status() == 0:
+            success(f"Модель {model} уже есть")
+            client.close()
+            return
+
+        console.print(f"[bold blue]Скачиваем {model}...[/bold blue]")
+        stdin, stdout, stderr = client.exec_command(f"ollama pull {model}", get_pty=True)
+        channel = stdout.channel
+
+        while not channel.exit_status_ready():
+            if channel.recv_ready():
+                print(channel.recv(1024).decode("utf-8", errors="replace"), end="", flush=True)
+            if channel.recv_stderr_ready():
+                print(channel.recv_stderr(1024).decode("utf-8", errors="replace"), end="", flush=True)
+
+        print(stdout.read().decode(), end="")
+        err_out = stderr.read().decode()
+        if err_out:
+            print(err_out, end="")
+        client.close()
+        success(f"Модель {model} готова")
+
+    def open_vscode(self) -> None:
+        header("Открываем VS Code Remote")
+        if self.dry_run:
+            console.print(f"[dim]DRY-RUN: code --remote ssh-remote+{self.alias}[/dim]")
+            return
+        
+        if shutil.which("code"):
+            subprocess.run(["code", "--remote", f"ssh-remote+{self.alias}"])
+            success("VS Code Remote открыт")
+        else:
+            warning("Команда 'code' не найдена. Установи VS Code CLI")
+
+
+def get_plan(server: GPUServer, install_ollama: bool, model: Optional[str], no_vscode: bool) -> list:
+    plan = [
+        ("Генерация ключа", "ed25519 (если нет)"),
+        ("Копирование ключа", "на сервер"),
+        ("SSH config", f"алиас {server.alias}"),
+        ("Тест подключения", "по ключу"),
+    ]
+    if install_ollama:
+        plan.append(("Ollama", "установка"))
+    if model:
+        plan.append(("Модель", f"ollama pull {model}"))
+    if not no_vscode:
+        plan.append(("VS Code", "открытие Remote"))
+    return plan

gpu_setup/rich_console.py

@@ -0,0 +1,39 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+console = Console()
+
+def header(text: str) -> None:
+    console.print(Panel(f"[bold green]{text}[/bold green]", expand=False))
+
+
+def success(text: str) -> None:
+    console.print(f"[bold green]{text}[/bold green]")
+
+
+def warning(text: str) -> None:
+    console.print(f"[bold yellow]{text}[/bold yellow]")
+
+
+def error(text: str) -> None:
+    console.print(f"[bold red]{text}[/bold red]")
+
+
+def plan_table(plan: list[tuple[str, str]]) -> None:
+    table = Table(title="План выполнения", show_header=True, header_style="bold magenta")
+    table.add_column("Шаг", style="cyan")
+    table.add_column("Описание", style="dim")
+    for step, desc in plan:
+        table.add_row(step, desc)
+    console.print(table)
+
+
+def live_ollama_output() -> None:
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]Скачиваем модель...[/bold blue]"),
+        transient=True,
+    ) as progress:
+        progress.add_task("pull", total=None)

gpu_setup/utils.py

@@ -0,0 +1,22 @@
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+from rich.console import Console
+
+console = Console()
+
+def run_local(cmd: List[str], dry_run: bool = False) -> None:
+    if dry_run:
+        console.print(f"[dim]DRY-RUN → {' '.join(cmd)}[/dim]")
+        return
+    try:
+        subprocess.run(cmd, check=True, capture_output=True)
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Локальная команда провалилась:[/red] {e}")
+        sys.exit(1)
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)