agentstack-cli 0.6.0rc1__py3-none-manylinux_2_34_aarch64.whl

agentstack_cli/commands/self.py

@@ -0,0 +1,213 @@
+# 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.api import fetch_server_version
+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", "--verbose", 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 fetch_server_version()
+        active_server = configuration.auth_manager.active_server
+
+        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(f"          agentstack server: [bold]{active_server if active_server else 'none'}[/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", "--verbose", 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", "--verbose", 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", "--verbose", 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.")

agentstack_cli/commands/server.py

@@ -0,0 +1,315 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+import logging
+import sys
+import typing
+import uuid
+import webbrowser
+from urllib.parse import urlencode
+
+import httpx
+import typer
+import uvicorn
+from authlib.common.security import generate_token
+from authlib.oauth2.rfc7636 import create_s256_code_challenge
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+
+from agentstack_cli.async_typer import AsyncTyper, console
+from agentstack_cli.configuration import Configuration
+
+app = AsyncTyper()
+
+config = Configuration()
+
+REDIRECT_URI = "http://localhost:9001/callback"
+
+
+async def _wait_for_auth_code(port: int = 9001) -> str:
+    code_future: asyncio.Future[str] = asyncio.Future()
+    app = FastAPI()
+
+    @app.get("/callback")
+    async def callback(request: Request):
+        code = request.query_params.get("code")
+        if code and not code_future.done():
+            code_future.set_result(code)
+        return HTMLResponse(
+            content="""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>Login Successful</title>
+                <style>
+                body { font-family: Arial, sans-serif; text-align: center; margin-top: 15%; }
+                h1 { color: #2e7d32; }
+                p { color: #555; }
+                </style>
+            </head>
+            <body>
+                <h1>Login successful!</h1>
+                <p>You can safely close this tab and return to the Agent Stack CLI.</p>
+            </body>
+            </html>
+            """,
+            status_code=200,
+        )
+
+    server = uvicorn.Server(config=uvicorn.Config(app, host="127.0.0.1", port=port, log_level=logging.ERROR))
+
+    async with asyncio.TaskGroup() as tg:
+        tg.create_task(server.serve())
+        code = await code_future
+        server.should_exit = True
+
+    return code
+
+
+def get_unique_app_name() -> str:
+    return f"Agent Stack CLI {uuid.uuid4()}"
+
+
+@app.command("login | change | select | default | switch")
+async def server_login(server: typing.Annotated[str | None, typer.Argument()] = None):
+    """Login to a server or switch between logged in servers."""
+    server = server or (
+        await inquirer.select(  #  type: ignore
+            message="Select a server, or log in to a new one:",
+            choices=[
+                *(
+                    Choice(
+                        name=f"{server} {'(active)' if server == config.auth_manager.active_server else ''}",
+                        value=server,
+                    )
+                    for server in config.auth_manager.servers
+                ),
+                Choice(name="Log in to a new server", value=None),
+            ],
+            default=0,
+        ).execute_async()
+        if config.auth_manager.servers
+        else None
+    )
+    server = server or await inquirer.text(message="Enter server URL:").execute_async()  #  type: ignore
+
+    if not server:
+        raise RuntimeError("No server selected. Action cancelled.")
+
+    if "://" not in server:
+        server = f"https://{server}"
+
+    server = server.rstrip("/")
+
+    if server_data := config.auth_manager.get_server(server):
+        console.info("Switching to an already logged in server.")
+        auth_server = None
+        auth_servers = list(server_data.authorization_servers.keys())
+        if len(auth_servers) == 1:
+            auth_server = auth_servers[0]
+        elif len(auth_servers) > 1:
+            auth_server = await inquirer.select(  #  type: ignore
+                message="Select an authorization server:",
+                choices=[
+                    Choice(
+                        name=f"{auth_server} {'(active)' if auth_server == config.auth_manager.active_auth_server else ''}",
+                        value=auth_server,
+                    )
+                    for auth_server in auth_servers
+                ],
+                default=config.auth_manager.active_auth_server
+                if config.auth_manager.active_auth_server in auth_servers
+                else 0,
+            ).execute_async()
+            if not auth_server:
+                console.info("Action cancelled.")
+                sys.exit(1)
+    else:
+        console.info("No authentication tokens found for this server. Proceeding to log in.")
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(f"{server}/.well-known/oauth-protected-resource/", follow_redirects=True)
+            if resp.is_error:
+                console.error("This server does not appear to run a compatible version of Agent Stack Platform.")
+                sys.exit(1)
+            metadata = resp.json()
+
+        auth_servers = metadata.get("authorization_servers", [])
+        auth_server = None
+        token = None
+
+        client_id = config.client_id
+        client_secret = config.client_secret
+        registration_token = None
+
+        if auth_servers:
+            if len(auth_servers) == 1:
+                auth_server = auth_servers[0]
+            else:
+                auth_server = await inquirer.select(  # type: ignore
+                    message="Select an authorization server:",
+                    choices=auth_servers,
+                ).execute_async()
+
+            if not auth_server:
+                raise RuntimeError("No authorization server selected.")
+
+            async with httpx.AsyncClient() as client:
+                try:
+                    resp = await client.get(f"{auth_server}/.well-known/openid-configuration")
+                    resp.raise_for_status()
+                    oidc = resp.json()
+                except Exception as e:
+                    raise RuntimeError(f"OIDC discovery failed: {e}") from e
+
+            registration_endpoint = oidc["registration_endpoint"]
+            if not client_id and registration_endpoint:
+                async with httpx.AsyncClient() as client:
+                    resp = None
+                    try:
+                        app_name = get_unique_app_name()
+                        resp = await client.post(
+                            registration_endpoint,
+                            json={
+                                "client_name": app_name,
+                                "grant_types": ["authorization_code", "refresh_token"],
+                                "enforce_pkce": True,
+                                "all_users_entitled": True,
+                                "redirect_uris": [REDIRECT_URI],
+                            },
+                        )
+                        resp.raise_for_status()
+                        data = resp.json()
+                        client_id = data["client_id"]
+                        client_secret = data["client_secret"]
+                        registration_token = data["registration_access_token"]
+                    except Exception as e:
+                        if resp:
+                            try:
+                                error_details = resp.json()
+                                console.warning(
+                                    f"error: {error_details['error']} error description: {error_details['error_description']}"
+                                )
+
+                            except Exception:
+                                console.info("no parsable json response.")
+                        console.warning(f" Dynamic client registration failed. Proceed with manual input.  {e!s}")
+
+            if not client_id:
+                client_id = (
+                    await inquirer.text(  #  type: ignore
+                        message="Enter Client ID (default agentstack-cli):",
+                        instruction=f"(Redirect URI: {REDIRECT_URI})",
+                    ).execute_async()
+                    or "agentstack-cli"
+                )
+                if not client_id:
+                    raise RuntimeError("Client ID is mandatory. Action cancelled.")
+                client_secret = (
+                    await inquirer.text(  #  type: ignore
+                        message="Enter Client Secret (optional):"
+                    ).execute_async()
+                    or None
+                )
+
+            code_verifier = generate_token(64)
+
+            auth_url = f"{oidc['authorization_endpoint']}?{
+                urlencode(
+                    {
+                        'client_id': client_id,
+                        'response_type': 'code',
+                        'redirect_uri': REDIRECT_URI,
+                        'scope': ' '.join(metadata.get('scopes_supported', ['openid', 'email', 'profile'])),
+                        'code_challenge': typing.cast(str, create_s256_code_challenge(code_verifier)),
+                        'code_challenge_method': 'S256',
+                    }
+                )
+            }"
+
+            console.info(f"Opening browser for login: [cyan]{auth_url}[/cyan]")
+            if not webbrowser.open(auth_url):
+                console.warning("Could not open browser. Please visit the above URL manually.")
+
+            code = await _wait_for_auth_code()
+            async with httpx.AsyncClient() as client:
+                token_resp = None
+                try:
+                    token_resp = await client.post(
+                        oidc["token_endpoint"],
+                        data={
+                            "grant_type": "authorization_code",
+                            "code": code,
+                            "redirect_uri": REDIRECT_URI,
+                            "client_id": client_id,
+                            "client_secret": client_secret,
+                            "code_verifier": code_verifier,
+                        },
+                    )
+                    token_resp.raise_for_status()
+                    token = token_resp.json()
+                except Exception as e:
+                    if resp:
+                        try:
+                            error_details = resp.json()
+                            console.warning(
+                                f"error: {error_details['error']} error description: {error_details['error_description']}"
+                            )
+                        except Exception:
+                            console.info("no parsable json response.")
+
+                    raise RuntimeError(f"Token request failed: {e}") from e
+
+            if not token:
+                raise RuntimeError("Login timed out or not successful.")
+
+        config.auth_manager.save_auth_token(
+            server=server,
+            auth_server=auth_server,
+            client_id=client_id,
+            client_secret=client_secret,
+            token=token,
+            registration_token=registration_token,
+        )
+
+    config.auth_manager.active_server = server
+    config.auth_manager.active_auth_server = auth_server
+    console.success(f"Logged in to [cyan]{server}[/cyan].")
+
+
+@app.command("logout | remove | rm | delete")
+async def server_logout(
+    all: typing.Annotated[
+        bool,
+        typer.Option(),
+    ] = False,
+):
+    await config.auth_manager.clear_auth_token(all=all)
+    console.success("You have been logged out.")
+
+
+@app.command("show")
+def server_show():
+    if not config.auth_manager.active_server:
+        console.info("No server selected.")
+        console.hint(
+            "Run [green]agentstack server list[/green] to list available servers, and [green]agentstack server login[/green] to select one."
+        )
+        return
+    console.info(f"Active server: [cyan]{config.auth_manager.active_server}[/cyan]")
+
+
+@app.command("list")
+def server_list():
+    if not config.auth_manager.servers:
+        console.info("No servers found.")
+        console.hint(
+            "Run [green]agentstack platform start[/green] to start a local server, or [green]agentstack server login[/green] to connect to a remote one."
+        )
+        return
+    for server in config.auth_manager.servers:
+        console.print(
+            f"[cyan]{server}[/cyan] {'[green](active)[/green]' if server == config.auth_manager.active_server else ''}"
+        )

