pipecatcloud 0.2.10__tar.gz → 0.2.12__tar.gz

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/.github/workflows/publish-pypi.yml

@@ -27,6 +27,8 @@ jobs:
       - name: Install development dependencies
         run: uv sync --group dev
       - name: Build project
+        env:
+          SETUPTOOLS_SCM_PRETEND_VERSION: ${{ github.event.inputs.gitref }}
         run: uv build
       - name: Upload wheels
         uses: actions/upload-artifact@v4

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/CHANGELOG.md

@@ -5,6 +5,64 @@ All notable changes to **Pipecat Cloud** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.12] - 2025-11-26
+
+### Added
+
+- Added regional support for secrets and services/agents. Services and secrets
+  must be in the same region. Available regions are fetched dynamically from
+  the API and can be viewed with `pcc regions list`.
+
+- Added `pcc regions list` command to display available regions with their
+  display names (e.g., "US West (Oregon)", "Europe (Frankfurt)",
+  "Asia Pacific (Mumbai)").
+
+- Added `--region` / `-r` option to the `secrets set` command to specify the
+  region when creating or updating secret sets.
+
+- Added `--region` / `-r` filter option to the `secrets list` command to filter
+  secret sets by region. The Region column is now displayed in the output
+  table.
+
+- Added `--region` / `-r` option to the `secrets image-pull-secret` command to
+  specify the region for image pull secrets.
+
+- Added `--region` / `-r` option to the `deploy` command to specify the region
+  for service deployments. Region can also be configured via `pcc-deploy.toml`
+  by adding the `region` attribute. The region is displayed in the deployment
+  review panel.
+
+- Added `--region` / `-r` filter option to the `agent list` command to filter
+  agents by region. The Region column is now displayed in the output table.
+
+- Added region validation that checks user-provided region codes against the
+  live API region list, with helpful error messages showing available regions.
+
+### Changed
+
+- When the `--region` option is not specified for create/update operations
+  (secrets, deployments), the CLI now defaults to `us-west` with a deprecation
+  warning. Users are encouraged to explicitly specify the region as this
+  default will be required in a future version.
+
+- All error messages reference the Pipecat CLI (e.g. `pipecat cloud`) in place
+  of `pipecatcloud` or `pcc`.
+
+### Fixed
+
+- Improved error handling when building a docker image on an x86 machine.
+
+## [0.2.11] - 2025-11-12
+
+### Added
+
+- Added an option to retrieve logs by session ID using `--session-id` / `-s`
+  with the `agent logs` command.
+
+### Changed
+
+- Bumped the `fastapi` dependency's upperbound to `<1.0.0`.
+
 ## [0.2.10] - 2025-10-25
 
 ### Removed

