pipecatcloud 0.0.6__py3-none-any.whl

pipecatcloud/cli/auth.py

@@ -0,0 +1,274 @@
+import asyncio
+import itertools
+import webbrowser
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, Optional, Tuple
+
+import aiohttp
+import typer
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+
+from pipecatcloud._utils.async_utils import synchronize_api, synchronizer
+from pipecatcloud._utils.auth_utils import requires_login
+from pipecatcloud._utils.http_utils import construct_api_url
+from pipecatcloud.cli import PANEL_TITLE_ERROR, PANEL_TITLE_SUCCESS
+from pipecatcloud.config import _remove_user_config, _store_user_config, config, user_config_path
+
+auth_cli = typer.Typer(name="auth", help="Manage Pipecat Cloud credentials.", no_args_is_help=True)
+
+
+class _AuthFlow:
+    def __init__(self):
+        pass
+
+    @asynccontextmanager
+    async def start(self) -> AsyncGenerator[Tuple[Optional[str], Optional[str]], None]:
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(f"{construct_api_url('login_path')}") as resp:
+                    if resp.status != 200:
+                        raise Exception(f"Failed to start auth flow: {resp.status}")
+                    data = await resp.json()
+                    self.token_flow_id = data["token_flow_id"]
+                    self.wait_secret = data["wait_secret"]
+                    web_url = data["web_url"]
+
+                    yield (self.token_flow_id, web_url)
+            except Exception:
+                pass
+            yield (None, None)
+
+    async def finish(self, timeout: float = 40.0, network_timeout: float = 5.0) -> Optional[str]:
+        start_time = asyncio.get_event_loop().time()
+        async with aiohttp.ClientSession() as session:
+            while (asyncio.get_event_loop().time() - start_time) < timeout:
+                try:
+                    async with session.get(
+                        f"{config.get('server_url')}{config.get('login_status_path')}",
+                        params={
+                            "token_flow_id": self.token_flow_id,
+                            "wait_secret": self.wait_secret
+                        },
+                        timeout=aiohttp.ClientTimeout(total=timeout + network_timeout),
+                    ) as resp:
+                        if resp.status == 200:
+                            data = await resp.json()
+                            if data["status"] == "complete":
+                                return data["token"]
+                            if data["status"] == "failure":
+                                return "failure"
+                        await asyncio.sleep(2)
+                        continue
+                except (asyncio.TimeoutError, aiohttp.ClientError):
+                    continue
+            return None
+
+
+AuthFlow = synchronize_api(_AuthFlow)
+
+
+def _open_url(url: str) -> bool:
+    try:
+        browser = webbrowser.get()
+        if isinstance(browser, webbrowser.GenericBrowser) and browser.name != "open":
+            return False
+        else:
+            return browser.open_new_tab(url)
+    except webbrowser.Error:
+        return False
+
+
+async def _set_credentials(
+    token: str,
+    account_org: str,
+):
+    console = Console()
+    with console.status("Storing user credentials", spinner="dots"):
+        _store_user_config(token, account_org)
+
+
+async def _get_account_org(
+        token: str, active_org: Optional[str] = None) -> Optional[Tuple[str, str]]:
+    console = Console()
+    # Retrieve account organization
+    with console.status("[dim]Obtaining account organization data[/dim]", spinner="dots"):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{construct_api_url('organization_path')}",
+                headers={"Authorization": f"Bearer {token}"},
+            ) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    organizations = data["organizations"]
+
+                    # If active_org is specified, try to find it in the list
+                    if active_org:
+                        for org in organizations:
+                            if org["name"] == active_org:
+                                return org["name"], org["verboseName"]
+
+                    # Default to first organization if active_org not found or not specified
+                    if organizations:
+                        return organizations[0]["name"], organizations[0]["verboseName"]
+
+                    return None
+                else:
+                    raise Exception(f"Failed to retrieve account organization: {resp.status}")
+
+
+# ----- Login
+
+async def _login(active_org: Optional[str] = None):
+    console = Console()
+    auth_flow = _AuthFlow()
+
+    try:
+        async with auth_flow.start() as (token_flow_id, web_url):
+            if web_url is None:
+                console.print(
+                    Panel(
+                        "Unable to connect to Pipecat Cloud API. Please check your network connection and try again.",
+                        title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+                        title_align="left",
+                        border_style="red",
+                    ))
+                return
+
+            with console.status("Waiting for authentication in the web browser", spinner="dots"):
+                # Open the web url in the browser
+                if _open_url(web_url):
+                    console.print(
+                        Panel(
+                            "The web browser should have opened for you to authenticate with Pipecat Cloud.\n"
+                            "If it didn't, please copy this URL into your web browser manually:\n\n"
+                            f"[blue][link={web_url}]{web_url}[/link][/blue]\n", ))
+                else:
+                    console.print(Panel(
+                        "[red]Was not able to launch web browser[/red]",
+                        title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+                        title_align="left",
+                        border_style="red",
+                    ))
+
+            with console.status("Waiting for token flow to complete...", spinner="dots") as status:
+                for attempt in itertools.count():
+                    result = await auth_flow.finish()
+                    if result is not None:
+                        break
+                    status.update(f"Waiting for token flow to complete... (attempt {attempt + 1})")
+                if result is None:
+                    console.print(Panel(
+                        "[red]Authentication failed[/red]",
+                        title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+                        title_align="left",
+                        border_style="red",
+                    ))
+                    return
+
+            # Retrieve user namespace
+            if not active_org:
+                try:
+                    account_name, account_name_verbose = await _get_account_org(result)
+                    logger.debug(f"Setting namespace to {account_name_verbose}")
+                    if account_name is None:
+                        raise
+                except Exception:
+                    console.print(
+                        Panel(
+                            "[red]Account has no associated namespace. Have you completed the onboarding process? Please first sign in via the web dashboard (https://dashboard.pipecat.cloud).[/red]",
+                            title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+                            title_align="left",
+                            border_style="red",
+                        ))
+                    return
+            else:
+                account_name = active_org
+
+            console.print(Panel(
+                "[green]Web authentication finished successfully![/green]\n"
+                f"Account details stored to [magenta]{user_config_path}[/magenta]",
+                title=f"[green]{PANEL_TITLE_SUCCESS}[/green]",
+                title_align="left",
+                border_style="green",
+            ))
+            await _set_credentials(result, account_name)
+    except Exception:
+        pass
+
+
+@auth_cli.command(name="login", help="Login to Pipecat Cloud and get a new token")
+@synchronizer.create_blocking
+async def login(ctx: typer.Context):
+    active_org = ctx.obj["org"]
+    await _login(active_org)
+
+
+# ----- Logut
+
+@auth_cli.command(name="logout", help="Logout from Pipecat Cloud")
+@synchronizer.create_blocking
+@requires_login
+async def logout():
+    """
+    # This command should delete the session token
+    # due to networkless token verification, the token will not be invalidated
+    # it will just be removed from the local config file
+    # if we want token invalidation, we'll need to either use sign-in tokens with clerk
+    # or use a networked token verification system of our own design
+    """
+    console = Console()
+
+    with console.status("Removing user ID", spinner="dots"):
+        _remove_user_config()
+
+    console.print(Panel(
+        "You are now logged out of Pipecat Cloud.",
+        title=f"[yellow]{PANEL_TITLE_SUCCESS}[/yellow]",
+        title_align="left",
+        border_style="yellow",
+    ))
+
+
+@auth_cli.command(name="whoami", help="Display data about the current user.")
+@synchronizer.create_blocking
+@requires_login
+async def whomai():
+    console = Console()
+    token = config.get("token")
+    active_org = config.get("org")
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            # Retrieve user data from whoami endpoint
+            with console.status("[dim]Obtaining user data[/dim]", spinner="dots"):
+                async with session.get(
+                    f"{construct_api_url('whoami_path')}",
+                    headers={"Authorization": f"Bearer {token}"},
+                ) as resp:
+                    if resp.status == 200:
+                        data = await resp.json()
+                    else:
+                        raise
+
+            # Retrieve default user organization
+            account_name, account_name_verbose = await _get_account_org(token, active_org)
+            if account_name is None:
+                raise
+
+            console.print(Panel(
+                f"[bold]User ID:[/bold] {data['user']['userId']}\n"
+                f"[bold]Active Organization:[/bold] {account_name_verbose} [dim]({account_name})[/dim]",
+                title="whoami",
+                title_align="left",
+                border_style="dim",
+            ))
+        except Exception:
+            console.print(Panel(
+                "[red]Failed to get user data. Please contact support.[/red]",
+                title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+                title_align="left",
+                border_style="red",
+            ))
+            return

