agentstack-cli 0.4.0__py3-none-macosx_12_0_arm64.whl

agentstack_cli/commands/platform/lima_driver.py

@@ -0,0 +1,210 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import importlib.resources
+import os
+import shutil
+import sys
+import tempfile
+import typing
+import uuid
+from subprocess import CompletedProcess
+
+import anyio
+import psutil
+import pydantic
+import yaml
+
+from agentstack_cli.commands.platform.base_driver import BaseDriver
+from agentstack_cli.configuration import Configuration
+from agentstack_cli.console import console
+from agentstack_cli.utils import run_command
+
+
+class LimaDriver(BaseDriver):
+    limactl_exe: str
+
+    def __init__(self, vm_name: str = "agentstack"):
+        super().__init__(vm_name)
+        bundled_limactl_exe = importlib.resources.files("agentstack_cli") / "data" / "limactl"
+        if bundled_limactl_exe.is_file():
+            self.limactl_exe = str(bundled_limactl_exe)
+        else:
+            self.limactl_exe = str(shutil.which("limactl"))
+            console.warning(f"Using external Lima from {self.limactl_exe}")
+
+    @typing.override
+    async def run_in_vm(
+        self,
+        command: list[str],
+        message: str,
+        env: dict[str, str] | None = None,
+        input: bytes | None = None,
+    ) -> CompletedProcess[bytes]:
+        return await run_command(
+            [self.limactl_exe, "shell", f"--tty={sys.stdin.isatty()}", self.vm_name, "--", "sudo", *command],
+            message,
+            env={"LIMA_HOME": str(Configuration().lima_home)} | (env or {}),
+            cwd="/",
+            input=input,
+        )
+
+    @typing.override
+    async def status(self) -> typing.Literal["running"] | str | None:
+        try:
+            result = await run_command(
+                [self.limactl_exe, "--tty=false", "list", "--format=json"],
+                "Looking for existing Agent Stack platform in Lima",
+                env={"LIMA_HOME": str(Configuration().lima_home)},
+                cwd="/",
+            )
+
+            for line in result.stdout.decode().split("\n"):
+                if not line:
+                    continue
+                status = pydantic.TypeAdapter(typing.TypedDict("Status", {"name": str, "status": str})).validate_json(
+                    line
+                )
+                if status["name"] == self.vm_name:
+                    return status["status"].lower()
+            return None
+        except Exception:
+            return None
+
+    @typing.override
+    async def create_vm(self):
+        Configuration().home.mkdir(exist_ok=True)
+        current_status = await self.status()
+
+        if not current_status:
+            await run_command(
+                [self.limactl_exe, "--tty=false", "delete", "--force", self.vm_name],
+                "Cleaning up remains of previous instance",
+                env={"LIMA_HOME": str(Configuration().lima_home)},
+                check=False,
+                cwd="/",
+            )
+
+            await run_command(
+                [self.limactl_exe, "--tty=false", "delete", "--force", "beeai-platform"],
+                "Cleaning up remains of legacy instance",
+                env={"LIMA_HOME": str(Configuration().lima_home)},
+                check=False,
+                cwd="/",
+            )
+
+            total_memory_gib = typing.cast(int, psutil.virtual_memory().total / (1024**3))
+
+            if total_memory_gib < 4:
+                console.error("Not enough memory. Agent Stack platform requires at least 4 GB of RAM.")
+                sys.exit(1)
+
+            if total_memory_gib < 8:
+                console.warning("Less than 8 GB of RAM detected. Performance may be degraded.")
+
+            vm_memory_gib = round(min(8, max(3, total_memory_gib / 2)))
+
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete_on_close=False) as template_file:
+                template_file.write(
+                    yaml.dump(
+                        {
+                            "images": [
+                                {
+                                    "location": "https://cloud-images.ubuntu.com/releases/noble/release/ubuntu-24.04-server-cloudimg-amd64.img",
+                                    "arch": "x86_64",
+                                },
+                                {
+                                    "location": "https://cloud-images.ubuntu.com/releases/noble/release/ubuntu-24.04-server-cloudimg-arm64.img",
+                                    "arch": "aarch64",
+                                },
+                            ],
+                            "portForwards": [
+                                {
+                                    "guestIP": "127.0.0.1",
+                                    "guestPortRange": [1024, 65535],
+                                    "hostPortRange": [1024, 65535],
+                                    "hostIP": "127.0.0.1",
+                                },
+                                {"guestIP": "0.0.0.0", "proto": "any", "ignore": True},
+                            ],
+                            "mounts": [
+                                {"location": "/tmp/agentstack", "mountPoint": "/tmp/agentstack", "writable": True}
+                            ],
+                            "containerd": {"system": False, "user": False},
+                            "hostResolver": {"hosts": {"host.docker.internal": "host.lima.internal"}},
+                            "memory": f"{vm_memory_gib}GiB",
+                        }
+                    )
+                )
+                template_file.flush()
+                template_file.close()
+                await run_command(
+                    [
+                        self.limactl_exe,
+                        "--tty=false",
+                        "start",
+                        str(template_file.name),
+                        f"--name={self.vm_name}",
+                    ],
+                    "Creating a Lima VM",
+                    env={"LIMA_HOME": str(Configuration().lima_home)},
+                    cwd="/",
+                )
+        elif current_status != "running":
+            await run_command(
+                [self.limactl_exe, "--tty=false", "start", self.vm_name],
+                "Starting up",
+                env={"LIMA_HOME": str(Configuration().lima_home)},
+                cwd="/",
+            )
+        else:
+            console.info("Updating an existing instance.")
+
+    @typing.override
+    async def stop(self):
+        await run_command(
+            [self.limactl_exe, "--tty=false", "stop", "--force", self.vm_name],
+            "Stopping Agent Stack VM",
+            env={"LIMA_HOME": str(Configuration().lima_home)},
+            cwd="/",
+        )
+
+    @typing.override
+    async def delete(self):
+        await run_command(
+            [self.limactl_exe, "--tty=false", "delete", "--force", self.vm_name],
+            "Deleting Agent Stack platform",
+            env={"LIMA_HOME": str(Configuration().lima_home)},
+            check=False,
+            cwd="/",
+        )
+
+    @typing.override
+    async def import_image(self, tag: str):
+        image_dir = anyio.Path("/tmp/agentstack")
+        await image_dir.mkdir(exist_ok=True, parents=True)
+        image_file = str(uuid.uuid4())
+        image_path = image_dir / image_file
+
+        try:
+            await run_command(
+                ["docker", "image", "save", "-o", str(image_path), tag], f"Exporting image {tag} from Docker"
+            )
+            await self.run_in_vm(
+                ["/bin/sh", "-c", f"k3s ctr images import /tmp/agentstack/{image_file}"],
+                f"Importing image {tag} into Agent Stack platform",
+            )
+        finally:
+            await image_path.unlink(missing_ok=True)
+
+    @typing.override
+    async def exec(self, command: list[str]):
+        await anyio.run_process(
+            [self.limactl_exe, "shell", f"--tty={sys.stdin.isatty()}", self.vm_name, "--", *command],
+            input=None if sys.stdin.isatty() else sys.stdin.read().encode(),
+            check=False,
+            stdout=None,
+            stderr=None,
+            env={**os.environ, "LIMA_HOME": str(Configuration().lima_home)},
+            cwd="/",
+        )