agentstack_cli/commands/user.py

@@ -0,0 +1,87 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import typing
+from datetime import datetime
+
+import typer
+from agentstack_sdk.platform import User
+from agentstack_sdk.platform.user import UserRole
+from rich.table import Column
+
+from agentstack_cli.async_typer import AsyncTyper, console, create_table
+from agentstack_cli.configuration import Configuration
+from agentstack_cli.utils import announce_server_action, confirm_server_action
+
+app = AsyncTyper()
+configuration = Configuration()
+
+ROLE_DISPLAY = {
+    "admin": "[red]admin[/red]",
+    "developer": "[cyan]developer[/cyan]",
+    "user": "user",
+}
+
+
+@app.command("list", help="List platform users [Admin only]")
+async def list_users(
+    email: typing.Annotated[str | None, typer.Option(help="Filter by email (case-insensitive partial match)")] = None,
+    limit: typing.Annotated[int, typer.Option(help="Results per page (1-100)")] = 40,
+    after: typing.Annotated[str | None, typer.Option(help="Pagination cursor (page_token)")] = None,
+):
+    announce_server_action("Listing users on")
+
+    async with configuration.use_platform_client():
+        result = await User.list(email=email, limit=limit, page_token=after)
+
+        items = result.items
+        has_more = result.has_more
+        next_page_token = result.next_page_token
+
+    with create_table(
+        Column("ID", style="yellow"),
+        Column("Email"),
+        Column("Role"),
+        Column("Created"),
+        no_wrap=True,
+    ) as table:
+        for user in items:
+            role_display = ROLE_DISPLAY.get(user.role, user.role)
+
+            created_at = _format_date(user.created_at)
+
+            table.add_row(
+                user.id,
+                user.email,
+                role_display,
+                created_at,
+            )
+
+    console.print()
+    console.print(table)
+
+    if has_more and next_page_token:
+        console.print(f"\n[dim]Use --after {next_page_token} to see more[/dim]")
+
+
+@app.command("set-role", help="Change user role [Admin only]")
+async def set_role(
+    user_id: typing.Annotated[str, typer.Argument(help="User UUID")],
+    role: typing.Annotated[UserRole, typer.Argument(help="Target role (admin, developer, user)")],
+    yes: typing.Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation prompts.")] = False,
+):
+    url = announce_server_action(f"Changing user {user_id} to role '{role}' on")
+    await confirm_server_action("Proceed with role change on", url=url, yes=yes)
+
+    async with configuration.use_platform_client():
+        result = await User.set_role(user_id, UserRole(role))
+
+        role_display = ROLE_DISPLAY.get(result.new_role, result.new_role)
+
+        console.success(f"User role updated to [cyan]{role_display}[/cyan]")
+
+
+def _format_date(dt: datetime | None) -> str:
+    if not dt:
+        return "-"
+    return dt.strftime("%Y-%m-%d %H:%M")

