lcloud-cli 0.1.0__py3-none-any.whl

lambda_cloud/cli/commands/config_cmd.py

@@ -0,0 +1,45 @@
+"""Inspect lambda-cloud CLI configuration."""
+
+from __future__ import annotations
+
+import typer
+from rich.table import Table
+
+from ...api.client import BASE_URL_ENV_VAR, DEFAULT_BASE_URL
+from ...core.config import (
+    API_KEY_ENV_VAR,
+    config_path,
+    describe_api_key_source,
+    mask_api_key,
+)
+from ..state import CommandBase
+from ..ui import history
+
+app = typer.Typer(no_args_is_help=True, help="Inspect lambda-cloud configuration.")
+
+
+@app.command("show")
+def show(ctx: typer.Context) -> None:
+    """Show where the CLI reads its configuration from."""
+    import os
+
+    cmd = CommandBase(ctx, needs_client=False)
+    source = describe_api_key_source(cmd.state.api_key)
+
+    table = Table(title="lambda-cloud configuration", show_header=False)
+    table.add_column("FIELD", style="bold cyan")
+    table.add_column("VALUE")
+    table.add_row("Config file", str(config_path()))
+    table.add_row("API base URL", os.environ.get(BASE_URL_ENV_VAR, DEFAULT_BASE_URL))
+    if source:
+        label, key = source
+        table.add_row("Key source", label)
+        table.add_row("API key", mask_api_key(key))
+    else:
+        table.add_row("Key source", f"not configured (login or set {API_KEY_ENV_VAR})")
+
+    last_launch = history.last_result("instances.launch")
+    if last_launch:
+        table.add_row("Last launch", str(last_launch["data"].get("instance_ids", "-")))
+
+    cmd.emit({"config_file": str(config_path())}, table)

lambda_cloud/cli/commands/filesystems.py