agentstack_cli/commands/platform/wsl_driver.py

@@ -0,0 +1,226 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import configparser
+import os
+import pathlib
+import platform
+import sys
+import textwrap
+import typing
+
+import anyio
+import pydantic
+import yaml
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+
+from agentstack_cli.commands.platform.base_driver import BaseDriver
+from agentstack_cli.configuration import Configuration
+from agentstack_cli.console import console
+from agentstack_cli.utils import run_command
+
+
+class WSLDriver(BaseDriver):
+    @typing.override
+    async def run_in_vm(
+        self,
+        command: list[str],
+        message: str,
+        env: dict[str, str] | None = None,
+        input: bytes | None = None,
+        check: bool = True,
+    ):
+        return await run_command(
+            ["wsl.exe", "--user", "root", "--distribution", self.vm_name, "--", *command],
+            message,
+            env={**(env or {}), "WSL_UTF8": "1", "WSLENV": os.getenv("WSLENV", "") + ":WSL_UTF8"},
+            input=input,
+            check=check,
+        )
+
+    @typing.override
+    async def status(self) -> typing.Literal["running"] | str | None:
+        try:
+            for status, cmd in [("running", ["--running"]), ("stopped", [])]:
+                result = await run_command(
+                    ["wsl.exe", "--list", "--quiet", *cmd],
+                    f"Looking for {status} Agent Stack platform in WSL",
+                    env={"WSL_UTF8": "1", "WSLENV": os.getenv("WSLENV", "") + ":WSL_UTF8"},
+                )
+                if self.vm_name in result.stdout.decode().splitlines():
+                    return status
+            return None
+        except Exception:
+            return None
+
+    @typing.override
+    async def create_vm(self):
+        if (await run_command(["wsl.exe", "--status"], "Checking for WSL2", check=False)).returncode != 0:
+            await run_command(["wsl.exe", "--install", "--no-launch", "--web-download"], "Installing WSL2")
+        await run_command(["wsl.exe", "--upgrade"], "Upgrading WSL2", check=False)
+
+        config_file = (
+            pathlib.Path.home()
+            if platform.system() == "Windows"
+            else pathlib.Path(
+                (
+                    await run_command(
+                        ["/bin/sh", "-c", '''wslpath "$(cmd.exe /c 'echo %USERPROFILE%')"'''], "Detecting home path"
+                    )
+                )
+                .stdout.decode()
+                .strip()
+            )
+        ) / ".wslconfig"
+        config_file.touch()
+        with config_file.open("r+") as f:
+            config = configparser.ConfigParser()
+            f.seek(0)
+            config.read_file(f)
+
+            if not config.has_section("wsl2"):
+                config.add_section("wsl2")
+
+            if (
+                config.get("wsl2", "networkingMode", fallback=None) != "mirrored"
+                and await inquirer.select(  # type: ignore
+                    textwrap.dedent("""\
+                    The Agent Stack platform needs to switch WSL to `mirrored` networking mode in order to support connecting to Windows applications -- like Ollama or self-registered agents. If you skip this step, these features won't be available.
+
+                    However, the default `nat` mode is required by some software, like Docker Desktop or Rancher Desktop, to function properly. If you use such software, you may want to keep the default `nat` mode.
+
+                    (It can be changed anytime later in C:/Users/<your name>/.wslconfig, followed by `wsl --shutdown` and `agentstack platform start` to apply changes.)
+                    """),
+                    choices=[
+                        Choice(
+                            value=True,
+                            name="Change WSL2 networking mode to `mirrored`",
+                        ),
+                        Choice(
+                            value=False,
+                            name="Leave WSL2 networking mode as `nat`",
+                        ),
+                    ],
+                ).execute_async()
+            ):
+                config.set("wsl2", "networkingMode", "mirrored")
+                f.seek(0)
+                f.truncate(0)
+                config.write(f)
+
+                if platform.system() == "Linux":
+                    console.warning(
+                        "WSL networking mode updated. Please close WSL, run [green]wsl --shutdown[/green] from PowerShell, re-open WSL and run [green]agentstack platform start[/green] again."
+                    )
+                    sys.exit(1)
+                await run_command(["wsl.exe", "--shutdown"], "Updating WSL2 networking")
+
+        Configuration().home.mkdir(exist_ok=True)
+        if not await self.status():
+            await run_command(
+                ["wsl.exe", "--unregister", self.vm_name], "Cleaning up remains of previous instance", check=False
+            )
+            await run_command(
+                ["wsl.exe", "--unregister", "beeai-platform"], "Cleaning up remains of legacy instance", check=False
+            )
+            await run_command(
+                ["wsl.exe", "--install", "--name", self.vm_name, "--no-launch", "--web-download"],
+                "Creating a WSL distribution",
+            )
+
+        await self.run_in_vm(
+            [
+                "sh",
+                "-c",
+                "echo '[network]\ngenerateResolvConf = false\n[boot]\nsystemd=true\n' >/etc/wsl.conf && rm /etc/resolv.conf && echo 'nameserver 1.1.1.1\n' >/etc/resolv.conf && chattr +i /etc/resolv.conf",
+            ],
+            "Setting up DNS configuration",
+            check=False,
+        )
+
+        await run_command(["wsl.exe", "--terminate", self.vm_name], "Restarting Agent Stack VM")
+        await self.run_in_vm(["dbus-launch", "true"], "Ensuring persistence of Agent Stack VM")
+
+    @typing.override
+    async def deploy(
+        self,
+        set_values_list: list[str],
+        values_file: pathlib.Path | None = None,
+        import_images: list[str] | None = None,
+    ) -> None:
+        await self.run_in_vm(
+            ["k3s", "kubectl", "apply", "-f", "-"],
+            "Setting up internal networking",
+            input=yaml.dump(
+                {
+                    "apiVersion": "v1",
+                    "kind": "ConfigMap",
+                    "metadata": {"name": "coredns-custom", "namespace": "kube-system"},
+                    "data": {
+                        "default.server": "host.docker.internal {\n    hosts {\n        127.0.0.1 host.docker.internal\n        fallthrough\n    }\n}"
+                    },
+                }
+            ).encode(),
+        )
+        await super().deploy(set_values_list=set_values_list, values_file=values_file, import_images=import_images)
+        await self.run_in_vm(
+            ["sh", "-c", "cat >/etc/systemd/system/kubectl-port-forward@.service"],
+            "Installing systemd unit for port-forwarding",
+            input=textwrap.dedent("""\
+            [Unit]
+            Description=Kubectl Port Forward for service %%i
+            After=network.target
+
+            [Service]
+            Type=simple
+            ExecStart=/bin/bash -c 'IFS=":" read svc port <<< "%i"; exec /usr/local/bin/kubectl port-forward --address=127.0.0.1 svc/$svc $port:$port'
+            Restart=on-failure
+            User=root
+
+            [Install]
+            WantedBy=multi-user.target
+            """).encode(),
+        )
+        await self.run_in_vm(["systemctl", "daemon-reexec"], "Reloading systemd")
+        services_json = (
+            await self.run_in_vm(
+                ["k3s", "kubectl", "get", "svc", "--field-selector=spec.type=LoadBalancer", "--output=json"],
+                "Detecting ports to forward",
+            )
+        ).stdout
+        ServicePort = typing.TypedDict("ServicePort", {"port": int, "name": str})
+        ServiceSpec = typing.TypedDict("ServiceSpec", {"ports": list[ServicePort]})
+        ServiceMetadata = typing.TypedDict("ServiceMetadata", {"name": str, "namespace": str})
+        Service = typing.TypedDict("Service", {"metadata": ServiceMetadata, "spec": ServiceSpec})
+        Services = typing.TypedDict("Services", {"items": list[Service]})
+        for service in pydantic.TypeAdapter(Services).validate_json(services_json)["items"]:
+            name = service["metadata"]["name"]
+            for port_item in service["spec"]["ports"]:
+                port = port_item["port"]
+                await self.run_in_vm(
+                    ["systemctl", "enable", "--now", f"kubectl-port-forward@{name}:{port}.service"],
+                    f"Starting port-forward for {name}:{port}",
+                )
+
+    @typing.override
+    async def stop(self):
+        await run_command(["wsl.exe", "--terminate", self.vm_name], "Stopping Agent Stack VM")
+
+    @typing.override
+    async def delete(self):
+        await run_command(["wsl.exe", "--unregister", self.vm_name], "Deleting Agent Stack platform", check=False)
+
+    @typing.override
+    async def import_image(self, tag: str) -> None:
+        raise NotImplementedError("Importing images is not supported on this platform.")
+
+    @typing.override
+    async def exec(self, command: list[str]):
+        await anyio.run_process(
+            ["wsl.exe", "--user", "root", "--distribution", self.vm_name, "--", *command],
+            input=None if sys.stdin.isatty() else sys.stdin.read().encode(),
+            check=False,
+            stdout=None,
+            stderr=None,
+        )

