agentstack-cli 0.6.0rc1__py3-none-manylinux_2_34_aarch64.whl

agentstack_cli/commands/platform/__init__.py

@@ -0,0 +1,198 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import datetime
+import functools
+import importlib.resources
+import os
+import pathlib
+import platform
+import shutil
+import sys
+import textwrap
+import typing
+
+import httpx
+import typer
+from tenacity import AsyncRetrying, retry_if_exception_type, stop_after_delay, wait_fixed
+
+from agentstack_cli.async_typer import AsyncTyper
+from agentstack_cli.commands.platform.base_driver import BaseDriver
+from agentstack_cli.commands.platform.lima_driver import LimaDriver
+from agentstack_cli.commands.platform.wsl_driver import WSLDriver
+from agentstack_cli.configuration import Configuration
+from agentstack_cli.console import console
+from agentstack_cli.utils import verbosity
+
+app = AsyncTyper()
+
+configuration = Configuration()
+
+
+@functools.cache
+def get_driver(vm_name: str = "agentstack") -> BaseDriver:
+    has_lima = (importlib.resources.files("agentstack_cli") / "data" / "limactl").is_file() or shutil.which("limactl")
+    has_vz = os.path.exists("/System/Library/Frameworks/Virtualization.framework")
+    arch = "aarch64" if platform.machine().lower() == "arm64" else platform.machine().lower()
+    has_qemu = bool(shutil.which(f"qemu-system-{arch}"))
+
+    if platform.system() == "Windows" or shutil.which("wsl.exe"):
+        return WSLDriver(vm_name=vm_name)
+    elif has_lima and (has_vz or has_qemu):
+        return LimaDriver(vm_name=vm_name)
+    else:
+        console.error("Could not find a compatible VM runtime.")
+        if platform.system() == "Darwin":
+            console.hint("This version of macOS is unsupported, please update the system.")
+        elif platform.system() == "Linux":
+            if not has_lima:
+                console.hint(
+                    "This Linux distribution is not suppored by Lima VM binary releases (required: glibc>=2.34). Manually install Lima VM >=1.2.1 through either:\n"
+                    + "  - Your distribution's package manager, if available (https://repology.org/project/lima/versions)\n"
+                    + "  - Homebrew, which uses its own separate glibc on Linux (https://brew.sh)\n"
+                    + "  - Building it yourself, and ensuring that limactl is in PATH (https://lima-vm.io/docs/installation/source/)"
+                )
+            if not has_qemu:
+                console.hint(
+                    f"QEMU is needed on Linux, please install it and ensure that qemu-system-{arch} is in PATH. Refer to https://www.qemu.org/download/ for instructions."
+                )
+        sys.exit(1)
+
+
+@app.command("start", help="Start Agent Stack platform. [Local only]")
+async def start(
+    set_values_list: typing.Annotated[
+        list[str], typer.Option("--set", help="Set Helm chart values using <key>=<value> syntax", default_factory=list)
+    ],
+    import_images: typing.Annotated[
+        list[str],
+        typer.Option(
+            "--import", help="Import an image from a local Docker CLI into Agent Stack platform", default_factory=list
+        ),
+    ],
+    pull_on_host: typing.Annotated[
+        bool,
+        typer.Option(
+            "--pull-on-host",
+            help="Pull images on host Docker daemon and import them instead of pulling inside the VM. Acts as a pull cache layer.",
+        ),
+    ] = False,
+    values_file: typing.Annotated[
+        pathlib.Path | None, typer.Option("-f", help="Set Helm chart values using yaml values file")
+    ] = None,
+    vm_name: typing.Annotated[str, typer.Option(hidden=True)] = "agentstack",
+    verbose: typing.Annotated[bool, typer.Option("-v", "--verbose", help="Show verbose output")] = False,
+    skip_pull: typing.Annotated[bool, typer.Option(hidden=True)] = False,
+    skip_restart_deployments: typing.Annotated[bool, typer.Option(hidden=True)] = False,
+    no_wait_for_platform: typing.Annotated[bool, typer.Option(hidden=True)] = False,
+):
+    import agentstack_cli.commands.server
+
+    values_file_path = None
+    if values_file:
+        values_file_path = pathlib.Path(values_file)
+        if not values_file_path.is_file():
+            raise FileNotFoundError(f"Values file {values_file} not found.")
+
+    with verbosity(verbose):
+        driver = get_driver(vm_name=vm_name)
+        await driver.create_vm()
+        await driver.install_tools()
+        await driver.deploy(
+            set_values_list=set_values_list,
+            values_file=values_file_path,
+            import_images=import_images,
+            pull_on_host=pull_on_host,
+            skip_pull=skip_pull,
+            skip_restart_deployments=skip_restart_deployments,
+        )
+
+        if not no_wait_for_platform:
+            with console.status("Waiting for Agent Stack platform to be ready...", spinner="dots"):
+                timeout = datetime.timedelta(minutes=20)
+                async with httpx.AsyncClient() as client:
+                    try:
+                        async for attempt in AsyncRetrying(
+                            stop=stop_after_delay(timeout),
+                            wait=wait_fixed(datetime.timedelta(seconds=1)),
+                            retry=retry_if_exception_type((httpx.HTTPError, ConnectionError)),
+                            reraise=True,
+                        ):
+                            with attempt:
+                                resp = await client.get("http://localhost:8333/healthcheck")
+                                resp.raise_for_status()
+                    except Exception as ex:
+                        raise ConnectionError(
+                            f"Server did not start in {timeout}. Please check your internet connection."
+                        ) from ex
+
+        console.success("Agent Stack platform started successfully!")
+
+        if any("phoenix.enabled=true" in value.lower() for value in set_values_list):
+            console.print(
+                textwrap.dedent("""\
+
+                License Notice:
+                When you enable Phoenix, be aware that Arize Phoenix is licensed under the Elastic License v2 (ELv2),
+                which has specific terms regarding commercial use and distribution. By enabling Phoenix, you acknowledge
+                that you are responsible for ensuring compliance with the ELv2 license terms for your specific use case.
+                Please review the Phoenix license (https://github.com/Arize-ai/phoenix/blob/main/LICENSE) before enabling
+                this feature in production environments.
+                """),
+                style="dim",
+            )
+
+        await agentstack_cli.commands.server.server_login("http://localhost:8333")
+
+
+@app.command("stop", help="Stop Agent Stack platform. [Local only]")
+async def stop(
+    vm_name: typing.Annotated[str, typer.Option(hidden=True)] = "agentstack",
+    verbose: typing.Annotated[bool, typer.Option("-v", "--verbose", help="Show verbose output")] = False,
+):
+    with verbosity(verbose):
+        driver = get_driver(vm_name=vm_name)
+        if not await driver.status():
+            console.info("Agent Stack platform not found. Nothing to stop.")
+            return
+        await driver.stop()
+        console.success("Agent Stack platform stopped successfully.")
+
+
+@app.command("delete", help="Delete Agent Stack platform. [Local only]")
+async def delete(
+    vm_name: typing.Annotated[str, typer.Option(hidden=True)] = "agentstack",
+    verbose: typing.Annotated[bool, typer.Option("-v", "--verbose", help="Show verbose output")] = False,
+):
+    with verbosity(verbose):
+        driver = get_driver(vm_name=vm_name)
+        await driver.delete()
+        console.success("Agent Stack platform deleted successfully.")
+
+
+@app.command("import", help="Import a local docker image into the Agent Stack platform. [Local only]")
+async def import_image_cmd(
+    tag: typing.Annotated[str, typer.Argument(help="Docker image tag to import")],
+    vm_name: typing.Annotated[str, typer.Option(hidden=True)] = "agentstack",
+    verbose: typing.Annotated[bool, typer.Option("-v", "--verbose", help="Show verbose output")] = False,
+):
+    with verbosity(verbose):
+        driver = get_driver(vm_name=vm_name)
+        if (await driver.status()) != "running":
+            console.error("Agent Stack platform is not running.")
+            sys.exit(1)
+        await driver.import_images(tag)
+
+
+@app.command("exec", help="For debugging -- execute a command inside the Agent Stack platform VM. [Local only]")
+async def exec_cmd(
+    command: typing.Annotated[list[str] | None, typer.Argument()] = None,
+    vm_name: typing.Annotated[str, typer.Option(hidden=True)] = "agentstack",
+    verbose: typing.Annotated[bool, typer.Option("-v", "--verbose", help="Show verbose output")] = False,
+):
+    with verbosity(verbose, show_success_status=False):
+        driver = get_driver(vm_name=vm_name)
+        if (await driver.status()) != "running":
+            console.error("Agent Stack platform is not running.")
+            sys.exit(1)
+        await driver.exec(command or ["/bin/bash"])