pipecatcloud/cli/deploy.py

@@ -0,0 +1,230 @@
+import asyncio
+from typing import Optional
+
+import aiohttp
+import typer
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+
+from pipecatcloud._utils.async_utils import synchronizer
+from pipecatcloud._utils.auth_utils import requires_login
+from pipecatcloud._utils.deploy_utils import load_deploy_config_file
+from pipecatcloud._utils.http_utils import construct_api_url
+from pipecatcloud.cli import PANEL_TITLE_ERROR, PANEL_TITLE_SUCCESS
+
+console = Console()
+
+TEST_CONFIG_FILE = {}
+
+
+async def _poll_deployment_status(
+        token: str,
+        organization: str,
+        agent_id: str,
+        max_attempts: int = 10):
+
+    attempts = 0
+    while attempts < max_attempts:
+        with console.status(f"Monitoring status for deployment id: [bold]'{agent_id}'[/bold] (attempt {attempts + 1} of {max_attempts})", spinner="dots"):
+            async with aiohttp.ClientSession() as session:
+                response = await session.get(
+                    f"{construct_api_url('services_path').format(org=organization)}/{agent_id}",
+                    headers={"Authorization": f"Bearer {token}"},
+                )
+                data = await response.json()
+                if data["body"]["ready"]:
+                    console.print(Panel(
+                        f"[green]Agent '{agent_id}' is ready[/green]",
+                        title=f"[green]{PANEL_TITLE_SUCCESS}[/green]",
+                        title_align="left",
+                        border_style="green",
+                    ))
+                    break
+                """
+                if not data["body"]["ready"]:
+                    console.print(Panel(
+                        f"[red]Unable to deploy '{agent_id}'[/red]\n\n"
+                        f"[dim]Message from API:[/dim]\n{data['body']['conditions'][-1]['message']}",
+                        title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+                        title_align="left",
+                        border_style="red",
+                    ))
+                    break
+                """
+                await asyncio.sleep(2)
+                attempts += 1
+
+
+async def _deploy(
+        token: str,
+        agent_name: str,
+        image: str,
+        deployment_config: dict,
+        credentials: Optional[str]):
+    organization = deployment_config.get("organization")
+    if not organization or not token:
+        console.print("[red]Not logged in[/red]")
+        return
+
+    try:
+        with console.status(f"Deploying [bold]'{agent_name}'[/bold]", spinner="dots"):
+            async with aiohttp.ClientSession() as session:
+                request_url = f"{construct_api_url('services_path').format(org=organization)}"
+                # Build request payload
+                payload = {
+                    "serviceName": agent_name,
+                    "image": image,
+                }
+                if deployment_config.get("secrets"):
+                    payload["secretSet"] = deployment_config["secrets"]
+
+                if credentials:
+                    payload["imagePullSecretSet"] = credentials
+
+                async with session.put(
+                    request_url,
+                    headers={"Authorization": f"Bearer {token}"},
+                    json=payload,
+                ) as resp:
+                    resp.raise_for_status()
+    except Exception as e:
+        console.print(Panel(
+            f"[red]Unable to deploy '{agent_name}'. {e}[/red]",
+            title=f"[red]{PANEL_TITLE_ERROR}[/red]",
+            title_align="left",
+            border_style="red",
+        ))
+        return typer.Exit(1)
+
+    # Poll the deployment status until it's ready
+    await _poll_deployment_status(token, organization, agent_name)
+
+# ----- Deploy
+
+
+def create_deploy_command(app: typer.Typer):
+    # Note we wrap the deploy command to avoid circular imports
+    @app.command(name="deploy", help="Deploy to Pipecat Cloud")
+    @synchronizer.create_blocking
+    @requires_login
+    async def deploy(
+        ctx: typer.Context,
+        agent_name: str = typer.Argument(
+            None,
+            help="Name of the agent to deploy e.g. 'my-agent'",
+            show_default=False),
+        image: str = typer.Argument(
+            None,
+            help="Docker image location e.g. 'my-image:latest'",
+            show_default=False),
+        min_instances: int = typer.Option(
+            1,
+            "--min-instances",
+            help="Minimum number of instances to keep warm",
+            rich_help_panel="Deployment Configuration",
+            min=1),
+        max_instances: int = typer.Option(
+            20,
+            "--max-instances",
+            help="Maximum number of allowed instances",
+            rich_help_panel="Deployment Configuration",
+            min=0,
+            max=50),
+        secrets: str = typer.Option(
+            None,
+            "--secrets",
+            "--s",
+            help="Secret set to use for deployment",
+            rich_help_panel="Deployment Configuration",
+        ),
+        organization: str = typer.Option(
+            None,
+            "--organization",
+            "--org",
+            help="Organization to deploy to",
+            rich_help_panel="Deployment Configuration",
+        ),
+        credentials: str = typer.Option(
+            None,
+            "--credentials",
+            "--c",
+            help="Image pull secret to use for deployment",
+            rich_help_panel="Deployment Configuration",
+        ),
+    ):
+        token = ctx.obj["token"]
+
+        # Compose deployment config from CLI options and config file (if provided)
+        # Order of precedence:
+        #   1. Arguments provided to the CLI deploy command
+        #   2. Values from the config toml file
+        #   3. CLI command defaults
+        deployment_config = {
+            "min_instances": min_instances or 1,
+            "max_instances": max_instances or 20,
+            "organization": organization or ctx.obj.get("org"),
+            "secrets": secrets,
+        }
+
+        # Collect passed values from CLI arguments (ignoring defaults)
+        passed_values = {}
+        for param in ctx.command.params:
+            if param.name == "agent_name" or param.name == "image":
+                continue
+            value = ctx.params.get(str(param.name))
+            # Only include if the value is different from the parameter's default
+            if value != param.default:
+                passed_values[param.name] = value
+        deployment_config.update(passed_values)
+
+        # Merge with values from deployment config file
+        if deploy_config := load_deploy_config_file():
+            for key, value in deploy_config.items():
+                deployment_config.setdefault(key, value)
+
+        final_agent_name = agent_name or deployment_config.get("agent_name")
+        final_image = image or deployment_config.get("image")
+
+        # Assert agent name and image are provided
+        if not final_agent_name:
+            raise typer.BadParameter("Agent name is required")
+        if not final_image:
+            console.print("[red]Error:[/red] Image location is required", style="bold red")
+            raise typer.BadParameter("Image location is required")
+
+        # Create and display table
+        table = Table(
+            show_header=False,
+            border_style="dim",
+            show_edge=True,
+            show_lines=True)
+        table.add_column("Property", style="cyan")
+        table.add_column("Value", style="green")
+        table.add_row("Min instances", str(deployment_config['min_instances']))
+        table.add_row("Max instances", str(deployment_config['max_instances']))
+
+        content = Group(
+            (f"[bold white]Agent name:[/bold white] [green]{final_agent_name}[/green]"),
+            (f"[bold white]Image:[/bold white] [green]{final_image}[/green]"),
+            (f"[bold white]Organization:[/bold white] [green]{deployment_config['organization']}[/green]"),
+            (f"[bold white]Secret set:[/bold white] [green]{secrets}[/green]"),
+            (f"[bold white]Image pull secret:[/bold white] [green]{credentials}[/green]"),
+            "\n[dim]Deployment configuration:[/dim]",
+            table)
+
+        console.print(
+            Panel(
+                content,
+                title="Review deployment",
+                title_align="left",
+                padding=1,
+                style="yellow",
+                border_style="yellow"))
+
+        if not typer.confirm("\nDo you want to proceed with deployment?", default=True):
+            raise typer.Abort()
+
+        # Deploy method posts the deployment config to the API
+        # and polls the deployment status until it's ready
+        await _deploy(token, final_agent_name, final_image, deployment_config, credentials)