@@ -0,0 +1,53 @@
+"""Manage shared filesystems."""
+
+from __future__ import annotations
+
+import typer
+
+from ...api import service
+from ..state import CommandBase
+from ..ui.console import confirm_or_exit, success
+from ..ui.tables import filesystems_table
+
+app = typer.Typer(no_args_is_help=True, help="Manage shared filesystems.")
+
+
+@app.command("list")
+def list_filesystems(ctx: typer.Context) -> None:
+    """List your filesystems."""
+    cmd = CommandBase(ctx)
+    filesystems = service.list_filesystems(cmd.client)
+    cmd.emit(filesystems, filesystems_table(filesystems))
+
+
+@app.command("create")
+def create_filesystem(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", "-n", help="Filesystem name."),
+    region: str = typer.Option(
+        ..., "--region", "-r", help="Region (see `lambda-cloud regions list`)."
+    ),
+) -> None:
+    """Create a new filesystem."""
+    cmd = CommandBase(ctx)
+    filesystem = service.create_filesystem(cmd.client, name=name, region=region)
+    if cmd.output.value == "table":
+        success(f"Filesystem {filesystem.name!r} created (id: {filesystem.id}).")
+    else:
+        cmd.emit(filesystem)
+
+
+@app.command("delete")
+def delete_filesystem(
+    ctx: typer.Context,
+    filesystem_id: str = typer.Argument(..., help="ID of the filesystem to delete."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete a filesystem. It must not be mounted on any running instance."""
+    cmd = CommandBase(ctx)
+    confirm_or_exit(f"Delete filesystem {filesystem_id}?", yes)
+    service.delete_filesystem(cmd.client, filesystem_id)
+    if cmd.output.value == "table":
+        success(f"Filesystem {filesystem_id} deleted.")
+    else:
+        cmd.emit({"id": filesystem_id})

lambda_cloud/cli/commands/firewall.py

@@ -0,0 +1,157 @@
+"""Manage firewall rulesets (regional and global)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from pydantic import ValidationError
+
+from ...api import service
+from ...core.errors import LambdaCloudError
+from ...mngr.models import FirewallRule
+from ..state import CommandBase
+from ..ui.console import confirm_or_exit, success
+from ..ui.tables import firewall_rules_table, rulesets_table
+
+app = typer.Typer(no_args_is_help=True, help="Manage firewall rulesets.")
+rulesets_app = typer.Typer(no_args_is_help=True, help="Manage regional firewall rulesets.")
+global_app = typer.Typer(no_args_is_help=True, help="Manage the global firewall ruleset.")
+app.add_typer(rulesets_app, name="rulesets")
+app.add_typer(global_app, name="global")
+
+_RULES_FILE_HELP = (
+    "Path to a JSON file containing a list of firewall rules, e.g. "
+    '[{"protocol": "tcp", "port_range": [22, 22], "source_network": "0.0.0.0/0", '
+    '"description": "SSH"}].'
+)
+
+_RULES_FILE_OPTION = dict(
+    exists=True,
+    file_okay=True,
+    dir_okay=False,
+    readable=True,
+    resolve_path=True,
+)
+
+
+def load_rules_file(path: Path) -> list[FirewallRule]:
+    """Load and validate firewall rules from a JSON file."""
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        raise LambdaCloudError(f"Cannot read rules file {path}: {exc}") from exc
+    if not isinstance(raw, list):
+        raise LambdaCloudError(f"Rules file {path} must contain a JSON list of rules.")
+    try:
+        return [FirewallRule.model_validate(item) for item in raw]
+    except ValidationError as exc:
+        raise LambdaCloudError(f"Invalid firewall rule in {path}: {exc}") from exc
+
+
+@rulesets_app.command("list")
+def list_rulesets(ctx: typer.Context) -> None:
+    """List your firewall rulesets."""
+    cmd = CommandBase(ctx)
+    rulesets = service.list_firewall_rulesets(cmd.client)
+    cmd.emit(rulesets, rulesets_table(rulesets))
+
+
+@rulesets_app.command("get")
+def get_ruleset(
+    ctx: typer.Context, ruleset_id: str = typer.Argument(..., help="Ruleset ID.")
+) -> None:
+    """Show a ruleset and its rules."""
+    cmd = CommandBase(ctx)
+    ruleset = service.get_firewall_ruleset(cmd.client, ruleset_id)
+    if cmd.output.value == "table":
+        cmd.emit(ruleset.rules, firewall_rules_table(ruleset.rules))
+    else:
+        cmd.emit(ruleset)
+
+
+@rulesets_app.command("create")
+def create_ruleset(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", "-n", help="Ruleset name."),
+    region: str = typer.Option(..., "--region", "-r", help="Region name."),
+    rules_file: Path = typer.Option(
+        ..., "--rules-file", help=_RULES_FILE_HELP, **_RULES_FILE_OPTION
+    ),
+) -> None:
+    """Create a firewall ruleset from a JSON rules file."""
+    cmd = CommandBase(ctx)
+    rules = load_rules_file(rules_file)
+    ruleset = service.create_firewall_ruleset(cmd.client, name, region, rules)
+    if cmd.output.value == "table":
+        success(f"Ruleset {ruleset.name!r} created (id: {ruleset.id}).")
+    else:
+        cmd.emit(ruleset)
+
+
+@rulesets_app.command("update")
+def update_ruleset(
+    ctx: typer.Context,
+    ruleset_id: str = typer.Argument(..., help="Ruleset ID."),
+    name: str | None = typer.Option(None, "--name", "-n", help="New ruleset name."),
+    rules_file: Path | None = typer.Option(
+        None, "--rules-file", help=_RULES_FILE_HELP, **_RULES_FILE_OPTION
+    ),
+) -> None:
+    """Update a ruleset's name and/or rules (omitted fields stay unchanged)."""
+    cmd = CommandBase(ctx)
+    if name is None and rules_file is None:
+        raise LambdaCloudError("Nothing to update: pass --name and/or --rules-file.")
+    rules = load_rules_file(rules_file) if rules_file else None
+    ruleset = service.update_firewall_ruleset(cmd.client, ruleset_id, name=name, rules=rules)
+    if cmd.output.value == "table":
+        success(f"Ruleset {ruleset_id} updated.")
+    else:
+        cmd.emit(ruleset)
+
+
+@rulesets_app.command("delete")
+def delete_ruleset(
+    ctx: typer.Context,
+    ruleset_id: str = typer.Argument(..., help="Ruleset ID."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete a firewall ruleset."""
+    cmd = CommandBase(ctx)
+    confirm_or_exit(f"Delete firewall ruleset {ruleset_id}?", yes)
+    service.delete_firewall_ruleset(cmd.client, ruleset_id)
+    if cmd.output.value == "table":
+        success(f"Ruleset {ruleset_id} deleted.")
+    else:
+        cmd.emit({"id": ruleset_id})
+
+
+@global_app.command("get")
+def get_global_ruleset(ctx: typer.Context) -> None:
+    """Show the global firewall ruleset."""
+    cmd = CommandBase(ctx)
+    ruleset = service.get_global_firewall_ruleset(cmd.client)
+    if cmd.output.value == "table":
+        cmd.emit(ruleset.rules, firewall_rules_table(ruleset.rules))
+    else:
+        cmd.emit(ruleset)
+
+
+@global_app.command("update")
+def update_global_ruleset(
+    ctx: typer.Context,
+    rules_file: Path = typer.Option(
+        ..., "--rules-file", help=_RULES_FILE_HELP, **_RULES_FILE_OPTION
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Replace the rules of the global firewall ruleset."""
+    cmd = CommandBase(ctx)
+    rules = load_rules_file(rules_file)
+    confirm_or_exit(f"Replace the global firewall ruleset with {len(rules)} rule(s)?", yes)
+    service.update_global_firewall_ruleset(cmd.client, rules)
+    if cmd.output.value == "table":
+        success("Global firewall ruleset updated.")
+    else:
+        cmd.emit(service.get_global_firewall_ruleset(cmd.client))

lambda_cloud/cli/commands/images.py

@@ -0,0 +1,23 @@
+"""List available machine images."""
+
+from __future__ import annotations
+
+import typer
+
+from ...api import service
+from ..state import CommandBase
+from ..ui.tables import images_table
+
+app = typer.Typer(no_args_is_help=True, help="List available machine images.")
+
+
+@app.command("list")
+def list_images(
+    ctx: typer.Context,
+    region: str | None = typer.Option(None, "--region", "-r", help="Only this region."),
+    family: str | None = typer.Option(None, "--family", help="Only this image family."),
+) -> None:
+    """List available images (Lambda Stack and others)."""
+    cmd = CommandBase(ctx)
+    images = service.filter_images(service.list_images(cmd.client), region=region, family=family)
+    cmd.emit(images, images_table(service.sort_images_by_updated(images)))

lambda_cloud/cli/commands/instance_types.py

@@ -0,0 +1,19 @@
+"""List available instance types, prices and capacity."""
+
+from __future__ import annotations
+
+import typer
+
+from ...api import service
+from ..state import CommandBase
+from ..ui.tables import instance_types_table
+
+app = typer.Typer(no_args_is_help=True, help="List instance types, prices and capacity.")
+
+
+@app.command("list")
+def list_instance_types_cmd(ctx: typer.Context) -> None:
+    """List every instance type with its specs, price and regional availability."""
+    cmd = CommandBase(ctx)
+    offers = service.list_instance_types(cmd.client)
+    cmd.emit(offers, instance_types_table(offers))

lambda_cloud/cli/commands/instances.py

@@ -0,0 +1,215 @@
+"""Manage on-demand GPU instances."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.panel import Panel
+
+from ...api import service
+from ...core.errors import LambdaCloudError
+from ...mngr.models import TagEntry
+from ..state import CommandBase
+from ..ui import history
+from ..ui.console import confirm_or_exit, console, success
+from ..ui.tables import instance_detail_table, instances_table
+
+app = typer.Typer(no_args_is_help=True, help="Manage on-demand GPU instances.")
+
+
+def parse_tag(tag: str) -> TagEntry:
+    """Parse a ``key=value`` tag option."""
+    if "=" not in tag:
+        raise LambdaCloudError(f"Invalid tag {tag!r}: expected format key=value.")
+    key, value = tag.split("=", 1)
+    if not key:
+        raise LambdaCloudError(f"Invalid tag {tag!r}: key must not be empty.")
+    return TagEntry(key=key, value=value)
+
+
+def build_launch_payload(
+    *,
+    region: str,
+    instance_type: str,
+    ssh_key: str,
+    name: str | None = None,
+    hostname: str | None = None,
+    filesystems: list[str] | None = None,
+    image_id: str | None = None,
+    image_family: str | None = None,
+    user_data: str | None = None,
+    tags: list[TagEntry] | None = None,
+    firewall_rulesets: list[str] | None = None,
+) -> dict[str, Any]:
+    """Assemble the request body for ``POST /instance-operations/launch``."""
+    if image_id and image_family:
+        raise LambdaCloudError("--image-id and --image-family are mutually exclusive.")
+
+    payload: dict[str, Any] = {
+        "region_name": region,
+        "instance_type_name": instance_type,
+        "ssh_key_names": [ssh_key],
+    }
+    if name is not None:
+        payload["name"] = name
+    if hostname is not None:
+        payload["hostname"] = hostname
+    if filesystems:
+        payload["file_system_names"] = filesystems
+    if image_id is not None:
+        payload["image"] = {"id": image_id}
+    elif image_family is not None:
+        payload["image"] = {"family": image_family}
+    if user_data is not None:
+        payload["user_data"] = user_data
+    if tags:
+        payload["tags"] = [tag.model_dump() for tag in tags]
+    if firewall_rulesets:
+        payload["firewall_rulesets"] = [{"id": ruleset_id} for ruleset_id in firewall_rulesets]
+    return payload
+
+
+@app.command("list")
+def list_instances_cmd(
+    ctx: typer.Context,
+    cluster_id: str | None = typer.Option(None, "--cluster-id", help="Filter by cluster ID."),
+) -> None:
+    """List running instances."""
+    cmd = CommandBase(ctx)
+    instances = service.list_instances(cmd.client, cluster_id=cluster_id)
+    cmd.state.history["instances"] = [instance.id for instance in instances]
+    cmd.emit(instances, instances_table(instances))
+
+
+@app.command("get")
+def get_instance(ctx: typer.Context, instance_id: str = typer.Argument(...)) -> None:
+    """Show details of a single instance."""
+    cmd = CommandBase(ctx)
+    instance = service.get_instance(cmd.client, instance_id)
+    cmd.state.history["instance"] = instance.id
+    cmd.emit(instance, instance_detail_table(instance))
+
+
+@app.command("launch")
+def launch_instance(
+    ctx: typer.Context,
+    instance_type: str = typer.Option(
+        ..., "--type", "-t", help="Instance type name (see `lambda-cloud types list`)."
+    ),
+    region: str = typer.Option(
+        ..., "--region", "-r", help="Region name (see `lambda-cloud regions list`)."
+    ),
+    ssh_key: str = typer.Option(
+        ...,
+        "--ssh-key",
+        "-s",
+        help="Name of an existing SSH key (see `lambda-cloud ssh-keys list`).",
+    ),
+    name: str | None = typer.Option(None, "--name", help="Friendly name for the instance."),
+    hostname: str | None = typer.Option(
+        None, "--hostname", help="Hostname written to /etc/hostname."
+    ),
+    filesystems: list[str] = typer.Option(
+        None, "--filesystem", "-f", help="Filesystem name to mount. Repeatable."
+    ),
+    image_id: str | None = typer.Option(None, "--image-id", help="ID of a specific image."),
+    image_family: str | None = typer.Option(
+        None, "--image-family", help="Image family (defaults to the latest Lambda Stack)."
+    ),
+    user_data: Path | None = typer.Option(
+        None,
+        "--user-data",
+        help="Path to a cloud-init user-data file.",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+    ),
+    tags: list[str] = typer.Option(None, "--tag", help="Tag as key=value. Repeatable."),
+    firewall_rulesets: list[str] = typer.Option(
+        None, "--firewall-ruleset", help="Firewall ruleset ID (same region). Repeatable."
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Launch a new on-demand instance."""
+    cmd = CommandBase(ctx)
+    payload = build_launch_payload(
+        region=region,
+        instance_type=instance_type,
+        ssh_key=ssh_key,
+        name=name,
+        hostname=hostname,
+        filesystems=filesystems,
+        image_id=image_id,
+        image_family=image_family,
+        user_data=user_data.read_text() if user_data else None,
+        tags=[parse_tag(tag) for tag in tags or []],
+        firewall_rulesets=firewall_rulesets,
+    )
+
+    if cmd.output.value == "table":
+        summary = (
+            f"[bold]Type:[/bold] {instance_type}\n"
+            f"[bold]Region:[/bold] {region}\n"
+            f"[bold]SSH key:[/bold] {ssh_key}\n"
+            f"[bold]Name:[/bold] {name or '-'}"
+        )
+        console.print(Panel(summary, title="Launch instance"))
+    confirm_or_exit("Proceed with launch?", yes)
+
+    instance_ids = service.launch_instances(cmd.client, payload)
+    history.record_result("instances.launch", {"instance_ids": instance_ids})
+    if cmd.output.value == "table":
+        for instance_id in instance_ids:
+            success(f"Launch requested for instance {instance_id}")
+    else:
+        cmd.emit({"instance_ids": instance_ids})
+
+
+@app.command("restart")
+def restart_instances_cmd(
+    ctx: typer.Context,
+    instance_ids: list[str] = typer.Argument(..., help="IDs of instances to restart."),
+) -> None:
+    """Restart one or more instances."""
+    cmd = CommandBase(ctx)
+    restarted = service.restart_instances(cmd.client, instance_ids)
+    cmd.emit(restarted, instances_table(restarted))
+
+
+@app.command("terminate")
+def terminate_instances_cmd(
+    ctx: typer.Context,
+    instance_ids: list[str] = typer.Argument(..., help="IDs of instances to terminate."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Terminate one or more instances. This cannot be undone."""
+    cmd = CommandBase(ctx)
+    confirm_or_exit(
+        f"Terminate {len(instance_ids)} instance(s): {', '.join(instance_ids)}?",
+        yes,
+    )
+    terminated = service.terminate_instances(cmd.client, instance_ids)
+    if cmd.output.value == "table":
+        for instance in terminated:
+            success(f"Terminating instance {instance.id}")
+    else:
+        cmd.emit({"terminated_instances": terminated})
+
+
+@app.command("rename")
+def rename_instance(
+    ctx: typer.Context,
+    instance_id: str = typer.Argument(...),
+    name: str = typer.Option(..., "--name", help="New name (empty string to clear)."),
+) -> None:
+    """Rename an instance."""
+    cmd = CommandBase(ctx)
+    service.rename_instance(cmd.client, instance_id, name)
+    if cmd.output.value == "table":
+        success(f"Instance {instance_id} renamed to {name!r}.")
+    else:
+        cmd.emit({"id": instance_id, "name": name})

lambda_cloud/cli/commands/regions.py

@@ -0,0 +1,19 @@
+"""List available regions."""
+
+from __future__ import annotations
+
+import typer
+
+from ...api import service
+from ..state import CommandBase
+from ..ui.tables import regions_table
+
+app = typer.Typer(no_args_is_help=True, help="List available regions.")
+
+
+@app.command("list")
+def list_regions(ctx: typer.Context) -> None:
+    """List every region where instances can be launched."""
+    cmd = CommandBase(ctx)
+    regions = service.list_regions(cmd.client)
+    cmd.emit(regions, regions_table(regions))

lambda_cloud/cli/commands/ssh_keys.py

@@ -0,0 +1,99 @@
+"""Manage SSH keys."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import typer
+
+from ...api import service
+from ...core.config import write_secret_file
+from ...core.errors import LambdaCloudError
+from ...mngr.models import GeneratedSSHKey
+from ..state import CommandBase
+from ..ui import history
+from ..ui.console import confirm_or_exit, console, success, warn
+from ..ui.tables import ssh_keys_table
+
+app = typer.Typer(no_args_is_help=True, help="Manage SSH keys.")
+
+
+@app.command("list")
+def list_ssh_keys(ctx: typer.Context) -> None:
+    """List your SSH keys."""
+    cmd = CommandBase(ctx)
+    keys = service.list_ssh_keys(cmd.client)
+    cmd.state.history["ssh_key_ids"] = [key.id for key in keys]
+    cmd.emit(keys, ssh_keys_table(keys))
+
+
+@app.command("add")
+def add_ssh_key(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", "-n", help="Name for the key."),
+    public_key: str | None = typer.Option(
+        None, "--public-key", help="Public key material (ssh-ed25519 AAAA…)."
+    ),
+    key_file: Path | None = typer.Option(
+        None,
+        "--file",
+        help="Path to a public key file, e.g. ~/.ssh/id_ed25519.pub.",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+    ),
+    save_to: Path | None = typer.Option(
+        None,
+        "--save-to",
+        help="Write the generated private key to this file (mode 0600).",
+    ),
+) -> None:
+    """Add an SSH key; generates a new key pair when no public key is given.
+
+    When a key pair is generated, the private key is returned once and is
+    NOT stored by Lambda: save it immediately.
+    """
+    cmd = CommandBase(ctx)
+    if public_key and key_file:
+        raise LambdaCloudError("--public-key and --file are mutually exclusive.")
+
+    key_material = public_key or (
+        key_file.read_text(encoding="utf-8").strip() if key_file else None
+    )
+    key = service.add_ssh_key(cmd.client, name, public_key=key_material)
+    history.record_result("ssh_keys.add", {"id": key.id, "name": key.name})
+
+    if isinstance(key, GeneratedSSHKey):
+        if cmd.output.value == "json":
+            cmd.emit(key)
+            return
+        if save_to is not None:
+            write_secret_file(save_to, key.private_key + "\n")
+            os.chmod(save_to, 0o600)
+            success(f"Key pair generated. Private key saved to {save_to} (mode 0600).")
+        else:
+            warn("Lambda does NOT store the private key. Save it now:")
+            console.print(f"\n{key.private_key}\n", style="bold")
+    elif cmd.output.value == "table":
+        success(f"SSH key {key.name!r} added (id: {key.id}).")
+    else:
+        cmd.emit(key)
+
+
+@app.command("delete")
+def delete_ssh_key(
+    ctx: typer.Context,
+    key_id: str = typer.Argument(..., help="ID of the SSH key to delete."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete an SSH key."""
+    cmd = CommandBase(ctx)
+    confirm_or_exit(f"Delete SSH key {key_id}?", yes)
+    service.delete_ssh_key(cmd.client, key_id)
+    if cmd.output.value == "table":
+        success(f"SSH key {key_id} deleted.")
+    else:
+        cmd.emit({"id": key_id})