pipecatcloud 0.2.2__tar.gz → 0.2.4__tar.gz

pipecatcloud-0.2.4/.github/workflows/publish-pypi.yml

@@ -0,0 +1,84 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to publish (must match pyproject.toml, e.g. 0.0.4)'
+        required: true
+        type: string
+
+jobs:
+  build:
+    name: 'Build and upload wheels'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+          fetch-depth: 100
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: 'latest'
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Verify version matches
+        run: |
+          PROJECT_VERSION=$(uv run python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          if [ "$PROJECT_VERSION" != "${{ github.event.inputs.version }}" ]; then
+            echo "Error: Input version (${{ github.event.inputs.version }}) does not match pyproject.toml version ($PROJECT_VERSION)"
+            exit 1
+          fi
+
+      - name: Install development dependencies
+        run: uv sync --group dev
+
+      - name: Build project
+        run: uv build
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+
+  publish-to-pypi:
+    name: 'Publish to PyPI'
+    runs-on: ubuntu-latest
+    needs: [build]
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pipecat-cloud
+    permissions:
+      id-token: write
+      contents: write # Needed for tagging
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+          fetch-depth: 100
+
+      - name: Create release tag
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git tag -a "v${{ github.event.inputs.version }}" -m "Version ${{ github.event.inputs.version }}"
+          git push origin "v${{ github.event.inputs.version }}"
+
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          print-hash: true

pipecatcloud-0.2.4/.github/workflows/publish-test.yml

@@ -0,0 +1,73 @@
+name: Publish to TEST PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to publish (must match pyproject.toml, e.g. 0.0.4)'
+        required: true
+        type: string
+
+jobs:
+  build:
+    name: 'Build and upload wheels'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+          fetch-depth: 100
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: 'latest'
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Verify version matches
+        run: |
+          PROJECT_VERSION=$(uv run python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          if [ "$PROJECT_VERSION" != "${{ github.event.inputs.version }}" ]; then
+            echo "Error: Input version (${{ github.event.inputs.version }}) does not match pyproject.toml version ($PROJECT_VERSION)"
+            exit 1
+          fi
+
+      - name: Install development dependencies
+        run: uv sync --group dev
+
+      - name: Build project
+        run: uv build
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+
+  publish-to-test-pypi:
+    name: 'Publish to Test PyPI'
+    runs-on: ubuntu-latest
+    needs: [build]
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/project/pipecat-cloud
+    permissions:
+      id-token: write
+    steps:
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: wheels
+          path: ./dist
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          verbose: true
+          print-hash: true

pipecatcloud-0.2.4/.github/workflows/tests.yml

@@ -0,0 +1,41 @@
+name: tests
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - '**'
+
+concurrency:
+  group: build-test-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: 'Unit Tests'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: 'latest'
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: |
+          uv sync --group dev
+
+      - name: Test Docker commands
+        run: |
+          uv run pytest tests/test_docker_commands.py -v
+
+      # Note: test_agent_sessions.py is excluded because it requires complex
+      # API mocking for CI. These tests can be run locally with proper auth.

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.4] - 2025-08-26
+
+### Added
+
+- Added `docker build-push` command for building, tagging, and pushing Docker
+  images. Automatically parses registry information from the `image` field in
+  `pcc-deploy.toml` and supports both Docker Hub and custom registries. Includes
+  real-time build output and helpful authentication error hints.
+
+### Changed
+
+- `pcc init` now points to https://github.com/pipecat-ai/pipecat-quickstart.
+
+## [0.2.3] - 2025-08-19
+
+### Fixed
+
+- Fixed an issue where DailySessionArguments required positional args for
+  `handle_sigint`, `handle_sigterm`, and `pipeline_idle_timeout_secs`.
+
 ## [0.2.2] - 2025-08-18
 
 ### Added

{pipecatcloud-0.2.2/src/pipecatcloud.egg-info → pipecatcloud-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.2
+Version: 0.2.4
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -63,7 +63,7 @@ pcc auth login
 
 2. Login to your account `pcc auth login`
 
-3. (Optional): Clone the starter agent [here](https://github.com/daily-co/pipecat-cloud-starter)
+3. (Optional): Clone the quickstart repo [here](https://github.com/pipecat-ai/pipecat-quickstart)
 
 4. Build your agent `docker build --platform linux/arm64 -t your-agent-name .`
 

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/README.md

@@ -40,7 +40,7 @@ pcc auth login
 
 2. Login to your account `pcc auth login`
 
-3. (Optional): Clone the starter agent [here](https://github.com/daily-co/pipecat-cloud-starter)
+3. (Optional): Clone the quickstart repo [here](https://github.com/pipecat-ai/pipecat-quickstart)
 
 4. Build your agent `docker build --platform linux/arm64 -t your-agent-name .`
 

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pipecatcloud"
-version = "0.2.2"
+version = "0.2.4"
 requires-python = ">=3.10"
 description = "Cloud hosting for Pipecat AI applications"
 license = { text = "BSD 2-Clause License" }
@@ -25,6 +25,19 @@ dependencies = [
 [project.optional-dependencies]
 pipecat = ["pipecat-ai>=0.0.79"]
 
+[dependency-groups]
+dev = [
+    "build~=1.2.2",
+    "grpcio-tools~=1.67.1",
+    "pre-commit~=4.2.0",
+    "pyright~=1.1.402",
+    "pytest~=8.4.1",
+    "pytest-asyncio~=1.0.0",
+    "ruff~=0.12.1",
+    "setuptools~=78.1.1",
+    "setuptools_scm~=8.3.1",
+]
+
 [project.scripts]
 pcc = "pipecatcloud.__main__:main"
 pipecatcloud = "pipecatcloud.__main__:main"

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/src/pipecatcloud/_utils/deploy_utils.py

@@ -4,9 +4,9 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
-import os
 import functools
-from typing import Optional, Callable, Any
+import os
+from typing import Callable, Optional
 
 import toml
 from attr import dataclass, field
@@ -64,6 +64,7 @@ class DeployConfigParams:
     secret_set: Optional[str] = None
     scaling: ScalingParams = ScalingParams()
     enable_krisp: bool = False
+    docker_config: dict = field(factory=dict)
 
     def __attrs_post_init__(self):
         if self.image is not None and ":" not in self.image:
@@ -77,6 +78,7 @@ class DeployConfigParams:
             "secret_set": self.secret_set,
             "scaling": self.scaling.to_dict() if self.scaling else None,
             "enable_krisp": self.enable_krisp,
+            "docker_config": self.docker_config,
         }
 
 
@@ -97,10 +99,14 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
         scaling_data = config_data.pop("scaling", {})
         scaling_params = ScalingParams(**scaling_data)
 
+        # Extract docker configuration if present
+        docker_data = config_data.pop("docker", {})
+
         # Create DeployConfigParams with validated data
         validated_config = DeployConfigParams(
             **config_data,
             scaling=scaling_params,
+            docker_config=docker_data,
         )
 
         # Check for unexpected keys
@@ -111,6 +117,7 @@ def load_deploy_config_file() -> Optional[DeployConfigParams]:
             "secret_set",
             "scaling",
             "enable_krisp",
+            "docker",
         }
         unexpected_keys = set(config_data.keys()) - expected_keys
         if unexpected_keys:
@@ -128,13 +135,15 @@ def with_deploy_config(func: Callable) -> Callable:
     Decorator that loads the deploy config file and injects it into the function.
     If the config file exists, it will be loaded and passed to the function as `deploy_config`.
     """
+
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         try:
             deploy_config = load_deploy_config_file()
-            kwargs['deploy_config'] = deploy_config
+            kwargs["deploy_config"] = deploy_config
         except Exception as e:
             logger.error(f"Error loading deploy config: {e}")
             raise ConfigFileError(str(e))
         return func(*args, **kwargs)
+
     return wrapper

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/src/pipecatcloud/agent.py

@@ -5,7 +5,7 @@
 #
 
 import warnings
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from fastapi import WebSocket
@@ -32,9 +32,9 @@ except ImportError:
             will be removed in a future release.
         """
 
-        handle_sigint: bool
-        handle_sigterm: bool
-        pipeline_idle_timeout_secs: int
+        handle_sigint: bool = field(init=False)
+        handle_sigterm: bool = field(init=False)
+        pipeline_idle_timeout_secs: int = field(init=False)
 
         def __post_init__(self):
             self.handle_sigint = False

pipecatcloud-0.2.4/src/pipecatcloud/cli/commands/docker.py

@@ -0,0 +1,344 @@
+#
+# Copyright (c) 2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import subprocess
+from enum import Enum
+from typing import Optional
+
+import typer
+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
+
+docker_cli = typer.Typer(
+    name="docker", help="Docker build and push utilities", no_args_is_help=True
+)
+
+
+class RegistryType(str, Enum):
+    DOCKERHUB = "dockerhub"
+    CUSTOM = "custom"
+
+
+def _provide_error_hints(stderr: 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()
+
+    # Only add hints for authentication errors where the solution isn't obvious
+    if _is_auth_error(stderr_lower) and "push" in " ".join(command):
+        _suggest_docker_login(registry_info)
+
+
+def _is_auth_error(stderr_lower: str) -> bool:
+    """Check if the error is authentication related."""
+    auth_keywords = ["unauthorized", "access denied", "denied"]
+    return any(keyword in stderr_lower for keyword in auth_keywords)
+
+
+def _suggest_docker_login(registry_info: dict = None):
+    """Suggest the appropriate docker login command."""
+    console.print("\n[yellow]💡 You need to authenticate with the registry[/yellow]")
+
+    if registry_info and registry_info.get("type") == "custom" and registry_info.get("url"):
+        console.print(f"[yellow]   docker login {registry_info['url']}[/yellow]")
+    else:
+        console.print("[yellow]   docker login[/yellow]")
+
+
+def run_docker_command(
+    command: list[str], description: str, stream_output: bool = True, registry_info: dict = None
+) -> bool:
+    """Run a docker command and handle output/errors."""
+    try:
+        console.print(f"[dim]{description}...[/dim]")
+
+        if stream_output:
+            # Stream output in real-time for build commands
+            process = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+            )
+
+            # Stream output line by line
+            for line in process.stdout:
+                console.print(f"[dim]{line.rstrip()}[/dim]")
+
+            process.wait()
+            if process.returncode != 0:
+                raise subprocess.CalledProcessError(process.returncode, command)
+        else:
+            # Capture output for push commands (less verbose)
+            result = subprocess.run(command, capture_output=True, text=True, check=True)
+            if result.stdout.strip():
+                console.print(f"[dim]{result.stdout.strip()}[/dim]")
+
+        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]")
+
+            # Provide helpful hints for common errors
+            _provide_error_hints(e.stderr, command, registry_info)
+        return False
+    except FileNotFoundError:
+        console.error("Docker not found. Please ensure Docker is installed and in your PATH.")
+        return False
+
+
+def _build_image_name(
+    registry_type: RegistryType, username: str, agent_name: str, registry_url: Optional[str] = None
+) -> str:
+    """Build the full image name based on registry type."""
+    if registry_type == RegistryType.DOCKERHUB:
+        return f"{username}/{agent_name}"
+    elif registry_type == RegistryType.CUSTOM:
+        if not registry_url:
+            raise ValueError("registry_url is required for custom registries")
+        return f"{registry_url}/{username}/{agent_name}"
+    else:
+        raise ValueError(f"Unsupported registry type: {registry_type}")
+
+
+@docker_cli.command(name="build-push", help="Build, tag, and push Docker image")
+@synchronizer.create_blocking
+@with_deploy_config
+async def build_push(
+    deploy_config=typer.Option(None, hidden=True),
+    agent_name: str = typer.Argument(
+        None, help="Name of the agent to build image for e.g. 'my-agent'", show_default=False
+    ),
+    registry: RegistryType = typer.Option(
+        None,
+        "--registry",
+        "-r",
+        help="Registry type to push to",
+        rich_help_panel="Registry Configuration",
+    ),
+    registry_username: str = typer.Option(
+        None,
+        "--username",
+        "-u",
+        help="Registry username",
+        rich_help_panel="Registry Configuration",
+    ),
+    registry_url: str = typer.Option(
+        None,
+        "--registry-url",
+        help="Custom registry URL (required for custom registries)",
+        rich_help_panel="Registry Configuration",
+    ),
+    version: str = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Version tag for the image",
+        rich_help_panel="Build Configuration",
+    ),
+    no_push: bool = typer.Option(
+        False,
+        "--no-push",
+        help="Build and tag only, do not push to registry",
+        rich_help_panel="Build Configuration",
+    ),
+    no_latest: bool = typer.Option(
+        False,
+        "--no-latest",
+        help="Do not tag as 'latest'",
+        rich_help_panel="Build Configuration",
+    ),
+):
+    """Build, tag, and optionally push a Docker image for your agent."""
+
+    # Load values from deployment config file (if one exists)
+    partial_config = deploy_config or DeployConfigParams()
+    docker_config = getattr(partial_config, "docker_config", {})
+
+    # Parse image field to extract registry info (if present)
+    parsed_registry = None
+    parsed_username = None
+    parsed_agent_name = None
+    parsed_version = None
+    parsed_registry_url = None
+
+    if partial_config.image:
+        # Parse image like "markatdaily/voice-starter:0.5" or "registry.com/user/app:v1.0"
+        image_parts = partial_config.image.split("/")
+
+        if len(image_parts) == 2:
+            # Format: "username/repo:tag" (Docker Hub)
+            parsed_registry = "dockerhub"
+            parsed_username = image_parts[0]
+            repo_and_tag = image_parts[1]
+        elif len(image_parts) == 3:
+            # Format: "registry.com/username/repo:tag" (Custom registry)
+            parsed_registry = "custom"
+            parsed_registry_url = image_parts[0]
+            parsed_username = image_parts[1]
+            repo_and_tag = image_parts[2]
+        else:
+            # Just "repo:tag" - use for agent name only
+            repo_and_tag = partial_config.image
+
+        # Extract agent name and version from "repo:tag"
+        if ":" in repo_and_tag:
+            parsed_agent_name, parsed_version = repo_and_tag.split(":", 1)
+        else:
+            parsed_agent_name = repo_and_tag
+            parsed_version = "latest"
+
+    # Resolve final values with precedence: CLI args > parsed from image > docker config > defaults
+    final_agent_name = agent_name or parsed_agent_name or partial_config.agent_name
+    final_registry = registry or parsed_registry or docker_config.get("registry")
+    final_username = registry_username or parsed_username or docker_config.get("registry_username")
+    final_registry_url = registry_url or parsed_registry_url or docker_config.get("registry_url")
+    final_version = version or parsed_version or "latest"
+    final_no_latest = no_latest or not docker_config.get("auto_latest", True)
+
+    # Validate required parameters
+    if not final_agent_name:
+        console.error("Agent name is required. Provide via argument or pcc-deploy.toml")
+        return typer.Exit(1)
+
+    if not no_push:
+        if not final_registry:
+            console.error(
+                "Registry type is required when pushing. Use --registry or configure in pcc-deploy.toml"
+            )
+            return typer.Exit(1)
+
+        if not final_username:
+            console.error(
+                "Registry username is required when pushing. Use --username or configure in pcc-deploy.toml"
+            )
+            return typer.Exit(1)
+
+        if final_registry == RegistryType.CUSTOM and not final_registry_url:
+            console.error(
+                "Registry URL is required for custom registries. Use --registry-url or configure in pcc-deploy.toml"
+            )
+            return typer.Exit(1)
+
+    # Build image name
+    if no_push:
+        # For local builds, just use agent name
+        base_image_name = final_agent_name
+    else:
+        try:
+            base_image_name = _build_image_name(
+                RegistryType(final_registry), final_username, final_agent_name, final_registry_url
+            )
+        except ValueError as e:
+            console.error(str(e))
+            return typer.Exit(1)
+
+    # Prepare image tags
+    version_tag = f"{base_image_name}:{final_version}"
+    latest_tag = f"{base_image_name}:latest"
+
+    # Build Docker command
+    build_tags = ["-t", version_tag]
+    if not final_no_latest:
+        build_tags.extend(["-t", latest_tag])
+
+    build_command = [
+        "docker",
+        "buildx",
+        "build",
+        "--platform=linux/arm64",
+        "--load",
+        *build_tags,
+        ".",
+    ]
+
+    # Display build configuration
+    tags_display = [version_tag]
+    if not final_no_latest:
+        tags_display.append(latest_tag)
+
+    console.print(
+        Panel(
+            f"[bold white]Agent:[/bold white] [green]{final_agent_name}[/green]\n"
+            f"[bold white]Platform:[/bold white] [green]linux/arm64[/green]\n"
+            f"[bold white]Tags:[/bold white] [green]{', '.join(tags_display)}[/green]\n"
+            f"[bold white]Push:[/bold white] {'[red]No[/red]' if no_push else f'[green]Yes ({final_registry})[/green]'}",
+            title="Docker Build Configuration",
+            title_align="left",
+            border_style="yellow",
+        )
+    )
+
+    if not typer.confirm("Do you want to proceed with the build?", default=True):
+        console.cancel()
+        return typer.Exit()
+
+    # Execute build
+    console.print("\n[bold cyan]Building Docker image...[/bold cyan]")
+    if not run_docker_command(build_command, f"Building {final_agent_name}", stream_output=True):
+        return typer.Exit(1)
+
+    console.success(f"Successfully built image(s): {', '.join(tags_display)}")
+
+    # Push if requested
+    if not no_push:
+        console.print(f"\n[bold cyan]Pushing to {final_registry}...[/bold cyan]")
+
+        # Prepare registry info for better error messages
+        registry_info = {
+            "type": final_registry,
+            "url": final_registry_url if final_registry == "custom" else None,
+        }
+
+        # Push version tag
+        if not run_docker_command(
+            ["docker", "push", version_tag],
+            f"Pushing {version_tag}",
+            stream_output=False,
+            registry_info=registry_info,
+        ):
+            return typer.Exit(1)
+
+        # Push latest tag if created
+        if not final_no_latest:
+            if not run_docker_command(
+                ["docker", "push", latest_tag],
+                f"Pushing {latest_tag}",
+                stream_output=False,
+                registry_info=registry_info,
+            ):
+                return typer.Exit(1)
+
+        pushed_tags = [version_tag]
+        if not final_no_latest:
+            pushed_tags.append(latest_tag)
+
+        console.success(f"Successfully pushed: {', '.join(pushed_tags)}")
+    else:
+        console.print("\n[yellow]Skipping push (--no-push specified)[/yellow]")
+
+    # Display next steps
+    if not no_push:
+        console.print("\n[dim]Your image is now available at:[/dim]")
+        for tag in tags_display:
+            console.print(f"  [bold]{tag}[/bold]")
+
+        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]pipecatcloud deploy[/bold]")
+
+
+def create_docker_command(app: typer.Typer):
+    """Add docker command to the main CLI app."""
+    app.add_typer(docker_cli, rich_help_panel="Commands")

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/src/pipecatcloud/cli/commands/init.py

@@ -19,14 +19,14 @@ from pipecatcloud.config import config
 # ----- Init
 
 FILES_TO_EXTRACT = {
-    "pipecat-cloud-starter-main/bot.py",
-    "pipecat-cloud-starter-main/Dockerfile",
-    "pipecat-cloud-starter-main/requirements.txt",
-    "pipecat-cloud-starter-main/pcc-deploy.toml",
-    "pipecat-cloud-starter-main/README.md",
-    "pipecat-cloud-starter-main/.gitignore",
-    "pipecat-cloud-starter-main/env.example",
-    "pipecat-cloud-starter-main/local_runner.py",
+    "pipecat-quickstart-main/bot.py",
+    "pipecat-quickstart-main/Dockerfile",
+    "pipecat-quickstart-main/pcc-deploy.toml",
+    "pipecat-quickstart-main/README.md",
+    "pipecat-quickstart-main/.gitignore",
+    "pipecat-quickstart-main/env.example",
+    "pipecat-quickstart-main/pyproject.toml",
+    "pipecat-quickstart-main/uv.lock",
 }
 
 

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/src/pipecatcloud/cli/entry_point.py

@@ -13,6 +13,7 @@ from pipecatcloud._utils.console_utils import console
 from pipecatcloud.cli.commands.agent import agent_cli
 from pipecatcloud.cli.commands.auth import auth_cli
 from pipecatcloud.cli.commands.deploy import create_deploy_command
+from pipecatcloud.cli.commands.docker import create_docker_command
 from pipecatcloud.cli.commands.init import create_init_command
 from pipecatcloud.cli.commands.organizations import organization_cli
 from pipecatcloud.cli.commands.run import create_run_command
@@ -80,6 +81,7 @@ def cli(
 create_run_command(entrypoint_cli_typer)
 create_init_command(entrypoint_cli_typer)
 create_deploy_command(entrypoint_cli_typer)
+create_docker_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(secrets_cli, rich_help_panel="Commands")

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/src/pipecatcloud/config.py

@@ -19,7 +19,7 @@ _SETTINGS = {
     "api_host": _Setting("https://api.pipecat.daily.co"),
     "dashboard_host": _Setting("https://pipecat.daily.co"),
     "init_zip_url": _Setting(
-        "https://github.com/daily-co/pipecat-cloud-starter/archive/refs/heads/main.zip"
+        "https://github.com/pipecat-ai/pipecat-quickstart/archive/refs/heads/main.zip"
     ),
     "onboarding_path": _Setting("/v1/onboarding"),
     "login_path": _Setting("/auth/login"),

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4/src/pipecatcloud.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.2
+Version: 0.2.4
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/
@@ -63,7 +63,7 @@ pcc auth login
 
 2. Login to your account `pcc auth login`
 
-3. (Optional): Clone the starter agent [here](https://github.com/daily-co/pipecat-cloud-starter)
+3. (Optional): Clone the quickstart repo [here](https://github.com/pipecat-ai/pipecat-quickstart)
 
 4. Build your agent `docker build --platform linux/arm64 -t your-agent-name .`
 

{pipecatcloud-0.2.2 → pipecatcloud-0.2.4}/src/pipecatcloud.egg-info/SOURCES.txt

@@ -2,13 +2,13 @@
 CHANGELOG.md
 LICENSE
 README.md
-dev-requirements.txt
 pipecat-cloud.png
 pyproject.toml
 pytest.ini
 .github/workflows/publish-pypi.yml
 .github/workflows/publish-test.yml
 .github/workflows/python-publish.yml
+.github/workflows/tests.yml
 src/pipecatcloud/__init__.py
 src/pipecatcloud/__main__.py
 src/pipecatcloud/__version__.py
@@ -38,9 +38,11 @@ src/pipecatcloud/cli/commands/__init__.py
 src/pipecatcloud/cli/commands/agent.py
 src/pipecatcloud/cli/commands/auth.py
 src/pipecatcloud/cli/commands/deploy.py
+src/pipecatcloud/cli/commands/docker.py
 src/pipecatcloud/cli/commands/init.py
 src/pipecatcloud/cli/commands/organizations.py
 src/pipecatcloud/cli/commands/run.py
 src/pipecatcloud/cli/commands/secrets.py
 tests/__init__.py
-tests/test_agent_sessions.py
+tests/test_agent_sessions.py
+tests/test_docker_commands.py

pipecatcloud-0.2.4/tests/test_docker_commands.py

@@ -0,0 +1,169 @@
+"""
+Unit tests for Docker build-push command.
+
+Tests the core functionality: image parsing, registry detection, and error handling.
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from src.pipecatcloud._utils.deploy_utils import DeployConfigParams
+from src.pipecatcloud.cli.commands.docker import (
+    RegistryType,
+    _build_image_name,
+    _is_auth_error,
+    _suggest_docker_login,
+)
+
+
+class TestImageParsing:
+    """Test parsing of image names for different registry formats."""
+
+    def test_build_image_name_dockerhub(self):
+        """Test building Docker Hub image names."""
+        result = _build_image_name(RegistryType.DOCKERHUB, "my_username", "test-image")
+        assert result == "my_username/test-image"
+
+    def test_build_image_name_custom_registry(self):
+        """Test building custom registry image names."""
+        result = _build_image_name(RegistryType.CUSTOM, "myuser", "myapp", "gcr.io")
+        assert result == "gcr.io/myuser/myapp"
+
+    def test_build_image_name_custom_registry_missing_url(self):
+        """Test custom registry without URL raises error."""
+        with pytest.raises(ValueError, match="registry_url is required"):
+            _build_image_name(RegistryType.CUSTOM, "user", "app")
+
+
+class TestConfigParsing:
+    """Test parsing configuration from deploy config."""
+
+    def test_parse_dockerhub_image(self):
+        """Test parsing Docker Hub format image."""
+        # Simulate parsing "my_username/test-image:0.5"
+        image = "my_username/test-image:0.5"
+        parts = image.split("/")
+
+        assert len(parts) == 2
+        assert parts[0] == "my_username"  # username
+
+        repo_and_tag = parts[1]
+        repo, tag = repo_and_tag.split(":", 1)
+        assert repo == "test-image"
+        assert tag == "0.5"
+
+    def test_parse_custom_registry_image(self):
+        """Test parsing custom registry format image."""
+        # Simulate parsing "gcr.io/my-project/app:v1.0"
+        image = "gcr.io/my-project/app:v1.0"
+        parts = image.split("/")
+
+        assert len(parts) == 3
+        assert parts[0] == "gcr.io"  # registry URL
+        assert parts[1] == "my-project"  # username/project
+
+        repo_and_tag = parts[2]
+        repo, tag = repo_and_tag.split(":", 1)
+        assert repo == "app"
+        assert tag == "v1.0"
+
+    def test_parse_image_no_tag(self):
+        """Test parsing image without explicit tag."""
+        image = "my_username/test-image"
+        parts = image.split("/")
+
+        repo_and_tag = parts[1]
+        if ":" in repo_and_tag:
+            repo, tag = repo_and_tag.split(":", 1)
+        else:
+            repo = repo_and_tag
+            tag = "latest"
+
+        assert repo == "test-image"
+        assert tag == "latest"
+
+
+class TestErrorHandling:
+    """Test error detection and hint generation."""
+
+    def test_is_auth_error_unauthorized(self):
+        """Test detection of unauthorized error."""
+        stderr = "Error: unauthorized: authentication required"
+        assert _is_auth_error(stderr.lower()) is True
+
+    def test_is_auth_error_access_denied(self):
+        """Test detection of access denied error."""
+        stderr = "Error: access denied to repository"
+        assert _is_auth_error(stderr.lower()) is True
+
+    def test_is_auth_error_denied(self):
+        """Test detection of denied error."""
+        stderr = "denied: requested access to the resource is denied"
+        assert _is_auth_error(stderr.lower()) is True
+
+    def test_is_auth_error_false(self):
+        """Test non-auth errors are not detected as auth errors."""
+        stderr = "Error: failed to build: syntax error in Dockerfile"
+        assert _is_auth_error(stderr.lower()) is False
+
+    @patch("src.pipecatcloud.cli.commands.docker.console")
+    def test_suggest_docker_login_dockerhub(self, mock_console):
+        """Test Docker Hub login suggestion."""
+        registry_info = {"type": "dockerhub"}
+        _suggest_docker_login(registry_info)
+
+        mock_console.print.assert_any_call(
+            "\n[yellow]💡 You need to authenticate with the registry[/yellow]"
+        )
+        mock_console.print.assert_any_call("[yellow]   docker login[/yellow]")
+
+    @patch("src.pipecatcloud.cli.commands.docker.console")
+    def test_suggest_docker_login_custom_registry(self, mock_console):
+        """Test custom registry login suggestion."""
+        registry_info = {"type": "custom", "url": "gcr.io"}
+        _suggest_docker_login(registry_info)
+
+        mock_console.print.assert_any_call(
+            "\n[yellow]💡 You need to authenticate with the registry[/yellow]"
+        )
+        mock_console.print.assert_any_call("[yellow]   docker login gcr.io[/yellow]")
+
+    @patch("src.pipecatcloud.cli.commands.docker.console")
+    def test_suggest_docker_login_no_registry_info(self, mock_console):
+        """Test login suggestion with no registry info."""
+        _suggest_docker_login(None)
+
+        mock_console.print.assert_any_call(
+            "\n[yellow]💡 You need to authenticate with the registry[/yellow]"
+        )
+        mock_console.print.assert_any_call("[yellow]   docker login[/yellow]")
+
+
+class TestDeployConfigIntegration:
+    """Test integration with deploy config system."""
+
+    def test_deploy_config_with_docker_section(self):
+        """Test deploy config parses docker section correctly."""
+        config = DeployConfigParams(
+            agent_name="test-agent",
+            image="my_username/test:1.0",
+            docker_config={
+                "registry": "dockerhub",
+                "registry_username": "my_username",
+                "auto_latest": False,
+            },
+        )
+
+        assert config.agent_name == "test-agent"
+        assert config.image == "my_username/test:1.0"
+        assert config.docker_config["registry"] == "dockerhub"
+        assert config.docker_config["auto_latest"] is False
+
+    def test_deploy_config_minimal(self):
+        """Test minimal deploy config works."""
+        config = DeployConfigParams(agent_name="test-agent", image="my_username/test:1.0")
+
+        assert config.agent_name == "test-agent"
+        assert config.image == "my_username/test:1.0"
+        assert config.docker_config == {}  # Empty dict by default

pipecatcloud-0.2.2/.github/workflows/publish-pypi.yml

@@ -1,66 +0,0 @@
-name: Publish to PyPI
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to publish (must match pyproject.toml, e.g. 0.0.4)'
-        required: true
-        type: string
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    environment:
-      name: pypi
-      url: https://pypi.org/p/pipecat-cloud
-    permissions:
-      id-token: write # IMPORTANT: this permission is needed for trusted publishing
-      contents: write # Needed for tagging
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-
-      - name: Verify version matches
-        run: |
-          pip install tomli
-          PROJECT_VERSION=$(python -c "import tomli; print(tomli.load(open('pyproject.toml', 'rb'))['project']['version'])")
-          if [ "$PROJECT_VERSION" != "${{ github.event.inputs.version }}" ]; then
-            echo "Error: Input version (${{ github.event.inputs.version }}) does not match pyproject.toml version ($PROJECT_VERSION)"
-            exit 1
-          fi
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r dev-requirements.txt
-          pip install build twine
-
-      - name: Build package
-        run: python -m build
-
-      - name: Check and create release tag if needed
-        run: |
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          
-          # Check if tag already exists remotely
-          if git ls-remote --tags origin | grep -q "refs/tags/v${{ github.event.inputs.version }}"; then
-            echo "Tag v${{ github.event.inputs.version }} already exists, skipping tag creation"
-          else
-            echo "Creating new tag v${{ github.event.inputs.version }}"
-            git tag -a "v${{ github.event.inputs.version }}" -m "Version ${{ github.event.inputs.version }}"
-            git push origin "v${{ github.event.inputs.version }}"
-          fi
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          verbose: true
-          print-hash: true

pipecatcloud-0.2.2/.github/workflows/publish-test.yml

@@ -1,67 +0,0 @@
-name: Publish to TEST PyPI
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to publish (must match pyproject.toml, e.g. 0.0.4)'
-        required: true
-        type: string
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    environment:
-      name: pypi
-      url: https://test.pypi.org/project/pipecat-cloud
-    permissions:
-      id-token: write 
-      contents: write
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-
-      - name: Verify version matches
-        run: |
-          pip install tomli
-          PROJECT_VERSION=$(python -c "import tomli; print(tomli.load(open('pyproject.toml', 'rb'))['project']['version'])")
-          if [ "$PROJECT_VERSION" != "${{ github.event.inputs.version }}" ]; then
-            echo "Error: Input version (${{ github.event.inputs.version }}) does not match pyproject.toml version ($PROJECT_VERSION)"
-            exit 1
-          fi
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r dev-requirements.txt
-          pip install build twine
-
-      - name: Build package
-        run: python -m build
-
-      - name: Check and create release tag if needed
-        run: |
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
-          
-          # Check if tag already exists remotely
-          if git ls-remote --tags origin | grep -q "refs/tags/v${{ github.event.inputs.version }}"; then
-            echo "Tag v${{ github.event.inputs.version }} already exists, skipping tag creation"
-          else
-            echo "Creating new tag v${{ github.event.inputs.version }}"
-            git tag -a "v${{ github.event.inputs.version }}" -m "Version ${{ github.event.inputs.version }}"
-            git push origin "v${{ github.event.inputs.version }}"
-          fi
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          repository-url: https://test.pypi.org/legacy/
-          verbose: true
-          print-hash: true

pipecatcloud-0.2.2/dev-requirements.txt

@@ -1,8 +0,0 @@
-build~=1.2.2
-grpcio-tools~=1.67.1
-pip-tools~=7.4.1
-pyright~=1.1.402
-pytest~=8.4.1
-ruff~=0.12.1
-setuptools~=78.1.1
-setuptools_scm~=8.3.1