pipecatcloud/cli/entry_point.py

@@ -0,0 +1,83 @@
+import sys
+
+import typer
+from loguru import logger
+
+from pipecatcloud.cli.agent import agent_cli
+from pipecatcloud.cli.auth import auth_cli
+from pipecatcloud.cli.deploy import create_deploy_command
+from pipecatcloud.cli.organizations import organization_cli
+from pipecatcloud.cli.run import create_run_command
+from pipecatcloud.cli.secrets import secrets_cli
+from pipecatcloud.config import config
+
+logger.remove()
+logger.add(sys.stderr, level=str(config.get("cli_log_level", "INFO")))
+
+
+def version_callback(value: bool):
+    if value:
+        from pipecatcloud.__version__ import version
+
+        typer.echo(
+            f"ᓚᘏᗢ Pipecat Cloud Client Version: {typer.style(version, fg=typer.colors.GREEN)}")
+        raise typer.Exit()
+
+
+def config_callback(value: bool):
+    if value:
+        from rich import print_json
+        from rich.pretty import pprint
+
+        from pipecatcloud._utils.deploy_utils import load_deploy_config_file
+        from pipecatcloud.config import config
+
+        # Check for deploy config
+        deploy_config = load_deploy_config_file()
+        if deploy_config:
+            print("Deploy config:")
+            print_json(data=deploy_config)
+
+            print("Config:")
+            print_json(data=config.to_dict())
+
+        pprint(config.to_dict())
+        raise typer.Exit()
+
+
+entrypoint_cli_typer = typer.Typer(
+    no_args_is_help=True,
+    add_completion=False,
+    rich_markup_mode="markdown",
+    help="""
+    ᓚᘏᗢ Pipecat Cloud CLI
+    See website at https://pipecat.cloud
+    """,
+)
+
+
+@entrypoint_cli_typer.callback()
+def pipecat(
+    ctx: typer.Context,
+    _version: bool = typer.Option(None, "--version", callback=version_callback, help="CLI version"),
+    _config: bool = typer.Option(None, "--config", callback=config_callback, help="CLI config"),
+):
+    if not ctx.obj:
+        ctx.obj = {}
+
+    # All commands require an active namespace (organization)
+    # The CLI reads config data and sets the users currently active org in context
+    # which is used as a default when an `--org` flag is not provided
+    ctx.obj["org"] = config.get("org")
+    ctx.obj["token"] = config.get("token")
+    ctx.obj["default_public_key"] = config.get("default_public_key", None)
+    ctx.obj["default_public_key_name"] = config.get("default_public_key_name", None)
+
+
+create_deploy_command(entrypoint_cli_typer)
+create_run_command(entrypoint_cli_typer)
+entrypoint_cli_typer.add_typer(auth_cli, rich_help_panel="Commands")
+entrypoint_cli_typer.add_typer(organization_cli, rich_help_panel="Commands")
+entrypoint_cli_typer.add_typer(agent_cli, rich_help_panel="Commands")
+entrypoint_cli_typer.add_typer(secrets_cli, rich_help_panel="Commands")
+entrypoint_cli = typer.main.get_command(entrypoint_cli_typer)