agentstack_cli/commands/self.py

@@ -0,0 +1,206 @@
+# SPDX-License-Identifier: Apache-2.0
+import functools
+import importlib.metadata
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import typing
+
+import httpx
+import packaging.version
+import pydantic
+import typer
+from InquirerPy import inquirer
+
+import agentstack_cli.commands.platform
+from agentstack_cli.async_typer import AsyncTyper
+from agentstack_cli.commands.model import setup as model_setup
+from agentstack_cli.configuration import Configuration
+from agentstack_cli.console import console
+from agentstack_cli.utils import run_command, verbosity
+
+app = AsyncTyper()
+configuration = Configuration()
+
+
+@functools.cache
+def _path() -> str:
+    # These are PATHs where `uv` installs itself when installed through own install script
+    # Package managers may install elsewhere, but that location should already be in PATH
+    return os.pathsep.join(
+        [
+            *([xdg_bin_home] if (xdg_bin_home := os.getenv("XDG_BIN_HOME")) else []),
+            *([os.path.realpath(f"{xdg_data_home}/../bin")] if (xdg_data_home := os.getenv("XDG_DATA_HOME")) else []),
+            os.path.expanduser("~/.local/bin"),
+            os.getenv("PATH", ""),
+        ]
+    )
+
+
+@app.command("version")
+async def version(verbose: typing.Annotated[bool, typer.Option("-v", help="Show verbose output")] = False):
+    """Print version of the Agent Stack CLI."""
+    with verbosity(verbose=verbose):
+        cli_version = importlib.metadata.version("agentstack-cli")
+        platform_version = await agentstack_cli.commands.platform.get_driver().version()
+
+        latest_cli_version: str | None = None
+        with console.status("Checking for newer version...", spinner="dots"):
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get("https://pypi.org/pypi/agentstack-cli/json")
+                PyPIPackageInfo = typing.TypedDict("PyPIPackageInfo", {"version": str})
+                PyPIPackage = typing.TypedDict("PyPIPackage", {"info": PyPIPackageInfo})
+                if response.status_code == 200:
+                    latest_cli_version = pydantic.TypeAdapter(PyPIPackage).validate_json(response.text)["info"][
+                        "version"
+                    ]
+
+        console.print()
+        console.print(f"     agentstack-cli version: [bold]{cli_version}[/bold]")
+        console.print(
+            f"agentstack-platform version: [bold]{platform_version.replace('-', '') if platform_version is not None else 'not running'}[/bold]"
+        )
+        console.print()
+
+        if latest_cli_version and packaging.version.parse(latest_cli_version) > packaging.version.parse(cli_version):
+            console.hint(
+                f"A newer version ([bold]{latest_cli_version}[/bold]) is available. Update using: [green]agentstack self upgrade[/green]."
+            )
+        elif platform_version is None:
+            console.hint("Start the Agent Stack platform using: [green]agentstack platform start[/green]")
+        elif platform_version.replace("-", "") != cli_version:
+            console.hint("Update the Agent Stack platform using: [green]agentstack platform start[/green]")
+        else:
+            console.success("Everything is up to date!")
+
+
+@app.command("install")
+async def install(
+    verbose: typing.Annotated[bool, typer.Option("-v", help="Show verbose output")] = False,
+):
+    """Install Agent Stack platform pre-requisites."""
+    with verbosity(verbose=verbose):
+        ready_to_start = False
+        if platform.system() == "Linux":
+            if shutil.which(
+                f"qemu-system-{'aarch64' if platform.machine().lower() == 'arm64' else platform.machine().lower()}"
+            ):
+                ready_to_start = True
+            else:
+                if os.geteuid() != 0:
+                    console.hint(
+                        "You may be prompted for your password to install QEMU, as this needs root privileges."
+                    )
+                    os.execlp("sudo", sys.executable, *sys.argv)
+                for cmd in [
+                    ["apt", "install", "-y", "-qq", "qemu-system"],
+                    ["dnf", "install", "-y", "-q", "@virtualization"],
+                    ["pacman", "-S", "--noconfirm", "--noprogressbar", "qemu"],
+                    ["zypper", "install", "-y", "-qq", "qemu"],
+                    ["yum", "install", "-y", "-q", "qemu-kvm"],
+                    ["emerge", "--quiet", "app-emulation/qemu"],
+                ]:
+                    if shutil.which(cmd[0]):
+                        try:
+                            await run_command(cmd, f"Installing QEMU with {cmd[0]}")
+                            ready_to_start = True
+                            break
+                        except (subprocess.CalledProcessError, FileNotFoundError):
+                            console.warning(
+                                "Failed to install QEMU automatically. Please install QEMU manually before using Agent Stack. Refer to https://www.qemu.org/download/ for instructions."
+                            )
+                            break
+        elif platform.system() == "Darwin":
+            ready_to_start = True
+
+        already_started = False
+        console.print()
+        if (
+            ready_to_start
+            and await inquirer.confirm(  # pyright: ignore[reportPrivateImportUsage]
+                message="Do you want to start the Agent Stack platform now? Will run: agentstack platform start",
+                default=True,
+            ).execute_async()
+        ):
+            try:
+                await agentstack_cli.commands.platform.start(set_values_list=[], import_images=[], verbose=verbose)
+                already_started = True
+                console.print()
+            except Exception:
+                console.warning("Platform start failed. You can retry with [green]agentstack platform start[/green].")
+
+        already_configured = False
+        if (
+            already_started
+            and await inquirer.confirm(  # pyright: ignore[reportPrivateImportUsage]
+                message="Do you want to configure your LLM provider now? Will run: agentstack model setup", default=True
+            ).execute_async()
+        ):
+            try:
+                await model_setup(verbose=verbose)
+                already_configured = True
+            except Exception:
+                console.warning("Model setup failed. You can retry with [green]agentstack model setup[/green].")
+
+        if (
+            already_configured
+            and await inquirer.confirm(  # pyright: ignore[reportPrivateImportUsage]
+                message="Do you want to open the web UI now? Will run: agentstack ui", default=True
+            ).execute_async()
+        ):
+            import webbrowser
+
+            webbrowser.open("http://localhost:8334")
+
+        console.print()
+        console.success("Installation complete!")
+        if not shutil.which("agentstack", path=_path()):
+            console.hint("Open a new terminal window to use the [green]agentstack[/green] command.")
+        if not already_started:
+            console.hint("Start the Agent Stack platform using: [green]agentstack platform start[/green]")
+        if not already_configured:
+            console.hint("Configure your LLM provider using: [green]agentstack model setup[/green]")
+        console.hint(
+            "Use [green]agentstack ui[/green] to open the web GUI, or [green]agentstack run chat[/green] to talk to an agent on the command line."
+        )
+        console.hint(
+            "Run [green]agentstack --help[/green] to learn about available commands, or check the documentation at https://agentstack.beeai.dev/"
+        )
+
+
+@app.command("upgrade")
+async def upgrade(verbose: typing.Annotated[bool, typer.Option("-v", help="Show verbose output")] = False):
+    """Upgrade Agent Stack CLI and Platform to the latest version."""
+    if not shutil.which("uv", path=_path()):
+        console.error("Can't self-upgrade because 'uv' was not found.")
+        raise typer.Exit(1)
+
+    with verbosity(verbose=verbose):
+        await run_command(
+            ["uv", "tool", "install", "--force", "agentstack-cli"],
+            "Upgrading agentstack-cli",
+            env={"PATH": _path()},
+        )
+        await agentstack_cli.commands.platform.start(set_values_list=[], import_images=[], verbose=verbose)
+        await version(verbose=verbose)
+
+
+@app.command("uninstall")
+async def uninstall(
+    verbose: typing.Annotated[bool, typer.Option("-v", help="Show verbose output")] = False,
+):
+    """Uninstall Agent Stack CLI and Platform."""
+    if not shutil.which("uv", path=_path()):
+        console.error("Can't self-uninstall because 'uv' was not found.")
+        raise typer.Exit(1)
+
+    with verbosity(verbose=verbose):
+        await agentstack_cli.commands.platform.delete(verbose=verbose)
+        await run_command(
+            ["uv", "tool", "uninstall", "agentstack-cli"],
+            "Uninstalling agentstack-cli",
+            env={"PATH": _path()},
+        )
+        console.success("Agent Stack uninstalled successfully.")