{pipecatcloud-0.2.10/src/pipecatcloud.egg-info → pipecatcloud-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.10
+Version: 0.2.12
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -9,7 +9,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp<4.0.0,>=3.11.12
-Requires-Dist: fastapi<0.117.0,>=0.115.6
+Requires-Dist: fastapi<1.0.0,>=0.115.6
 Requires-Dist: loguru~=0.7.3
 Requires-Dist: python-dotenv<2.0.0,>=1.0.1
 Requires-Dist: uvicorn<1.0.0,>=0.32.0

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/pyproject.toml

@@ -12,7 +12,7 @@ readme = "README.md"
 keywords = ["pipecat", "pipecat-ai", "voice", "ai", "llm"]
 dependencies = [
     "aiohttp>=3.11.12,<4.0.0",
-    "fastapi>=0.115.6,<0.117.0",
+    "fastapi>=0.115.6,<1.0.0",
     "loguru~=0.7.3",
     "python-dotenv>=1.0.1,<2.0.0",
     "uvicorn>=0.32.0,<1.0.0",

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/src/pipecatcloud/_utils/deploy_utils.py

@@ -80,6 +80,7 @@ class DeployConfigParams:
     image: Optional[str] = None
     image_credentials: Optional[str] = None
     secret_set: Optional[str] = None
+    region: Optional[str] = None
     scaling: ScalingParams = ScalingParams()
     enable_krisp: bool = False
     enable_managed_keys: bool = False
@@ -97,6 +98,7 @@ class DeployConfigParams:
             "image": self.image,
             "image_credentials": self.image_credentials,
             "secret_set": self.secret_set,
+            "region": self.region,
             "scaling": self.scaling.to_dict() if self.scaling else None,
             "enable_krisp": self.enable_krisp,
             "enable_managed_keys": self.enable_managed_keys,
@@ -144,6 +146,7 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "image",
             "image_credentials",
             "secret_set",
+            "region",
             "scaling",
             "enable_krisp",
             "enable_managed_keys",

pipecatcloud-0.2.12/src/pipecatcloud/_utils/regions.py

@@ -0,0 +1,70 @@
+#
+# Copyright (c) 2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""
+Region utilities for Pipecat Cloud CLI.
+
+Provides functions to fetch and cache available regions from the API.
+"""
+
+from typing import Dict, List, Optional
+
+from pipecatcloud.cli.api import API
+from pipecatcloud.cli.config import config
+
+# Module-level cache for regions
+_regions_cache: Optional[List[Dict[str, str]]] = None
+
+
+async def get_regions() -> List[Dict[str, str]]:
+    """
+    Fetch available regions from the API with caching.
+
+    This function is cached so the API is only called once per CLI session.
+
+    Returns:
+        List of region objects with 'code' and 'display_name' fields
+        Example: [
+            {"code": "us-west", "display_name": "US West"},
+            {"code": "eu-central", "display_name": "EU Central"}
+        ]
+    """
+    global _regions_cache
+
+    if _regions_cache is None:
+        org = config.get("org")
+        # API returns (data, error) tuple
+        data, error = await API.regions(org=org)
+        if error or not data:
+            return []
+        _regions_cache = data
+
+    return _regions_cache
+
+
+async def get_region_codes() -> List[str]:
+    """
+    Get list of region codes only.
+
+    Returns:
+        List of region codes (e.g., ['us-west', 'eu-central', 'ap-south'])
+    """
+    regions = await get_regions()
+    return [r["code"] for r in regions]
+
+
+async def validate_region(region: str) -> bool:
+    """
+    Validate that a region code is supported.
+
+    Args:
+        region: Region code to validate
+
+    Returns:
+        True if region is valid, False otherwise
+    """
+    valid_codes = await get_region_codes()
+    return region in valid_codes

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/src/pipecatcloud/api.py

@@ -86,8 +86,8 @@ class _API:
                     # Fallback structure matching API format
                     self.error = {
                         "error": response.reason or "Bad Request",
-                        "code": str(
-                            response.status)}
+                        "code": str(response.status),
+                    }
                 response.raise_for_status()
 
             return await response.json()
@@ -236,13 +236,16 @@ class _API:
 
     # Secret
 
-    async def _secrets_list(self, org: str, secret_set: Optional[str] = None) -> dict | None:
+    async def _secrets_list(self, org: str, secret_set: Optional[str] = None, region: Optional[str] = None) -> dict | None:
         if secret_set:
             url = f"{self.construct_api_url('secrets_path').format(org=org)}/{secret_set}"
         else:
             url = f"{self.construct_api_url('secrets_path').format(org=org)}"
 
-        result = await self._base_request("GET", url, not_found_is_empty=True) or {}
+        # Build query params if region filter is specified
+        params = {"region": region} if region else None
+
+        result = await self._base_request("GET", url, params=params, not_found_is_empty=True) or {}
 
         if "sets" in result:
             return result["sets"]
@@ -258,12 +261,17 @@ class _API:
         Args:
             org: Organization ID,
             secret_set: (optional) name of secret set to lookup
+            region: (optional) filter by region
 
         """
         return self.create_api_method(self._secrets_list)
 
-    async def _secrets_upsert(self, data: dict, set_name: str, org: str) -> dict:
+    async def _secrets_upsert(self, data: dict, set_name: str, org: str, region: str) -> dict:
         url = f"{self.construct_api_url('secrets_path').format(org=org)}/{set_name}"
+
+        # Add region to data payload
+        data = {**data, "region": region}
+
         return await self._base_request("PUT", url, json=data) or {}
 
     @property
@@ -273,6 +281,7 @@ class _API:
             data: key and value of secret to add (or credentials for image pull secrets)
             set_name: name of set to create or update
             org: Organization ID
+            region: region for secret set
         """
         return self.create_api_method(self._secrets_upsert)
 
@@ -316,6 +325,7 @@ class _API:
             "image": deploy_config.image,
             "imagePullSecretSet": deploy_config.image_credentials,
             "secretSet": deploy_config.secret_set,
+            "region": deploy_config.region,
             "autoScaling": {
                 "minAgents": deploy_config.scaling.min_agents,
                 "maxAgents": deploy_config.scaling.max_agents,
@@ -373,9 +383,13 @@ class _API:
         """
         return self.create_api_method(self._agent)
 
-    async def _agents(self, org: str) -> List[dict] | None:
+    async def _agents(self, org: str, region: Optional[str] = None) -> List[dict] | None:
         url = f"{self.construct_api_url('services_path').format(org=org)}"
-        result = await self._base_request("GET", url) or {}
+
+        # Build query params if region filter is specified
+        params = {"region": region} if region else None
+
+        result = await self._base_request("GET", url, params=params) or {}
 
         if "services" in result:
             return result["services"]
@@ -384,6 +398,11 @@ class _API:
 
     @property
     def agents(self):
+        """List agents/services
+        Args:
+            org: Organization ID
+            region: (optional) filter by region
+        """
         return self.create_api_method(self._agents)
 
     async def _start_agent(
@@ -422,12 +441,20 @@ class _API:
     def agent_delete(self):
         return self.create_api_method(self._agent_delete)
 
-    async def _agent_logs(self, agent_name: str, org: str, limit: int = 100,
-                          deployment_id: Optional[str] = None) -> dict | None:
+    async def _agent_logs(
+        self,
+        agent_name: str,
+        org: str,
+        limit: int = 100,
+        deployment_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ) -> dict | None:
         url = f"{self.construct_api_url('services_logs_path').format(org=org, service=agent_name)}"
         params: dict[str, Union[int, str]] = {"limit": limit}
         if deployment_id:
             params["deploymentId"] = deployment_id
+        if session_id:
+            params["sessionId"] = session_id
         return await self._base_request("GET", url, params=params)
 
     @property
@@ -442,7 +469,9 @@ class _API:
     def agent_sessions(self):
         return self.create_api_method(self._agent_sessions)
 
-    async def _agent_session_terminate(self, agent_name: str, session_id: str, org: str) -> dict | None:
+    async def _agent_session_terminate(
+        self, agent_name: str, session_id: str, org: str
+    ) -> dict | None:
         url = f"{self.construct_api_url('services_sessions_path').format(org=org, service=agent_name)}/{session_id}"
         return await self._base_request("DELETE", url, not_found_is_empty=True)
 
@@ -455,3 +484,25 @@ class _API:
             org: Organization ID
         """
         return self.create_api_method(self._agent_session_terminate)
+
+    # Regions
+
+    async def _regions(self, org: str) -> list[dict] | None:
+        url = self.construct_api_url("regions_path").format(org=org)
+        result = await self._base_request("GET", url, not_found_is_empty=True)
+
+        if result and "regions" in result:
+            # Return full region objects with code and display_name
+            return result["regions"]
+
+        return None
+
+    @property
+    def regions(self):
+        """List available regions
+        Args:
+            org: Organization ID
+        Returns:
+            List of region objects with 'code' and 'display_name' fields
+        """
+        return self.create_api_method(self._regions)

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/src/pipecatcloud/cli/__init__.py

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
-PIPECAT_CLI_NAME = "pcc"
+PIPECAT_CLI_NAME = "pipecat cloud"
 PIPECAT_CREDENTIALS_PATH = "~/.config/pipecatcloud/pipecatcloud.toml"
 PIPECAT_DEPLOY_CONFIG_PATH = "pcc-deploy.toml"
 

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/src/pipecatcloud/cli/commands/agent.py

@@ -6,6 +6,7 @@
 
 import json
 from enum import Enum
+from typing import Optional
 
 import aiohttp
 import questionary
@@ -28,9 +29,11 @@ from pipecatcloud._utils.console_utils import (
     format_timestamp,
 )
 from pipecatcloud._utils.deploy_utils import DeployConfigParams, with_deploy_config
+from pipecatcloud._utils.regions import get_region_codes, validate_region
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
+from pipecatcloud.constants import Region
 
 agent_cli = typer.Typer(name="agent", help="Agent management", no_args_is_help=True)
 
@@ -45,13 +48,27 @@ async def list(
     organization: str = typer.Option(
         None, "--organization", "-o", help="Organization to list agents for"
     ),
+    region: Optional[Region] = typer.Option(
+        None,
+        "--region",
+        "-r",
+        help="Filter by region",
+    ),
 ):
     org = organization or config.get("org")
 
+    # Validate region if provided
+    if region and not await validate_region(region):
+        valid_regions = await get_region_codes()
+        console.print(
+            f"[red]Invalid region '{region}'. Valid regions are: {', '.join(valid_regions)}[/red]"
+        )
+        return typer.Exit(1)
+
     with console.status(
         f"[dim]Fetching agents for organization: [bold]'{org}'[/bold][/dim]", spinner="dots"
     ):
-        data, error = await API.agents(org=org)
+        data, error = await API.agents(org=org, region=region)
 
         if error:
             return typer.Exit()
@@ -66,6 +83,7 @@ async def list(
         else:
             table = Table(show_header=True, show_lines=True, border_style="dim", box=box.SIMPLE)
             table.add_column("Name")
+            table.add_column("Region")
             table.add_column("Agent ID")
             table.add_column("Active Deployment ID")
             table.add_column("Created At")
@@ -74,6 +92,7 @@ async def list(
             for service in data:
                 table.add_row(
                     f"[bold]{service['name']}[/bold]",
+                    service["region"],
                     service["id"],
                     service["activeDeploymentId"],
                     service["createdAt"],
@@ -440,17 +459,26 @@ async def logs(
     deployment_id: str = typer.Option(
         None, "--deployment", "-d", help="Filter logs by deployment ID"
     ),
+    session_id: str = typer.Option(None, "--session-id", "-s", help="Filter logs by session ID"),
 ):
     org = organization or config.get("org")
 
-    status_text = "agent" if not deployment_id else f"deployment ({deployment_id})"
+    status_text = "agent"
+    if deployment_id:
+        status_text = f"deployment ({deployment_id})"
+    if session_id:
+        status_text = f"session ({session_id})"
 
     with console.status(
         f"[dim]Fetching logs for {status_text}: [bold]'{agent_name}'[/bold] with severity: [bold cyan]{level.value if level else 'ALL'}[/bold cyan][/dim]",
         spinner="dots",
     ):
         data, error = await API.agent_logs(
-            agent_name=agent_name, org=org, limit=limit, deployment_id=deployment_id
+            agent_name=agent_name,
+            org=org,
+            limit=limit,
+            deployment_id=deployment_id,
+            session_id=session_id,
         )
 
         if not data or not data.get("logs"):
@@ -786,16 +814,13 @@ async def stop(
     if not force:
         console.print(
             Panel(
-                f"Agent Name: {agent_name}\n"
-                f"Session ID: {session_id}",
-                title=f"[bold]Stop Session[/bold]",
+                f"Agent Name: {agent_name}\nSession ID: {session_id}",
+                title="[bold]Stop Session[/bold]",
                 title_align="left",
                 border_style="yellow",
             )
         )
-        if not await questionary.confirm(
-            "Are you sure you want to stop this session?"
-        ).ask_async():
+        if not await questionary.confirm("Are you sure you want to stop this session?").ask_async():
             console.print("[bold]Aborting stop request[/bold]")
             return typer.Exit(1)
 

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/src/pipecatcloud/cli/commands/deploy.py

@@ -5,6 +5,7 @@
 #
 
 import asyncio
+from typing import Optional
 
 import typer
 from loguru import logger
@@ -23,7 +24,8 @@ from pipecatcloud._utils.deploy_utils import (
     ScalingParams,
     with_deploy_config,
 )
-from pipecatcloud.constants import KRISP_VIVA_MODELS
+from pipecatcloud._utils.regions import get_region_codes, validate_region
+from pipecatcloud.constants import KRISP_VIVA_MODELS, Region
 from pipecatcloud.cli import PIPECAT_CLI_NAME
 from pipecatcloud.cli.api import API
 from pipecatcloud.cli.config import config
@@ -300,6 +302,13 @@ def create_deploy_command(app: typer.Typer):
             help="Agent profile to use for deployment",
             rich_help_panel="Deployment Configuration",
         ),
+        region: Optional[Region] = typer.Option(
+            None,
+            "--region",
+            "-r",
+            help="Region for service deployment",
+            rich_help_panel="Deployment Configuration",
+        ),
         skip_confirm: bool = typer.Option(
             False,
             "--force",
@@ -372,6 +381,24 @@ def create_deploy_command(app: typer.Typer):
         partial_config.enable_managed_keys = managed_keys or partial_config.enable_managed_keys
         partial_config.agent_profile = profile or partial_config.agent_profile
 
+        # Handle region with warning if not specified
+        deploy_region = region or partial_config.region
+        if not deploy_region:
+            logger.warning(
+                "Region not specified, defaulting to 'us-west'. Please use --region to specify explicitly. "
+                "This default will be required in a future version."
+            )
+            deploy_region = "us-west"
+        partial_config.region = deploy_region
+
+        # Validate region against API
+        if not await validate_region(deploy_region):
+            valid_regions = await get_region_codes()
+            console.error(
+                f"Invalid region '{deploy_region}'. Valid regions are: {', '.join(valid_regions)}"
+            )
+            return typer.Exit(1)
+
         # Handle Krisp VIVA configuration
         if krisp_viva_audio_filter is not None:
             partial_config.krisp_viva = KrispVivaConfig(audio_filter=krisp_viva_audio_filter)
@@ -409,6 +436,7 @@ def create_deploy_command(app: typer.Typer):
             (f"[bold white]Agent name:[/bold white] [green]{partial_config.agent_name}[/green]"),
             (f"[bold white]Image:[/bold white] [green]{partial_config.image}[/green]"),
             (f"[bold white]Organization:[/bold white] [green]{org}[/green]"),
+            (f"[bold white]Region:[/bold white] [green]{partial_config.region}[/green]"),
             (f"[bold white]Secret set:[/bold white] {'[dim]None[/dim]' if not partial_config.secret_set else '[green] '+ partial_config.secret_set + '[/green]'}"),
             (f"[bold white]Image pull secret:[/bold white] {'[dim]None[/dim]' if not partial_config.image_credentials else '[green]' + partial_config.image_credentials + '[/green]'}"),
             (f"[bold white]Agent profile:[/bold white] {'[dim]None[/dim]' if not partial_config.agent_profile else '[green]' + partial_config.agent_profile + '[/green]'}"),

{pipecatcloud-0.2.10 → pipecatcloud-0.2.12}/src/pipecatcloud/cli/commands/docker.py

@@ -14,6 +14,7 @@ from rich.panel import Panel
 from pipecatcloud._utils.async_utils import synchronizer
 from pipecatcloud._utils.console_utils import console
 from pipecatcloud._utils.deploy_utils import DeployConfigParams, with_deploy_config
+from pipecatcloud.cli import PIPECAT_CLI_NAME
 
 docker_cli = typer.Typer(
     name="docker", help="Docker build and push utilities", no_args_is_help=True
@@ -25,9 +26,61 @@ class RegistryType(str, Enum):
     CUSTOM = "custom"
 
 
-def _provide_error_hints(stderr: str, command: list[str], registry_info: dict = None):
+def _suggest_and_install_binfmt():
+    """Suggest and optionally install binfmt_misc support for cross-platform builds."""
+    console.print("\n[yellow]⚠️  Cross-platform build support missing[/yellow]")
+    console.print(
+        "[yellow]   Building ARM64 images on x86_64 requires QEMU and binfmt_misc support.[/yellow]"
+    )
+    console.print(
+        "\n[yellow]   This is a one-time setup that persists across Docker restarts.[/yellow]"
+    )
+    console.print(
+        "\n[dim]   The following command will be run (requires Docker --privileged flag):[/dim]"
+    )
+    console.print("[dim]   docker run --privileged --rm tonistiigi/binfmt --install all[/dim]")
+
+    if typer.confirm("\nWould you like to install binfmt support now?", default=True):
+        console.print("\n[cyan]Installing binfmt support...[/cyan]")
+        install_cmd = [
+            "docker",
+            "run",
+            "--privileged",
+            "--rm",
+            "tonistiigi/binfmt",
+            "--install",
+            "all",
+        ]
+        if run_docker_command(
+            install_cmd, "Setting up cross-platform build support", stream_output=False
+        ):
+            console.success("✓ binfmt support installed! You can now retry your build.")
+        else:
+            console.error("Failed to install binfmt support.")
+            console.print("\n[yellow]You can install it manually by running:[/yellow]")
+            console.print(
+                "[yellow]   docker run --privileged --rm tonistiigi/binfmt --install all[/yellow]"
+            )
+    else:
+        console.print("\n[yellow]Skipping installation. To install manually, run:[/yellow]")
+        console.print(
+            "[yellow]   docker run --privileged --rm tonistiigi/binfmt --install all[/yellow]"
+        )
+
+
+def _provide_error_hints(stderr: str, stdout: str, command: list[str], registry_info: dict = None):
     """Provide helpful error hints only when Docker's message isn't clear enough."""
     stderr_lower = stderr.lower()
+    stdout_lower = stdout.lower()
+    combined_output = f"{stderr_lower} {stdout_lower}"
+
+    # Check for exec format error (cross-platform build issue)
+    if (
+        "exec format error" in combined_output
+        or "exec /bin/sh: exec format error" in combined_output
+    ):
+        _suggest_and_install_binfmt()
+        return
 
     # Only add hints for authentication errors where the solution isn't obvious
     if _is_auth_error(stderr_lower) and "push" in " ".join(command):
@@ -59,6 +112,8 @@ def run_docker_command(
 
         if stream_output:
             # Stream output in real-time for build commands
+            # Collect output for error analysis
+            output_lines = []
             process = subprocess.Popen(
                 command,
                 stdout=subprocess.PIPE,
@@ -70,11 +125,17 @@ def run_docker_command(
 
             # Stream output line by line
             for line in process.stdout:
+                output_lines.append(line)
                 console.print(f"[dim]{line.rstrip()}[/dim]")
 
             process.wait()
             if process.returncode != 0:
-                raise subprocess.CalledProcessError(process.returncode, command)
+                # Create a pseudo-exception with captured output
+                error = subprocess.CalledProcessError(process.returncode, command)
+                error.output = "".join(output_lines)
+                error.stdout = error.output
+                error.stderr = ""
+                raise error
         else:
             # Capture output for push commands (less verbose)
             result = subprocess.run(command, capture_output=True, text=True, check=True)
@@ -84,13 +145,16 @@ def run_docker_command(
         return True
     except subprocess.CalledProcessError as e:
         console.error(f"Docker command failed: {' '.join(command)}")
-        if e.stdout:
-            console.print(f"[red]stdout: {e.stdout}[/red]")
-        if e.stderr:
-            console.print(f"[red]stderr: {e.stderr}[/red]")
+        stdout = getattr(e, "stdout", "") or getattr(e, "output", "") or ""
+        stderr = getattr(e, "stderr", "") or ""
+
+        if stdout:
+            console.print(f"[red]stdout: {stdout}[/red]")
+        if stderr:
+            console.print(f"[red]stderr: {stderr}[/red]")
 
-            # Provide helpful hints for common errors
-            _provide_error_hints(e.stderr, command, registry_info)
+        # Provide helpful hints for common errors
+        _provide_error_hints(stderr, stdout, command, registry_info)
         return False
     except FileNotFoundError:
         console.error("Docker not found. Please ensure Docker is installed and in your PATH.")
@@ -336,7 +400,7 @@ async def build_push(
         console.print("\n[dim]To deploy this image, update your pcc-deploy.toml:[/dim]")
         console.print(f'  [bold]image = "{version_tag}"[/bold]')
         console.print("\n[dim]Then run:[/dim]")
-        console.print("  [bold]pipecat cloud deploy[/bold]")
+        console.print(f"  [bold]{PIPECAT_CLI_NAME} deploy[/bold]")
 
 
 def create_docker_command(app: typer.Typer):