agentstack_cli/commands/platform/base_driver.py

@@ -0,0 +1,217 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import abc
+import importlib.resources
+import pathlib
+import shlex
+import typing
+from subprocess import CompletedProcess
+from textwrap import dedent
+
+import anyio
+import yaml
+from tenacity import AsyncRetrying, stop_after_attempt
+
+from agentstack_cli.configuration import Configuration
+from agentstack_cli.utils import merge, run_command
+
+
+class BaseDriver(abc.ABC):
+    vm_name: str
+
+    def __init__(self, vm_name: str = "agentstack"):
+        self.vm_name = vm_name
+        self.loaded_images: set[str] = set()
+
+    @abc.abstractmethod
+    async def run_in_vm(
+        self,
+        command: list[str],
+        message: str,
+        env: dict[str, str] | None = None,
+        input: bytes | None = None,
+    ) -> CompletedProcess[bytes]: ...
+
+    @abc.abstractmethod
+    async def status(self) -> typing.Literal["running"] | str | None: ...
+
+    @abc.abstractmethod
+    async def create_vm(self) -> None: ...
+
+    @abc.abstractmethod
+    async def stop(self) -> None: ...
+
+    @abc.abstractmethod
+    async def delete(self) -> None: ...
+
+    @abc.abstractmethod
+    async def import_images(self, *tags: str) -> None: ...
+
+    @abc.abstractmethod
+    async def import_image_to_internal_registry(self, tag: str) -> None: ...
+
+    @abc.abstractmethod
+    async def exec(self, command: list[str]) -> None: ...
+
+    async def install_tools(self) -> None:
+        # Configure k3s registry for local registry access
+        registry_config = dedent(
+            """\
+            mirrors:
+              "agentstack-registry-svc.default:5001":
+                endpoint:
+                  - "http://localhost:30501"
+            configs:
+              "agentstack-registry-svc.default:5001":
+                tls:
+                  insecure_skip_verify: true
+            """
+        )
+
+        await self.run_in_vm(
+            [
+                "sh",
+                "-c",
+                (
+                    f"sudo mkdir -p /etc/rancher/k3s /registry-data && "
+                    f"echo '{registry_config}' | "
+                    "sudo tee /etc/rancher/k3s/registries.yaml > /dev/null"
+                ),
+            ],
+            "Configuring k3s registry",
+        )
+
+        await self.run_in_vm(
+            [
+                "sh",
+                "-c",
+                "which k3s || curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644 --https-listen-port=16443",
+            ],
+            "Installing k3s",
+        )
+        await self.run_in_vm(
+            [
+                "sh",
+                "-c",
+                "which helm || curl -sfL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash",
+            ],
+            "Installing Helm",
+        )
+
+    async def deploy(
+        self,
+        set_values_list: list[str],
+        values_file: pathlib.Path | None = None,
+        import_images: list[str] | None = None,
+        pull_on_host: bool = False,
+        skip_pull: bool = False,
+        skip_restart_deployments: bool = False,
+    ) -> None:
+        _ = await self.run_in_vm(
+            ["sh", "-c", "mkdir -p /tmp/agentstack && cat >/tmp/agentstack/chart.tgz"],
+            "Preparing Helm chart",
+            input=(importlib.resources.files("agentstack_cli") / "data" / "helm-chart.tgz").read_bytes(),
+        )
+        values = {
+            **{svc: {"service": {"type": "LoadBalancer"}} for svc in ["collector", "docling", "ui", "phoenix"]},
+            "service": {"type": "LoadBalancer"},
+            "externalRegistries": {"public_github": str(Configuration().agent_registry)},
+            "encryptionKey": "Ovx8qImylfooq4-HNwOzKKDcXLZCB3c_m0JlB9eJBxc=",
+            "trustProxyHeaders": True,
+            "keycloak": {
+                "uiClientSecret": "agentstack-ui-secret",
+                "serverClientSecret": "agentstack-server-secret",
+                "service": {"type": "LoadBalancer"},
+                "auth": {"adminPassword": "admin"},
+            },
+            "features": {"uiLocalSetup": True},
+            "providerBuilds": {"enabled": True},
+            "localDockerRegistry": {"enabled": True},
+            "auth": {"enabled": False},
+        }
+        if values_file:
+            values = merge(values, yaml.safe_load(values_file.read_text()))
+        await self.run_in_vm(
+            ["sh", "-c", "cat >/tmp/agentstack/values.yaml"],
+            "Preparing Helm values",
+            input=yaml.dump(values).encode("utf-8"),
+        )
+
+        images_str = (
+            await self.run_in_vm(
+                [
+                    "/bin/bash",
+                    "-c",
+                    "helm template agentstack /tmp/agentstack/chart.tgz --values=/tmp/agentstack/values.yaml "
+                    + " ".join(shlex.quote(f"--set={value}") for value in set_values_list)
+                    + " | sed -n '/^\\s*image:/{ /{{/!{ s/.*image:\\s*//p } }'",
+                ],
+                "Listing necessary images",
+            )
+        ).stdout.decode()
+
+        def canonify(tag: str) -> str:
+            return tag if "." in tag.split("/")[0] else f"docker.io/{tag}"
+
+        required_images = {canonify(typing.cast(str, yaml.safe_load(line))) for line in images_str.splitlines()}
+        images_to_import = {canonify(tag) for tag in import_images or []}
+        images_to_pull = required_images - images_to_import
+
+        if not skip_pull:
+            if pull_on_host:
+                for image in images_to_pull:
+                    await run_command(["docker", "pull", image], f"Pulling image {image} on host")
+                images_to_import = required_images
+                images_to_pull = set[str]()
+
+            if images_to_import:
+                await self.import_images(*images_to_import)
+
+            for image in images_to_pull:
+                async for attempt in AsyncRetrying(stop=stop_after_attempt(5)):
+                    with attempt:
+                        attempt_num = attempt.retry_state.attempt_number
+                        await self.run_in_vm(
+                            ["k3s", "ctr", "image", "pull", image],
+                            f"Pulling image {image}" + (f" (attempt {attempt_num})" if attempt_num > 1 else ""),
+                        )
+        elif images_to_import:
+            await self.import_images(*images_to_import)
+
+        self.loaded_images = required_images
+
+        kubeconfig_path = anyio.Path(Configuration().lima_home) / self.vm_name / "copied-from-guest" / "kubeconfig.yaml"
+        await kubeconfig_path.parent.mkdir(parents=True, exist_ok=True)
+        await kubeconfig_path.write_text(
+            (
+                await self.run_in_vm(
+                    ["/bin/cat", "/etc/rancher/k3s/k3s.yaml"],
+                    "Copying kubeconfig from Agent Stack platform",
+                )
+            ).stdout.decode()
+        )
+
+        await self.run_in_vm(
+            [
+                "helm",
+                "upgrade",
+                "--install",
+                "agentstack",
+                "/tmp/agentstack/chart.tgz",
+                "--namespace=default",
+                "--create-namespace",
+                "--values=/tmp/agentstack/values.yaml",
+                "--timeout=20m",
+                "--wait",
+                "--kubeconfig=/etc/rancher/k3s/k3s.yaml",
+                *(f"--set={value}" for value in set_values_list),
+            ],
+            "Deploying Agent Stack platform with Helm",
+        )
+
+        if import_images and not skip_restart_deployments:
+            await self.run_in_vm(
+                ["k3s", "kubectl", "rollout", "restart", "deployment"],
+                "Restarting deployments to load imported images",
+            )