llmport-cli 0.1.0__py3-none-any.whl

llmport/__init__.py

@@ -0,0 +1,16 @@
+"""llmport — CLI installer and management tool for llm.port.
+
+Layered command structure built on Click framework.
+Install, configure, and manage the full platform.
+YAML-driven configuration persisted in llmport.yaml.
+Async HTTP calls to backend REST API via httpx.
+Native Docker Compose integration for orchestration.
+Automatic system detection for OS, GPU, and Docker.
+GPU vendor discovery supports NVIDIA and AMD ROCm.
+Rich terminal output with tables, panels, progress.
+Advanced TUI wizard powered by Textual framework.
+Module activation via Docker Compose profiles.
+All secrets generated securely during init phase.
+"""
+
+__version__ = "0.1.0"

llmport/cli.py

@@ -0,0 +1,95 @@
+"""CLI entry point — Click root group and subcommand registration.
+
+This module defines the ``llmport`` command group and wires up all
+subcommands.  Run ``llmport --help`` for the full command tree.
+"""
+
+from __future__ import annotations
+
+import click
+
+from llmport import __version__
+
+
+class AliasedGroup(click.Group):
+    """Click group that supports command abbreviations.
+
+    For instance ``llmport st`` resolves to ``llmport status`` if no
+    other command starts with ``st``.
+    """
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        rv = click.Group.get_command(self, ctx, cmd_name)
+        if rv is not None:
+            return rv
+        matches = [x for x in self.list_commands(ctx) if x.startswith(cmd_name)]
+        if not matches:
+            return None
+        if len(matches) == 1:
+            return click.Group.get_command(self, ctx, matches[0])
+        ctx.fail(f"Ambiguous command '{cmd_name}'. Did you mean: {', '.join(sorted(matches))}?")
+        return None  # unreachable, but satisfies type checker
+
+
+@click.group(cls=AliasedGroup, invoke_without_command=True)
+@click.option("-v", "--verbose", is_flag=True, help="Enable verbose output.")
+@click.option("-q", "--quiet", is_flag=True, help="Suppress informational output.")
+@click.version_option(version=__version__, prog_name="llmport")
+@click.pass_context
+def cli(ctx: click.Context, *, verbose: bool, quiet: bool) -> None:
+    """llmport — CLI installer and management tool for llm.port."""
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    ctx.obj["quiet"] = quiet
+
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+# ── Register subcommands ──────────────────────────────────────────
+
+def register_core_commands(group: click.Group | None = None) -> None:
+    """Import and register all core subcommand groups and commands.
+
+    Accepts an optional *group* parameter so the EE CLI can call this
+    with its own root group.  Defaults to ``cli`` when called internally.
+    """
+    target = group or cli
+
+    from llmport.commands.version import version_cmd
+    from llmport.commands.doctor import doctor_cmd
+    from llmport.commands.status import status_cmd
+    from llmport.commands.up import up_cmd
+    from llmport.commands.down import down_cmd
+    from llmport.commands.logs_cmd import logs_cmd
+    from llmport.commands.config import config_group
+    from llmport.commands.module import module_group
+    from llmport.commands.tune import tune_cmd
+    from llmport.commands.deploy import deploy_cmd
+    from llmport.commands.dev.dev_group import dev_group
+    from llmport.commands.admin import admin_group
+
+    target.add_command(version_cmd, "version")
+    target.add_command(doctor_cmd, "doctor")
+    target.add_command(status_cmd, "status")
+    target.add_command(up_cmd, "up")
+    target.add_command(down_cmd, "down")
+    target.add_command(logs_cmd, "logs")
+    target.add_command(config_group, "config")
+    target.add_command(module_group, "module")
+    target.add_command(tune_cmd, "tune")
+    target.add_command(deploy_cmd, "deploy")
+    target.add_command(dev_group, "dev")
+    target.add_command(admin_group, "admin")
+
+
+register_core_commands()
+
+
+def main() -> None:
+    """Package entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

llmport/commands/__init__.py

@@ -0,0 +1 @@
+"""Command implementations for the llmport CLI."""

llmport/commands/admin.py

@@ -0,0 +1,154 @@
+"""``llmport admin`` — administrative commands for a running deployment."""
+
+from __future__ import annotations
+
+import re
+import secrets
+import shutil
+import string
+import subprocess
+import sys
+
+import click
+
+from llmport.core.console import console, error, info, success, warning
+
+
+def _generate_password(length: int = 24) -> str:
+    """Generate a random password (letters + digits + punctuation subset)."""
+    alphabet = string.ascii_letters + string.digits + "!@#$%&*-_=+"
+    return "".join(secrets.choice(alphabet) for _ in range(length))
+
+
+# Minimal email validation — rejects obvious injection attempts.
+_EMAIL_RE = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-.]+$")
+
+
+@click.group("admin")
+def admin_group() -> None:
+    """Administrative commands for a running llm.port deployment."""
+
+
+@admin_group.command("reset-password")
+@click.option(
+    "--email",
+    default="admin@localhost",
+    show_default=True,
+    help="Email address of the user whose password will be reset.",
+)
+@click.option(
+    "--password",
+    default=None,
+    help="New password.  Auto-generated if omitted.",
+)
+@click.option(
+    "-y", "--yes",
+    is_flag=True,
+    help="Skip confirmation prompt.",
+)
+def reset_password_cmd(*, email: str, password: str | None, yes: bool) -> None:
+    """Reset a user's password directly via the database.
+
+    This bypasses the API and sets the password hash in PostgreSQL.
+    The backend container must be running (needed for password hashing).
+    """
+    # Validate email early to prevent any injection
+    if not _EMAIL_RE.match(email):
+        error(f"Invalid email address: {email}")
+        sys.exit(1)
+
+    docker = shutil.which("docker")
+    if not docker:
+        error("docker not found on PATH")
+        sys.exit(1)
+
+    new_password = password or _generate_password()
+
+    if not yes:
+        click.confirm(
+            f"Reset password for '{email}'?",
+            abort=True,
+        )
+
+    # ── 1. Hash the password inside the backend container ─────
+    info("Hashing new password…")
+    hash_script = (
+        "from fastapi_users.password import PasswordHelper; "
+        "print(PasswordHelper().hash(input()))"
+    )
+
+    hash_result = subprocess.run(  # noqa: S603
+        [
+            docker, "exec", "-i", "llm-port-backend",
+            "python", "-c", hash_script,
+        ],
+        input=new_password,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if hash_result.returncode != 0:
+        error("Failed to hash password — is the backend container running?")
+        if hash_result.stderr.strip():
+            error(f"  {hash_result.stderr.strip()}")
+        sys.exit(1)
+
+    hashed = hash_result.stdout.strip()
+    if not hashed:
+        error("Password hashing returned empty result.")
+        sys.exit(1)
+
+    # ── 2. Update the password in PostgreSQL ──────────────────
+    info("Updating password in database…")
+
+    # Both `hashed` (bcrypt output we generated) and `email` (validated
+    # above by regex) are safe for SQL string interpolation here.
+    sql = (
+        f"UPDATE \"user\" SET hashed_password = '{hashed}' "
+        f"WHERE email = '{email}';"
+    )
+
+    pg_result = subprocess.run(  # noqa: S603
+        [
+            docker, "exec", "llm-port-postgres",
+            "psql", "-U", "postgres", "-d", "llm_port_backend",
+            "-c", sql,
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    if pg_result.returncode != 0:
+        error("Database update failed — is the postgres container running?")
+        if pg_result.stderr.strip():
+            error(f"  {pg_result.stderr.strip()}")
+        sys.exit(1)
+
+    # Check if a row was actually updated
+    if "UPDATE 0" in pg_result.stdout:
+        warning(f"No user found with email '{email}'.")
+        sys.exit(1)
+
+    success(f"Password reset for '{email}'.")
+
+    # ── 3. Display credentials ────────────────────────────────
+    from rich.panel import Panel
+    from rich.text import Text
+
+    lines = Text()
+    lines.append("  Email:     ", style="bold")
+    lines.append(email, style="cyan")
+    lines.append("\n  Password:  ", style="bold")
+    lines.append(new_password, style="cyan")
+    lines.append("\n\n  Store this in a password manager.", style="dim")
+
+    console.print()
+    console.print(
+        Panel(
+            lines,
+            title="[bold yellow]New Credentials[/bold yellow]",
+            border_style="yellow",
+            padding=(1, 2),
+        )
+    )

llmport/commands/config.py

@@ -0,0 +1,146 @@
+"""``llmport config`` — view and manage configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+import yaml
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from llmport.core.console import console, success, error
+from llmport.core.settings import load_config, save_config, config_path
+
+
+@click.group("config")
+def config_group() -> None:
+    """Manage llmport configuration."""
+
+
+@config_group.command("show")
+def config_show() -> None:
+    """Display the current configuration."""
+    cfg_path = config_path()
+
+    if not cfg_path.exists():
+        console.print(f"[dim]No config file found at {cfg_path}[/dim]")
+        console.print("[dim]Using default configuration.[/dim]")
+        cfg = load_config()
+        import dataclasses
+
+        raw = yaml.dump(dataclasses.asdict(cfg), default_flow_style=False, sort_keys=False)
+        console.print(Panel(Syntax(raw, "yaml", theme="monokai"), title="defaults"))
+        return
+
+    raw = cfg_path.read_text(encoding="utf-8")
+    console.print(
+        Panel(
+            Syntax(raw, "yaml", theme="monokai"),
+            title=str(cfg_path),
+            border_style="cyan",
+        )
+    )
+
+
+@config_group.command("set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key: str, value: str) -> None:
+    """Set a configuration value (dot-notation supported).
+
+    Examples:
+
+        llmport config set install_dir /opt/llmport
+
+        llmport config set dev.branch main
+    """
+    cfg = load_config()
+    import dataclasses
+
+    cfg_dict = dataclasses.asdict(cfg)
+
+    # Support dot-notation for nested keys (e.g., dev.branch)
+    parts = key.split(".")
+    target = cfg_dict
+    for part in parts[:-1]:
+        if part not in target or not isinstance(target[part], dict):
+            error(f"Unknown config section: {part}")
+            return
+        target = target[part]
+
+    final_key = parts[-1]
+    if final_key not in target:
+        error(f"Unknown config key: {key}")
+        return
+
+    # Coerce value types
+    old_val = target[final_key]
+    if isinstance(old_val, bool):
+        value_typed: str | bool | int | float | list[str] = value.lower() in ("true", "1", "yes")
+    elif isinstance(old_val, int):
+        value_typed = int(value)
+    elif isinstance(old_val, float):
+        value_typed = float(value)
+    elif isinstance(old_val, list):
+        value_typed = [v.strip() for v in value.split(",")]
+    else:
+        value_typed = value
+
+    target[final_key] = value_typed
+
+    # Rebuild config
+    from llmport.core.settings import LlmportConfig, DevConfig
+
+    dev_data = cfg_dict.pop("dev", {}) or {}
+    dev_cfg = DevConfig(**{k: v for k, v in dev_data.items() if k in DevConfig.__dataclass_fields__})
+    new_cfg = LlmportConfig(**cfg_dict, dev=dev_cfg)
+
+    save_config(new_cfg)
+    success(f"Set {key} = {value_typed}")
+
+
+@config_group.command("path")
+def config_path_cmd() -> None:
+    """Print the config file path."""
+    click.echo(str(config_path()))
+
+
+@config_group.command("init")
+@click.option("--force", is_flag=True, help="Overwrite existing config file.")
+def config_init(*, force: bool) -> None:
+    """Create a default configuration file."""
+    cfg_file = config_path()
+
+    if cfg_file.exists() and not force:
+        error(f"Config file already exists at {cfg_file}. Use --force to overwrite.")
+        return
+
+    cfg = load_config()
+    save_config(cfg)
+    success(f"Configuration written to {cfg_file}")
+
+
+@config_group.command("edit")
+def config_edit() -> None:
+    """Open the config file in $EDITOR."""
+    import os
+    import subprocess
+
+    cfg_file = config_path()
+    if not cfg_file.exists():
+        # Create default first
+        cfg = load_config()
+        save_config(cfg)
+
+    editor = os.environ.get("EDITOR", os.environ.get("VISUAL", ""))
+    if not editor:
+        # Fallback based on platform
+        import platform
+
+        if platform.system() == "Windows":
+            editor = "notepad"
+        else:
+            editor = "nano"
+
+    subprocess.run([editor, str(cfg_file)], check=False)