pdd-cli 0.0.90__py3-none-any.whl → 0.0.121__py3-none-any.whl

pdd/core/cloud.py

@@ -0,0 +1,237 @@
+"""
+Centralized cloud configuration for PDD CLI commands.
+
+Provides consistent cloud URL configuration and JWT token handling
+across all cloud-enabled commands (generate, fix, test, sync, etc.).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Optional
+
+from rich.console import Console
+
+from ..get_jwt_token import (
+    AuthError,
+    NetworkError,
+    RateLimitError,
+    TokenError,
+    UserCancelledError,
+    get_jwt_token as device_flow_get_token,
+)
+
+console = Console()
+
+# Environment variable names
+FIREBASE_API_KEY_ENV = "NEXT_PUBLIC_FIREBASE_API_KEY"
+GITHUB_CLIENT_ID_ENV = "GITHUB_CLIENT_ID"
+PDD_CLOUD_URL_ENV = "PDD_CLOUD_URL"
+PDD_JWT_TOKEN_ENV = "PDD_JWT_TOKEN"
+
+# Default cloud endpoints
+DEFAULT_BASE_URL = "https://us-central1-prompt-driven-development.cloudfunctions.net"
+
+# Endpoint paths (can be extended as more endpoints are added)
+CLOUD_ENDPOINTS = {
+    "generateCode": "/generateCode",
+    "generateExample": "/generateExample",
+    "generateTest": "/generateTest",
+    "generateBugTest": "/generateBugTest",
+    "fixCode": "/fixCode",
+    "crashCode": "/crashCode",
+    "verifyCode": "/verifyCode",
+    "syncState": "/syncState",
+    "trackUsage": "/trackUsage",
+    "getCreditBalance": "/getCreditBalance",
+    "llmInvoke": "/llmInvoke",
+    # Remote session endpoints
+    "registerSession": "/registerSession",
+    "listSessions": "/listSessions",
+    "heartbeatSession": "/heartbeatSession",
+    "deregisterSession": "/deregisterSession",
+    # Command relay endpoints (Firestore message bus)
+    "getCommands": "/getCommands",
+    "getCommandStatus": "/getCommandStatus",
+    "updateCommand": "/updateCommand",
+    "cancelCommand": "/cancelCommand",
+}
+
+
+class CloudConfig:
+    """Centralized cloud configuration for all PDD commands."""
+
+    @staticmethod
+    def _ensure_default_env() -> None:
+        """Default PDD_ENV for CLI usage when unset."""
+        if os.environ.get("PDD_ENV"):
+            return
+
+        # Local/emulator signals should keep PDD_ENV local.
+        if (os.environ.get("FUNCTIONS_EMULATOR") or
+                os.environ.get("FIREBASE_AUTH_EMULATOR_HOST") or
+                os.environ.get("FIREBASE_EMULATOR_HUB")):
+            os.environ["PDD_ENV"] = "local"
+            return
+
+        cloud_url = (os.environ.get(PDD_CLOUD_URL_ENV) or "").lower()
+        if cloud_url:
+            if any(host in cloud_url for host in ("localhost", "127.0.0.1", "0.0.0.0")):
+                os.environ["PDD_ENV"] = "local"
+                return
+            if "prompt-driven-development-stg" in cloud_url or "staging" in cloud_url:
+                os.environ["PDD_ENV"] = "staging"
+                return
+
+        # Default to production for typical CLI usage.
+        os.environ["PDD_ENV"] = "prod"
+
+    @staticmethod
+    def get_base_url() -> str:
+        """Get cloud base URL, allowing override via PDD_CLOUD_URL.
+
+        For testing against different environments:
+        - Local emulator: http://127.0.0.1:5555/prompt-driven-development/us-central1
+        - Staging: https://us-central1-prompt-driven-development-stg.cloudfunctions.net
+        - Production: (default) https://us-central1-prompt-driven-development.cloudfunctions.net
+        """
+        custom_url = os.environ.get(PDD_CLOUD_URL_ENV)
+        if custom_url:
+            # If full URL provided (with endpoint), extract base
+            # If base URL provided, use as-is
+            return custom_url.rstrip("/")
+        return DEFAULT_BASE_URL
+
+    @staticmethod
+    def get_endpoint_url(endpoint_name: str) -> str:
+        """Get full URL for a specific cloud endpoint.
+
+        Args:
+            endpoint_name: Name of endpoint (e.g., 'generateCode', 'syncState')
+
+        Returns:
+            Full URL for the endpoint
+        """
+        base = CloudConfig.get_base_url()
+
+        # Check if PDD_CLOUD_URL already includes the endpoint
+        custom_url = os.environ.get(PDD_CLOUD_URL_ENV, "")
+        if endpoint_name in custom_url:
+            return custom_url
+
+        path = CLOUD_ENDPOINTS.get(endpoint_name, f"/{endpoint_name}")
+        return f"{base}{path}"
+
+    @staticmethod
+    def get_jwt_token(
+        verbose: bool = False,
+        app_name: str = "PDD Code Generator"
+    ) -> Optional[str]:
+        """Get JWT token for cloud authentication.
+
+        Checks PDD_JWT_TOKEN environment variable first (for testing/CI),
+        then falls back to interactive device flow authentication.
+
+        Args:
+            verbose: Whether to print status messages
+            app_name: Application name for device flow
+
+        Returns:
+            JWT token string, or None if authentication failed
+
+        Note:
+            Callers should handle None return by falling back to local execution.
+        """
+        # Default env to prod for typical CLI usage (unless emulator/custom URL says otherwise).
+        CloudConfig._ensure_default_env()
+
+        # Check for pre-injected token (testing/CI)
+        injected_token = os.environ.get(PDD_JWT_TOKEN_ENV)
+        if injected_token:
+            if verbose:
+                console.print(f"[info]Using injected JWT token from {PDD_JWT_TOKEN_ENV}[/info]")
+            return injected_token
+
+        # Standard device flow authentication
+        try:
+            firebase_api_key = os.environ.get(FIREBASE_API_KEY_ENV)
+            github_client_id = os.environ.get(GITHUB_CLIENT_ID_ENV)
+
+            if not firebase_api_key:
+                raise AuthError(f"{FIREBASE_API_KEY_ENV} not set.")
+            if not github_client_id:
+                raise AuthError(f"{GITHUB_CLIENT_ID_ENV} not set.")
+
+            return asyncio.run(device_flow_get_token(
+                firebase_api_key=firebase_api_key,
+                github_client_id=github_client_id,
+                app_name=app_name
+            ))
+        except (AuthError, NetworkError, TokenError, UserCancelledError, RateLimitError) as e:
+            # Always display auth errors (both these expected ones and the unexpected ones handled below) - critical for debugging auth issues
+            console.print(f"[yellow]Cloud authentication error: {e}[/yellow]")
+            return None
+        except Exception as e:
+            # Always display unexpected errors too
+            console.print(f"[yellow]Unexpected auth error: {e}[/yellow]")
+            return None
+
+    @staticmethod
+    def is_running_in_cloud() -> bool:
+        """Check if we're running inside a cloud environment.
+
+        Detects Google Cloud Functions/Cloud Run via K_SERVICE env var,
+        or local emulator via FUNCTIONS_EMULATOR. This prevents infinite
+        loops when cloud endpoints call the CLI internally.
+        """
+        return bool(
+            os.environ.get("K_SERVICE") or
+            os.environ.get("FUNCTIONS_EMULATOR")
+        )
+
+    @staticmethod
+    def is_cloud_enabled() -> bool:
+        """Check if cloud features are available.
+
+        Cloud is enabled if:
+        1. PDD_FORCE_LOCAL is NOT set (respects --local flag), AND
+        2. NOT already running inside a cloud environment (prevents infinite loops), AND
+        3. Either:
+           a. PDD_JWT_TOKEN is set (injected token for testing/CI), OR
+           b. Both FIREBASE_API_KEY and GITHUB_CLIENT_ID are set (for device flow auth)
+        """
+        # Respect --local flag (sets PDD_FORCE_LOCAL=1)
+        if os.environ.get("PDD_FORCE_LOCAL"):
+            return False
+
+        # CRITICAL: Never enable cloud mode when already running in cloud
+        # This prevents infinite loops when cloud endpoints call CLI internally
+        if CloudConfig.is_running_in_cloud():
+            return False
+
+        # Check for injected token first (testing/CI scenario)
+        if os.environ.get(PDD_JWT_TOKEN_ENV):
+            return True
+        # Check for device flow auth credentials
+        return bool(
+            os.environ.get(FIREBASE_API_KEY_ENV) and
+            os.environ.get(GITHUB_CLIENT_ID_ENV)
+        )
+
+
+# Re-export exception classes for convenience
+__all__ = [
+    'CloudConfig',
+    'AuthError',
+    'NetworkError',
+    'TokenError',
+    'UserCancelledError',
+    'RateLimitError',
+    'FIREBASE_API_KEY_ENV',
+    'GITHUB_CLIENT_ID_ENV',
+    'PDD_CLOUD_URL_ENV',
+    'PDD_JWT_TOKEN_ENV',
+    'DEFAULT_BASE_URL',
+    'CLOUD_ENDPOINTS',
+]

pdd/core/dump.py

@@ -16,6 +16,43 @@ import requests
 from .. import __version__
 from .errors import console, get_core_dump_errors
 
+
+def garbage_collect_core_dumps(keep: int = 10) -> int:
+    """Delete old core dumps, keeping only the most recent `keep` files.
+
+    Core dumps are sorted by modification time (mtime), and the oldest
+    files beyond the `keep` limit are deleted.
+
+    Args:
+        keep: Number of core dump files to keep. Default is 10.
+
+    Returns:
+        The number of deleted files.
+    """
+    core_dump_dir = Path.cwd() / ".pdd" / "core_dumps"
+    if not core_dump_dir.exists():
+        return 0
+
+    # Find all core dump files and sort by mtime (newest first)
+    dumps = sorted(
+        core_dump_dir.glob("pdd-core-*.json"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True
+    )
+
+    # Delete files beyond the keep limit
+    deleted = 0
+    for dump_file in dumps[keep:]:
+        try:
+            dump_file.unlink()
+            deleted += 1
+        except OSError:
+            # If we can't delete a file, just skip it
+            pass
+
+    return deleted
+
+
 def _write_core_dump(
     ctx: click.Context,
     normalized_results: List[Any],
@@ -70,8 +107,8 @@ def _write_core_dump(
         file_contents = {}
         core_dump_files = ctx.obj.get("core_dump_files", set())
 
-        if not ctx.obj.get("quiet"):
-            console.print(f"[info]Core dump: Found {len(core_dump_files)} tracked files[/info]")
+        if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+            console.print(f"[info]Debug snapshot: Found {len(core_dump_files)} tracked files[/info]")
 
         # Auto-include relevant meta files for the invoked commands
         meta_dir = Path.cwd() / ".pdd" / "meta"
@@ -100,8 +137,8 @@ def _write_core_dump(
         for file_path in core_dump_files:
             try:
                 path = Path(file_path)
-                if not ctx.obj.get("quiet"):
-                    console.print(f"[info]Core dump: Checking file {file_path}[/info]")
+                if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                    console.print(f"[info]Debug snapshot: Checking file {file_path}[/info]")
 
                 if path.exists() and path.is_file():
                     if path.stat().st_size < 50000:  # 50KB limit
@@ -113,23 +150,23 @@ def _write_core_dump(
                                 key = str(path)
 
                             file_contents[key] = path.read_text(encoding='utf-8')
-                            if not ctx.obj.get("quiet"):
-                                console.print(f"[info]Core dump: Added content for {key}[/info]")
+                            if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                                console.print(f"[info]Debug snapshot: Added content for {key}[/info]")
                         except UnicodeDecodeError:
                             file_contents[str(path)] = "<binary>"
-                            if not ctx.obj.get("quiet"):
-                                console.print(f"[warning]Core dump: Binary file {path}[/warning]")
+                            if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                                console.print(f"[warning]Debug snapshot: Binary file {path}[/warning]")
                     else:
                         file_contents[str(path)] = "<too large>"
-                        if not ctx.obj.get("quiet"):
-                            console.print(f"[warning]Core dump: File too large {path}[/warning]")
+                        if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                            console.print(f"[warning]Debug snapshot: File too large {path}[/warning]")
                 else:
-                    if not ctx.obj.get("quiet"):
-                        console.print(f"[warning]Core dump: File not found or not a file: {file_path}[/warning]")
+                    if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                        console.print(f"[warning]Debug snapshot: File not found or not a file: {file_path}[/warning]")
             except Exception as e:
                 file_contents[str(file_path)] = f"<error reading file: {e}>"
-                if not ctx.obj.get("quiet"):
-                    console.print(f"[warning]Core dump: Error reading {file_path}: {e}[/warning]")
+                if ctx.obj.get("verbose") and not ctx.obj.get("quiet"):
+                    console.print(f"[warning]Debug snapshot: Error reading {file_path}: {e}[/warning]")
 
         payload: Dict[str, Any] = {
             "schema_version": 1,
@@ -166,15 +203,26 @@ def _write_core_dump(
 
         dump_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
 
+        # Garbage collect old core dumps after writing (Issue #231)
+        # This ensures we keep at most N dumps, not N+1
+        keep_core_dumps = ctx.obj.get("keep_core_dumps", 10)
+        garbage_collect_core_dumps(keep=keep_core_dumps)
+
         if not ctx.obj.get("quiet"):
-            console.print(
-                f"[info]Core dump written to [path]{dump_path}[/path]. "
-                "You can attach this file when reporting a bug.[/info]"
-            )
+            # Check if the dump still exists after GC (may be deleted if keep=0)
+            if dump_path.exists():
+                console.print(
+                    f"[info]📦 Debug snapshot saved to [path]{dump_path}[/path] "
+                    "(attach when reporting bugs)[/info]"
+                )
+            else:
+                console.print(
+                    "[info]📦 Debug snapshot saved and immediately cleaned up (--keep-core-dumps=0)[/info]"
+                )
     except Exception as exc:
-        # Never let core dumping itself crash the CLI
+        # Never let debug snapshot creation crash the CLI
         if not ctx.obj.get("quiet"):
-            console.print(f"[warning]Failed to write core dump: {exc}[/warning]", style="warning")
+            console.print(f"[warning]Failed to write debug snapshot: {exc}[/warning]", style="warning")
 
 
 def _get_github_token() -> Optional[str]:

pdd/core/errors.py

@@ -1,6 +1,7 @@
 """
 Error handling logic for PDD CLI.
 """
+import os
 import traceback
 from typing import Any, Dict, List
 import click
@@ -60,4 +61,7 @@ def handle_error(exception: Exception, command_name: str, quiet: bool):
             console.print(escape(str(exception)))
         else:
             console.print(f"  [error]An unexpected error occurred:[/error] {exception}", style="error")
+    strict_exit = os.environ.get("PDD_STRICT_EXIT", "").strip().lower() in {"1", "true", "yes", "on"}
+    if strict_exit:
+        raise SystemExit(1)
     # Do NOT re-raise e here. Let the command function return None.

pdd/core/remote_session.py

@@ -0,0 +1,61 @@
+"""
+Utility to detect if running in a remote/SSH session or headless environment.
+"""
+import os
+import sys
+from typing import Optional, Tuple
+
+
+def is_remote_session() -> Tuple[bool, str]:
+    """
+    Detect if the current session is remote (SSH) or headless.
+
+    Returns:
+        Tuple[bool, str]: (is_remote, reason) where reason explains why
+
+    Detection criteria:
+    1. SSH environment variables (SSH_CONNECTION, SSH_CLIENT, SSH_TTY)
+    2. DISPLAY not set (headless Linux/Unix)
+    3. WSL without WSLg (Windows Subsystem for Linux)
+    """
+    # Check SSH environment variables
+    if os.environ.get("SSH_CONNECTION"):
+        return True, "SSH_CONNECTION environment variable detected"
+    if os.environ.get("SSH_CLIENT"):
+        return True, "SSH_CLIENT environment variable detected"
+    if os.environ.get("SSH_TTY"):
+        return True, "SSH_TTY environment variable detected"
+
+    # Check for headless environment (no DISPLAY on Unix/Linux)
+    if sys.platform in ("linux", "linux2") or sys.platform == "darwin":
+        if not os.environ.get("DISPLAY"):
+            return True, "No DISPLAY environment variable (headless)"
+
+    # Check for WSL without WSLg (older WSL versions)
+    if os.environ.get("WSL_DISTRO_NAME") and not os.environ.get("WAYLAND_DISPLAY"):
+        return True, "WSL environment without display server"
+
+    return False, "Local session with display capability"
+
+
+def should_skip_browser(explicit_flag: Optional[bool] = None) -> Tuple[bool, str]:
+    """
+    Determine if browser opening should be skipped.
+
+    Args:
+        explicit_flag: True to force browser, False to force no-browser, None to auto-detect
+
+    Returns:
+        Tuple[bool, str]: (skip_browser, reason)
+    """
+    if explicit_flag is True:
+        return False, "User explicitly requested browser opening (--browser flag)"
+    if explicit_flag is False:
+        return True, "User explicitly requested no browser (--no-browser flag)"
+
+    # Auto-detect
+    is_remote, reason = is_remote_session()
+    if is_remote:
+        return True, f"Auto-detected remote session: {reason}"
+
+    return False, "Local session detected, will attempt browser opening"