pipecatcloud 1.0.1__tar.gz → 1.2.0__tar.gz

{pipecatcloud-1.0.1 → pipecatcloud-1.2.0}/CHANGELOG.md

@@ -5,6 +5,195 @@ 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).
 
+## [1.2.0] - 2026-08-27
+
+### Added
+
+- **GitHub integration**, at parity with the dashboard. Connect an
+  organization with `pipecat cloud github connect`: it opens the GitHub App
+  install page and waits while the install completes, so there is nothing to
+  copy back into the terminal. `github status` reports the connected account
+  and whether the App is suspended, `github disconnect` removes the
+  installation and every repository link under it, and `github repos` /
+  `github branches <owner/repo>` list what the App can see (`--query` runs the
+  server-side branch search for repositories with more branches than the list
+  returns).
+
+- Agents can be built from a repository instead of an image. `pipecat cloud
+  deploy --repo owner/repo --branch main` creates a GitHub-sourced agent,
+  skipping the image build and push entirely, and follows the first deploy
+  through its build; a `[git]` section in `pcc-deploy.toml` (`repo`, `branch`,
+  `dockerfile_path`, `subdirectory`) does the same, with flags taking
+  precedence. An existing agent's repository is changed with `pipecat cloud
+  agent link <name> --repo owner/repo --branch main` (also `--dockerfile-path`,
+  `--subdirectory` and `--no-auto-deploy`), and removed with `agent unlink`.
+  Linking never changes what is running.
+
+- `pipecat cloud agent deploy <name> --github` builds and deploys the linked
+  branch's current HEAD without waiting for a push, printing the deploy intent
+  and commit. `--wait` follows the deploy and reports one of four outcomes: it
+  succeeded, it failed, a newer push superseded it (naming the newer commit),
+  or it was still building when the wait ran out. Only an observed failure and
+  a deploy that was never visible at all exit non-zero, so a green `--wait`
+  means the deploy was observed and did not fail, never merely that the wait
+  finished. In `--output json` the outcome is reported as `waitOutcome`.
+
+- `pipecat cloud agent list` gains a GitHub column, and `agent status` reports
+  the linked repository and branch, the Dockerfile path, whether pushes
+  auto-deploy, the commit actually running, and the latest deploy attempt with
+  its failure reason. A running commit that did not come from the current link
+  (a freshly linked agent, or one whose repository or branch was re-pointed)
+  says so and names where it did come from. `pipecat cloud build status` and
+  `build list` show the repository, ref and commit a build came from.
+
+- Architecture selection on deploy: `pipecat cloud deploy --architecture
+  {amd64,arm64}` or an `architecture` key in `pcc-deploy.toml` (the flag
+  wins). Omitted, the region's default applies — set it when your image is
+  built for one architecture, so it schedules on matching nodes instead of
+  failing at startup. The choice is validated against the target region's
+  supported architectures before anything uploads, when the API advertises
+  them. `pipecat cloud regions list` shows each region's supported and
+  default architectures (Daily-hosted regions are arm64-only today), and
+  `pipecat cloud agent status` shows the deployment's architecture.
+
+- Region lifecycle commands for **self-hosted regions**. `pipecat cloud
+  regions register <key>` registers or updates a region (an omit-preserves
+  upsert: options you leave out keep their stored values), with a one-question
+  display-name prompt so region pickers show a friendly name instead of the
+  uppercased key. `regions show <key>` prints the full record, including the
+  enrollment status and intermediate certificate expiry. `regions delete
+  <key>` revokes a region, surfacing the server's refusal while live sessions
+  or deployed services exist; that guard has no bypass, so delete the region's
+  agents first, and `--yes` only skips the confirmation prompt.
+  `regions enroll-token <key>` mints the one-time enrollment token and
+  prints the ready-to-paste `kubectl create secret` command.
+
+- New `pipecat cloud organizations registry-keys` command group for the
+  pull-only registry credentials that fetch the region package chart:
+  `mint` (the key is shown exactly once, with the matching
+  `helm registry login` command), `list` (lifecycle metadata only, never key
+  material), and `revoke`. With these plus `regions register` and
+  `regions enroll-token`, a self-hosted region's control-plane setup needs no
+  raw API calls.
+
+- Explicit agent sizing for **enterprise (self-hosted) regions**. Deploys can
+  now state resources directly instead of selecting an agent profile:
+  `pipecat cloud deploy --resources cpu=2,memory=4Gi`, or a `[resources]`
+  section in `pcc-deploy.toml` with `cpu` and `memory` keys. Explicit
+  resources and `--profile` are mutually exclusive, and the API accepts
+  explicit resources only for agents in self-hosted regions.
+
+- `pipecat cloud agent status` now shows the agent's resolved resources
+  (cpu/memory) from the deployment. For agents deployed with explicit
+  resources rather than a profile, this is the sizing surface.
+
+- New `pipecat cloud agent profiles` command group. `list` shows the platform
+  catalog plus any profiles your organization has defined; `create`, `update`,
+  `disable`, and `enable` manage organization-defined profiles for self-hosted
+  regions. Profile edits apply to future deploys only: running agents keep the
+  resources their deployment captured. Disabling is reversible: a disabled
+  profile can't be selected for new deploys until re-enabled.
+
+- New `pipecat cloud secrets reference <name> --region <region>` command for
+  **self-hosted regions**. It registers an existing Kubernetes Secret from your
+  workloads namespace as a secret set, so agents can use it by set name exactly
+  as they use managed sets, and the Kubernetes Secret's name becomes the secret
+  set name. The secret stays in your cluster: Pipecat Cloud records only its
+  name, region, and readiness, never its values or keys, and you keep managing
+  its contents with your own tooling such as `kubectl`. `--region` is required
+  and must name a self-hosted region; cloud regions are rejected.
+
+### Fixed
+
+- `pipecat cloud deploy` no longer rejects a referenced secret set as "not
+  found". The existence check read the set's array of key names and tested it
+  for truthiness, but referenced sets carry no key names by design (Daily
+  stores name, region and readiness, never the contents), so every healthy
+  referenced set failed the check and no self-hosted deploy could use one. The
+  check now fetches the set itself; readiness is still enforced server-side.
+
+- `pipecat cloud secrets set` no longer treats an existing referenced secret
+  set as nonexistent. It had the same key-names misread as the deploy guard,
+  so it announced "Creating secret set" and then failed on the server's
+  name-uniqueness check. It now refuses before asking for confirmation,
+  pointing at the cluster as the place a referenced set's contents are
+  managed.
+
+- `pipecat cloud agent status` plain output (`--output plain`, or any piped
+  invocation) now includes the Architecture and Resources rows. Both were
+  rendered only in the rich table, so scripted output silently omitted the
+  deployment's architecture and, for agents sized with explicit resources,
+  their only visible sizing.
+
+## [1.1.0] - 2026-08-05
+
+### Added
+
+- New global `--output {rich,plain,json}` option for every `pipecat cloud`
+  command, also settable via the `PIPECAT_OUTPUT` environment variable or the
+  `output` config key. Note the option is placed before the subcommand
+  (`pipecat cloud --output json agent list`); in CI, setting `PIPECAT_OUTPUT`
+  once avoids ordering concerns. `rich` is the interactive default; `plain` is
+  line-oriented with no boxes and no truncation; `json` emits one
+  machine-readable JSON object on stdout with all human output on stderr.
+  When stdout is not a terminal the CLI now defaults to `plain`.
+
+- Progress is now visible when output is piped or redirected. Long-running
+  operations (deploy rollout polling, cloud builds) print each status
+  transition as a timestamped line instead of rendering nothing outside a
+  terminal. Cloud-build polling additionally reports build status changes.
+
+- Listings (`agent list`, `agent sessions`, `agent deployments`,
+  `secrets list`, `organizations list`, `organizations keys list`, `build
+  list`, `regions list`, and friends) render as tab-separated rows with
+  full, untruncated values in `plain` mode. Piped output previously fell
+  back to an 80-column table that silently ellipsized IDs.
+
+- `agent status` and `agent deployments` now show `Build: <build id>` for
+  cloud-built deployments instead of `Image: N/A`. Cloud builds produce an
+  image managed by Pipecat Cloud, so the build ID is the reference to use
+  when checking which artifact a deployment is running.
+
+### Changed
+
+- **The CLI now exits non-zero on failure.** Previously every error path
+  exited `0` — including failed deploys and running commands while logged
+  out — so CI pipelines could not detect failures. Errors and user
+  cancellations exit `1`; usage errors and refused non-interactive prompts
+  exit `2`. Pipelines that depended on the old always-zero behavior will
+  now correctly fail.
+
+- Commands that would show a confirmation prompt now fail fast with exit
+  code `2` when stdin is not a terminal, pointing at the bypass flag
+  (`--yes`/`--force`/`--skip`), instead of hanging or misbehaving in CI.
+
+- `organizations list` and `organizations keys create` label their
+  organization columns **Organization Name** (the display name) and
+  **Organization ID** (the identifier `--organization` takes), matching
+  the dashboard. The values are unchanged, as is `--output json`, which
+  emits the server's own field names. Scripts scraping the previous
+  `Organization` / `Name` headers out of table output need updating. In
+  `organizations list`, the active-organization marker moved to its own
+  `Active` column, so the ID column holds nothing but the identifier.
+
+- CLI messages call an organization an "organization" rather than a
+  "namespace". The Kubernetes namespace an organization maps to is an
+  implementation detail, so messages about missing agents, secret sets,
+  or accounts now name the organization. `organizations select` reports
+  an unmatched `--organization` value as an unknown organization ID and
+  points at `organizations list`.
+
+### Deprecated
+
+- `spend-limit show --json` still works but is now an alias for the global
+  `--output json` mode.
+
+### Fixed
+
+- `organizations keys create` no longer reports a new key as "Using as
+  default in local config" when it was not stored as the default. The
+  panel carries that note only when the key actually became the default.
+
 ## [1.0.1] - 2026-07-13
 
 ### Fixed

{pipecatcloud-1.0.1 → pipecatcloud-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 1.0.1
+Version: 1.2.0
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.ai/pipecat-cloud

{pipecatcloud-1.0.1 → pipecatcloud-1.2.0}/pyproject.toml

@@ -41,7 +41,7 @@ dev = [
     "pytest>=9.0.0,<10",
     "pytest-asyncio>=1.0.0,<2",
     "ruff>=0.12.11,<1",
-    "setuptools~=78.1.1",
+    "setuptools>=83.0.0,<84",
     "setuptools_scm~=8.3.1",
     # Needed to import/test pipecatcloud.agent (the optional pipecat surface).
     "pipecat-ai>=1.0.0",

{pipecatcloud-1.0.1 → pipecatcloud-1.2.0}/src/pipecatcloud/_utils/auth_utils.py

@@ -7,6 +7,7 @@
 import functools
 
 import aiohttp
+import typer
 
 from pipecatcloud.__version__ import version
 from pipecatcloud._utils.console_utils import console
@@ -46,7 +47,7 @@ def requires_login(func):
             console.error(
                 f"You are not logged in. Please run `{PIPECAT_CLI_NAME} auth login` first.",
             )
-            return
+            raise typer.Exit(1)
 
         # When org is not set locally (e.g. PIPECAT_TOKEN without a config file),
         # resolve the user's default organization from the API.
@@ -59,7 +60,7 @@ def requires_login(func):
                     "Could not determine your organization. "
                     f"Set PIPECAT_ORG or run `{PIPECAT_CLI_NAME} auth login`.",
                 )
-                return
+                raise typer.Exit(1)
 
         return await func(*args, **kwargs)
 

{pipecatcloud-1.0.1 → pipecatcloud-1.2.0}/src/pipecatcloud/_utils/console_utils.py

@@ -4,8 +4,11 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+import json
 import statistics
+import sys
 from datetime import datetime
+from enum import Enum
 
 from rich.console import Console
 from rich.panel import Panel
@@ -13,6 +16,65 @@ from rich.panel import Panel
 from pipecatcloud.cli import PANEL_TITLE_ERROR, PANEL_TITLE_SUCCESS, PIPECAT_CLI_NAME
 
 
+class OutputMode(str, Enum):
+    """How the CLI renders its output.
+
+    - ``rich``: panels, spinners, and tables (the interactive default)
+    - ``plain``: line-oriented output — no boxes, no spinners, no truncation
+    - ``json``: one machine-parseable JSON object on stdout; all human
+      output is redirected to stderr
+    """
+
+    rich = "rich"
+    plain = "plain"
+    json = "json"
+
+
+def stdin_is_interactive() -> bool:
+    """Whether we can prompt the user. Separate function so tests can patch it."""
+    try:
+        return sys.stdin.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
+class _PlainStatus:
+    """Drop-in replacement for rich's Status in non-interactive output.
+
+    Rich renders nothing from ``console.status(...)`` when stdout is not a
+    terminal, which left long-running operations (e.g. the up-to-600s deploy
+    poll loop) completely silent in CI. This sink prints each *distinct*
+    status message as a timestamped line instead, so piped output shows
+    every transition without spamming identical poll updates.
+    """
+
+    def __init__(self, console: "PipecatConsole", message: str | None = None):
+        self._console = console
+        self._last: str | None = None
+        self._stopped = False
+        if message:
+            self.update(message)
+
+    def update(self, status: str | None = None, **kwargs) -> None:
+        if not status or self._stopped or status == self._last:
+            return
+        self._last = status
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        self._console.print(rf"[dim]\[{timestamp}][/dim] {status}")
+
+    def start(self) -> None:
+        self._stopped = False
+
+    def stop(self) -> None:
+        self._stopped = True
+
+    def __enter__(self) -> "_PlainStatus":
+        return self
+
+    def __exit__(self, *_exc) -> None:
+        self.stop()
+
+
 def format_cents(cents: int | None) -> str:
     """Render a cents value as a USD dollar string (e.g. 1234 -> "$12.34").
 
@@ -28,6 +90,92 @@ def format_cents(cents: int | None) -> str:
 
 
 class PipecatConsole(Console):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # None means "auto": rich on a terminal, plain otherwise.
+        self._explicit_output_mode: OutputMode | None = None
+
+    @property
+    def output_mode(self) -> OutputMode:
+        if self._explicit_output_mode is not None:
+            return self._explicit_output_mode
+        return OutputMode.rich if self.is_terminal else OutputMode.plain
+
+    def set_output_mode(self, mode: OutputMode) -> None:
+        self._explicit_output_mode = mode
+        if mode == OutputMode.json:
+            # stdout is reserved for the single JSON payload; every human-facing
+            # write on this console moves to stderr so parsers see pure JSON.
+            self.file = sys.stderr
+
+    @property
+    def rich_output(self) -> bool:
+        return self.output_mode == OutputMode.rich
+
+    @property
+    def json_output(self) -> bool:
+        return self.output_mode == OutputMode.json
+
+    def output_json(self, data) -> None:
+        """Write the single machine-readable JSON object to stdout.
+
+        In json mode this console's own writes go to stderr, so this is the
+        only thing that touches stdout — parsers get pure JSON.
+        """
+        sys.stdout.write(json.dumps(data, indent=2, default=str) + "\n")
+        sys.stdout.flush()
+
+    def status(self, status, **kwargs):  # pyright: ignore[reportIncompatibleMethodOverride]
+        # Returns rich's Status in rich mode and a line-printing _PlainStatus
+        # otherwise; both expose update()/stop()/context-manager.
+        if self.rich_output:
+            return super().status(status, **kwargs)
+        return _PlainStatus(self, str(status))
+
+    def require_interactive(self, flag_hint: str | None = "--yes") -> None:
+        """Fail fast instead of letting a prompt hang or misbehave in CI.
+
+        Exits 2 (usage error) when a prompt would be shown but stdin is not a
+        terminal, pointing at the flag that skips the prompt when one exists.
+        """
+        import typer
+
+        if not stdin_is_interactive():
+            remedy = (
+                f"Pass [bold]{flag_hint}[/bold] to run non-interactively."
+                if flag_hint
+                else "This command requires an interactive terminal."
+            )
+            self.error(f"Confirmation required but input is not a terminal.\n{remedy}")
+            raise typer.Exit(2)
+
+    def print(self, *objects, **kwargs):
+        # In non-rich modes, never hard-wrap plain text lines: wrapped IDs and
+        # URIs are as unparseable as truncated ones.
+        if not self.rich_output and objects and all(isinstance(o, str) for o in objects):
+            kwargs.setdefault("soft_wrap", True)
+        return super().print(*objects, **kwargs)
+
+    def print_records(
+        self,
+        columns: list[str],
+        rows: list[tuple],
+        title: str | None = None,
+    ) -> None:
+        """Plain-mode listing: tab-separated, full values, no boxes.
+
+        Rich tables ellipsize cell values at 80 columns when piped, which
+        silently corrupts IDs consumed by scripts. Rows are written straight to
+        the output stream — bypassing Rich's tab expansion and line wrapping —
+        so the output stays greppable and `cut`-able.
+        """
+        if title:
+            self.print(title)
+        self.file.write("\t".join(columns) + "\n")
+        for row in rows:
+            self.file.write("\t".join("" if cell is None else str(cell) for cell in row) + "\n")
+        self.file.flush()
+
     def success(
         self,
         message,
@@ -38,6 +186,16 @@ class PipecatConsole(Console):
         if not title:
             title = f"{PANEL_TITLE_SUCCESS}{f' - {title_extra}' if title_extra is not None else ''}"
 
+        if not self.rich_output:
+            if isinstance(message, str):
+                self.print(f"[bold green]{title}:[/bold green] {message}")
+            else:
+                self.print(f"[bold green]{title}[/bold green]")
+                self.print(message)
+            if subtitle:
+                self.print(subtitle)
+            return
+
         self.print(
             Panel(
                 message,
@@ -59,6 +217,16 @@ class PipecatConsole(Console):
         if not title:
             title = f"{PANEL_TITLE_ERROR}{f' - {title_extra}' if title_extra is not None else ''}"
 
+        if not self.rich_output:
+            if isinstance(message, str):
+                self.print(f"[bold red]{title}:[/bold red] {message}")
+            else:
+                self.print(f"[bold red]{title}[/bold red]")
+                self.print(message)
+            if subtitle:
+                self.print(subtitle)
+            return
+
         self.print(
             Panel(
                 message,
@@ -74,9 +242,16 @@ class PipecatConsole(Console):
         self.print("[yellow]Cancelled by user[/yellow]")
 
     def unauthorized(self):
+        message = (
+            "Unauthorized request / invalid user token.\n\n"
+            f"Please log in again using [bold cyan]{PIPECAT_CLI_NAME} auth login[/bold cyan]"
+        )
+        if not self.rich_output:
+            self.error(message, title=f"{PANEL_TITLE_ERROR} - Unauthorized (401)")
+            return
         self.print(
             Panel(
-                f"Unauthorized request / invalid user token.\n\nPlease log in again using [bold cyan]{PIPECAT_CLI_NAME} auth login[/bold cyan]",
+                message,
                 title=f"[bold red]{PANEL_TITLE_ERROR} - Unauthorized (401)[/bold red]",
                 subtitle="",
                 title_align="left",
@@ -112,13 +287,22 @@ class PipecatConsole(Console):
         if not error_message:
             hide_subtitle = True
 
+        panel_title = f"{PANEL_TITLE_ERROR}{f' - {code}' if code else ''}"
+        subtitle = (
+            f"[dim]Docs: https://docs.pipecat.ai/pipecat-cloud/fundamentals/error-codes#{str(code).lower()}[/dim]"
+            if not hide_subtitle and code
+            else None
+        )
+
+        if not self.rich_output:
+            self.error(f"{title}: {error_message}", title=panel_title, subtitle=subtitle)
+            return
+
         self.print(
             Panel(
                 f"[red]{title}[/red]\n\n[dim]Error message:[/dim]\n{error_message}",
-                title=f"[bold red]{PANEL_TITLE_ERROR}{f' - {code}' if code else ''}[/bold red]",
-                subtitle=f"[dim]Docs: https://docs.pipecat.ai/pipecat-cloud/fundamentals/error-codes#{str(code).lower()}[/dim]"
-                if not hide_subtitle and code
-                else None,
+                title=f"[bold red]{panel_title}[/bold red]",
+                subtitle=subtitle,
                 title_align="left",
                 subtitle_align="left",
                 border_style="red",
@@ -158,6 +342,10 @@ class PipecatConsole(Console):
             f"Or visit [link={dashboard}]{dashboard}[/link]"
         )
 
+        if not self.rich_output:
+            self.error(body, title=f"{PANEL_TITLE_ERROR} - Spend limit reached (402)")
+            return
+
         self.print(
             Panel(
                 body,