pipecatcloud 0.2.18__tar.gz → 0.2.20__tar.gz

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.20] - 2026-02-11
+
+### Fixed
+
+- Fixed `auth login --headless` to be fully non-interactive by using plain text
+  output instead of Rich terminal widgets, enabling use in environments like
+  Claude Code and CI/CD pipelines.
+
+
+## [0.2.19] - 2026-01-27
+
+### Added
+
+- Added detailed session view with resource metrics. Use `pcc agent sessions <agent> --id <session-id>`
+  to see CPU and memory usage with sparkline visualizations and percentile summaries.
+
 ## [0.2.18] - 2026-01-06
 
 ### Added

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.18
+Version: 0.2.20
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/src/pipecatcloud/api.py

@@ -475,6 +475,20 @@ class _API:
     def agent_sessions(self):
         return self.create_api_method(self._agent_sessions)
 
+    async def _agent_session(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("GET", url, not_found_is_empty=True)
+
+    @property
+    def agent_session(self):
+        """Get details for a specific session including resource metrics.
+        Args:
+            agent_name: Name of the agent
+            session_id: ID of the session
+            org: Organization ID
+        """
+        return self.create_api_method(self._agent_session)
+
     async def _agent_session_terminate(
         self, agent_name: str, session_id: str, org: str
     ) -> dict | None:

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/src/pipecatcloud/cli/commands/agent.py

@@ -38,6 +38,46 @@ from pipecatcloud.constants import Region
 agent_cli = typer.Typer(name="agent", help="Agent management", no_args_is_help=True)
 
 
+def sparkline(values: list[int | float], max_width: int = 50) -> str:
+    """Generate Unicode sparkline from values, downsampling if needed."""
+    if not values:
+        return ""
+
+    # Downsample if too many values
+    if len(values) > max_width:
+        bucket_size = len(values) / max_width
+        downsampled = []
+        for i in range(max_width):
+            start = int(i * bucket_size)
+            end = int((i + 1) * bucket_size)
+            bucket = values[start:end]
+            downsampled.append(sum(bucket) / len(bucket) if bucket else 0)
+        values = downsampled
+
+    blocks = "▁▂▃▄▅▆▇█"
+    lo, hi = min(values), max(values)
+    if hi == lo:
+        return blocks[4] * len(values)  # flat line
+    scale = (hi - lo) / 7
+    return "".join(blocks[min(7, int((v - lo) / scale))] for v in values)
+
+
+def format_bytes(b: int) -> str:
+    """Format bytes as human-readable string."""
+    if b >= 1024 * 1024 * 1024:
+        return f"{b / (1024 * 1024 * 1024):.1f}GB"
+    if b >= 1024 * 1024:
+        return f"{b / (1024 * 1024):.0f}MB"
+    if b >= 1024:
+        return f"{b / 1024:.0f}KB"
+    return f"{b}B"
+
+
+def format_cpu(millicores: int) -> str:
+    """Format CPU millicores as human-readable string."""
+    return f"{millicores / 1000:.2f} cores"
+
+
 # ----- Agent Commands -----
 
 
@@ -292,6 +332,90 @@ async def sessions(
             console.error("No target agent name provided")
             return typer.Exit(1)
 
+    # If session_id is specified, fetch single session with detailed metrics
+    if session_id:
+        with Live(
+            console.status(f"[dim]Looking up session '{session_id}'[/dim]", spinner="dots")
+        ) as live:
+            data, error = await API.agent_session(
+                agent_name=agent_name, session_id=session_id, org=org, live=live
+            )
+            live.stop()
+
+            if error:
+                return typer.Exit()
+
+            if not data:
+                console.error(f"Session '{session_id}' not found")
+                return typer.Exit()
+
+            # Display detailed session view
+            session_duration = format_duration(data.get("createdAt"), data.get("endedAt")) or "N/A"
+            status = data.get("completionStatus", "")
+            if data.get("endedAt"):
+                status_display = "[red]Error (500)[/red]" if status == "500" else "Complete"
+            else:
+                status_display = "[yellow]Active[/yellow]"
+
+            # Build session info panel
+            info_lines = [
+                f"[bold]Session ID:[/bold] {data['sessionId']}",
+                f"[bold]Status:[/bold] {status_display}"
+                + (f" ({status})" if status and status != "500" else ""),
+                f"[bold]Duration:[/bold] {session_duration}",
+                f"[bold]Created:[/bold] {format_timestamp(data.get('createdAt'))}",
+                f"[bold]Ended:[/bold] {format_timestamp(data.get('endedAt')) if data.get('endedAt') else '[dim]N/A[/dim]'}",
+                f"[bold]Bot Start:[/bold] {data.get('botStartSeconds')}s"
+                if data.get("botStartSeconds") is not None
+                else "[bold]Bot Start:[/bold] [dim]N/A[/dim]",
+                f"[bold]Cold Start:[/bold] {'[red]Yes[/red]' if data.get('coldStart') else 'No'}",
+            ]
+
+            # Add resource metrics if available
+            metrics = data.get("resourceMetrics")
+            if metrics:
+                timeseries = metrics.get("timeseries", [])
+                sample_count = metrics.get("sampleCount", 0)
+
+                # Calculate duration from timeseries
+                if len(timeseries) >= 2:
+                    ts_duration = timeseries[-1].get("t", 0) - timeseries[0].get("t", 0)
+                    ts_duration_str = f"{ts_duration}s"
+                else:
+                    ts_duration_str = "N/A"
+
+                info_lines.append("")
+                info_lines.append(
+                    f"[bold]Resource Metrics[/bold] ({sample_count} samples over {ts_duration_str}):"
+                )
+
+                # CPU sparkline and percentiles
+                cpu_values = [s.get("c", 0) for s in timeseries]
+                cpu_spark = sparkline(cpu_values) if cpu_values else ""
+                cpu_p50 = metrics.get("cpuMillicoresP50", 0)
+                cpu_p99 = metrics.get("cpuMillicoresP99", 0)
+                info_lines.append(
+                    f"  CPU:    {cpu_spark}  p50: {format_cpu(cpu_p50)}  p99: {format_cpu(cpu_p99)}"
+                )
+
+                # Memory sparkline and percentiles
+                mem_values = [s.get("m", 0) for s in timeseries]
+                mem_spark = sparkline(mem_values) if mem_values else ""
+                mem_p50 = int(metrics.get("memoryBytesP50", 0))
+                mem_p99 = int(metrics.get("memoryBytesP99", 0))
+                info_lines.append(
+                    f"  Memory: {mem_spark}  p50: {format_bytes(mem_p50)}  p99: {format_bytes(mem_p99)}"
+                )
+
+            console.success(
+                Panel(
+                    "\n".join(info_lines),
+                    title=f"Session details for agent [bold]{agent_name}[/bold] [dim]({org})[/dim]",
+                    title_align="left",
+                ),
+            )
+            return
+
     with Live(
         console.status(f"[dim]Looking up agent with name '{agent_name}'[/dim]", spinner="dots")
     ) as live:

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/src/pipecatcloud/cli/commands/auth.py

@@ -161,17 +161,22 @@ async def login(
                 return
 
             # Display the authentication URL and code
-            console.print(
-                Panel(
-                    "[bold]To authenticate with Pipecat Cloud:[/bold]\n\n"
-                    "Visit this URL:\n"
-                    f"[blue][link={web_url}]{web_url}[/link][/blue]\n\n"
-                    "Then enter this code:\n"
-                    f"[cyan bold]{code}[/cyan bold]",
-                    title="[bold]Authentication Required[/bold]",
-                    border_style="blue",
+            if headless:
+                print("\nTo authenticate with Pipecat Cloud:\n", flush=True)
+                print(f"  Visit this URL: {web_url}", flush=True)
+                print(f"  Then enter this code: {code}\n", flush=True)
+            else:
+                console.print(
+                    Panel(
+                        "[bold]To authenticate with Pipecat Cloud:[/bold]\n\n"
+                        "Visit this URL:\n"
+                        f"[blue][link={web_url}]{web_url}[/link][/blue]\n\n"
+                        "Then enter this code:\n"
+                        f"[cyan bold]{code}[/cyan bold]",
+                        title="[bold]Authentication Required[/bold]",
+                        border_style="blue",
+                    )
                 )
-            )
 
             # Prompt user to open the browser (unless in headless mode)
             if not headless:
@@ -185,44 +190,76 @@ async def login(
                     return typer.Exit()
                 _open_url(web_url)
 
-            with Live(
-                console.status(
-                    "[dim]Waiting for authentication to complete...[/dim]", spinner="dots"
-                ),
-                transient=True,
-            ) as live:
+            if headless:
+                print("Waiting for authentication to complete...", flush=True)
                 for attempt in itertools.count():
                     result = await auth_flow.finish()
                     if result is not None:
                         break
-                    live.update(
-                        console.status(
-                            f"[dim]Waiting for authentication to complete... (attempt {attempt + 1})[/dim]"
-                        )
-                    )
                 if result is None:
-                    live.stop()
-                    console.error("Authentication failed")
+                    print("Error: Authentication failed", flush=True)
                     return typer.Exit()
 
-                live.update(console.status("[dim]Obtaining account data[/dim]", spinner="dots"))
+                print("Obtaining account data...", flush=True)
                 try:
                     account_name, account_name_verbose = await _get_account_org(result, active_org)
-                    live.stop()
                     logger.debug(f"Setting namespace to {account_name_verbose} ({account_name})")
                     if account_name is None:
                         raise
                 except Exception:
-                    live.stop()
-                    console.error(
-                        "Account has no associated namespace. Have you completed the onboarding process? Please first sign in via the web dashboard."
+                    print(
+                        "Error: Account has no associated namespace. "
+                        "Have you completed the onboarding process? "
+                        "Please first sign in via the web dashboard.",
+                        flush=True,
                     )
                     return typer.Exit()
 
-            console.success(
-                "Web authentication finished successfully!\n"
-                f"[dim]Account details stored to [magenta]{user_config_path}[/magenta][/dim]"
-            )
+                print("Web authentication finished successfully!", flush=True)
+                print(f"Account details stored to {user_config_path}", flush=True)
+            else:
+                with Live(
+                    console.status(
+                        "[dim]Waiting for authentication to complete...[/dim]", spinner="dots"
+                    ),
+                    transient=True,
+                ) as live:
+                    for attempt in itertools.count():
+                        result = await auth_flow.finish()
+                        if result is not None:
+                            break
+                        live.update(
+                            console.status(
+                                f"[dim]Waiting for authentication to complete... (attempt {attempt + 1})[/dim]"
+                            )
+                        )
+                    if result is None:
+                        live.stop()
+                        console.error("Authentication failed")
+                        return typer.Exit()
+
+                    live.update(console.status("[dim]Obtaining account data[/dim]", spinner="dots"))
+                    try:
+                        account_name, account_name_verbose = await _get_account_org(
+                            result, active_org
+                        )
+                        live.stop()
+                        logger.debug(
+                            f"Setting namespace to {account_name_verbose} ({account_name})"
+                        )
+                        if account_name is None:
+                            raise
+                    except Exception:
+                        live.stop()
+                        console.error(
+                            "Account has no associated namespace. Have you completed the onboarding process? Please first sign in via the web dashboard."
+                        )
+                        return typer.Exit()
+
+                console.success(
+                    "Web authentication finished successfully!\n"
+                    f"[dim]Account details stored to [magenta]{user_config_path}[/magenta][/dim]"
+                )
 
     except Exception as e:
         logger.debug(e)

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/src/pipecatcloud/cli/config.py

@@ -5,6 +5,8 @@
 #
 
 import os
+import stat
+import warnings
 from typing import Optional
 
 import toml
@@ -47,6 +49,18 @@ def _read_user_config():
 
             if not all(isinstance(e, dict) for e in org_sections.values()):
                 config_problem = "Pipecat Cloud config file is not valid TOML. Organization sections must be dictionaries. Please log out and log back in."
+
+            # Warn if credentials file is readable by group or others (Unix only).
+            if os.name != "nt":
+                file_mode = os.stat(user_config_path).st_mode
+                if file_mode & (stat.S_IRWXG | stat.S_IRWXO):
+                    warnings.warn(
+                        f"Credentials file '{user_config_path}' has overly permissive "
+                        f"permissions ({stat.filemode(file_mode)}). Other users on this "
+                        f"system may be able to read your token. Run "
+                        f"'chmod 600 {user_config_path}' to fix, or login again to repair automatically.",
+                        stacklevel=2,
+                    )
         if config_problem:
             raise ConfigError(config_problem)
 
@@ -63,6 +77,12 @@ def _write_user_config(new_config):
     with open(user_config_path, "w") as f:
         toml.dump(new_config, f)
 
+    # Restrict permissions so only the file owner can access credentials.
+    # On Windows os.chmod is limited but home directories are already
+    # protected by ACLs, so this is effectively a Unix-only hardening.
+    os.chmod(dir_path, stat.S_IRWXU)  # 0o700
+    os.chmod(user_config_path, stat.S_IRUSR | stat.S_IWUSR)  # 0o600
+
 
 def remove_user_config():
     os.remove(user_config_path)

{pipecatcloud-0.2.18 → pipecatcloud-0.2.20}/src/pipecatcloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.18
+Version: 0.2.20
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/