agentstack_cli/configuration.py

@@ -0,0 +1,79 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import importlib.metadata
+import pathlib
+import re
+import sys
+import typing
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+import pydantic
+import pydantic_settings
+from agentstack_sdk.platform import PlatformClient, use_platform_client
+from pydantic import HttpUrl, SecretStr
+
+from agentstack_cli.auth_manager import AuthManager
+from agentstack_cli.console import console
+
+
+@functools.cache
+def version():
+    # Python strips '-', we need to re-insert it: 1.2.3rc1 -> 1.2.3-rc1
+    return re.sub(r"([0-9])([a-z])", r"\1-\2", importlib.metadata.version("agentstack-cli"))
+
+
+@functools.cache
+class Configuration(pydantic_settings.BaseSettings):
+    model_config = pydantic_settings.SettingsConfigDict(
+        env_file=None, env_prefix="AGENTSTACK__", env_nested_delimiter="__", extra="allow"
+    )
+    debug: bool = False
+    home: pathlib.Path = pydantic.Field(default_factory=lambda: pathlib.Path.home() / ".agentstack")
+    agent_registry: pydantic.AnyUrl = HttpUrl(
+        f"https://github.com/i-am-bee/agentstack@v{version()}#path=agent-registry.yaml"
+    )
+    username: str = "admin"
+    password: SecretStr | None = None
+    server_metadata_ttl: int = 86400
+
+    oidc_enabled: bool = False
+    client_id: str | None = None
+    client_secret: str | None = None
+
+    @property
+    def lima_home(self) -> pathlib.Path:
+        return self.home / "lima"
+
+    @property
+    def auth_file(self) -> pathlib.Path:
+        """Return auth config file path"""
+        return self.home / "auth.json"
+
+    @property
+    def auth_manager(self) -> AuthManager:
+        return AuthManager(self.auth_file)
+
+    @asynccontextmanager
+    async def use_platform_client(self) -> AsyncIterator[PlatformClient]:
+        if self.auth_manager.active_server is None:
+            console.error("No server selected.")
+            console.hint(
+                "Run [green]agentstack platform start[/green] to start a local server, or [green]agentstack server login[/green] to connect to a remote one."
+            )
+            sys.exit(1)
+        async with use_platform_client(
+            auth=(self.username, self.password.get_secret_value()) if self.password else None,
+            auth_token=await self.auth_manager.load_auth_token(),
+            base_url=self.auth_manager.active_server + "/",
+        ) as client:
+            yield client
+
+    @pydantic.model_validator(mode="after")
+    def _check_old_home(self) -> typing.Self:
+        old_home = pathlib.Path.home() / ".beeai"
+        if old_home.exists() and not self.home.exists():
+            old_home.rename(self.home)
+        return self