shotgun-sh 0.1.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

shotgun/sentry_telemetry.py

@@ -1,8 +1,10 @@
 """Sentry observability setup for Shotgun."""
 
-import os
+from typing import Any
 
+from shotgun import __version__
 from shotgun.logging_config import get_early_logger
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -22,35 +24,37 @@ def setup_sentry_observability() -> bool:
             logger.debug("Sentry is already initialized, skipping")
             return True
 
-        # Try to get DSN from build constants first (production builds)
-        dsn = None
-        try:
-            from shotgun import build_constants
-
-            dsn = build_constants.SENTRY_DSN
-            logger.debug("Using Sentry DSN from build constants")
-        except ImportError:
-            # Fallback to environment variable (development)
-            dsn = os.getenv("SENTRY_DSN", "")
-            if dsn:
-                logger.debug("Using Sentry DSN from environment variable")
+        # Get DSN from settings (handles build constants + env vars automatically)
+        dsn = settings.telemetry.sentry_dsn
 
         if not dsn:
             logger.debug("No Sentry DSN configured, skipping Sentry initialization")
             return False
 
-        logger.debug("Found DSN, proceeding with Sentry setup")
-
-        # Get version for release tracking
-        from shotgun import __version__
+        logger.debug("Using Sentry DSN from settings, proceeding with setup")
 
         # Determine environment based on version
-        # Dev versions contain "dev", "rc", "alpha", or "beta"
+        # Dev versions contain "dev", "rc", "alpha", "beta"
         if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
             environment = "development"
         else:
             environment = "production"
 
+        def before_send(event: Any, hint: dict[str, Any]) -> Any:
+            """Filter out user-actionable errors from Sentry.
+
+            User-actionable errors (like context size limits) are expected conditions
+            that users need to resolve, not bugs that need tracking.
+            """
+            if "exc_info" in hint:
+                exc_type, exc_value, tb = hint["exc_info"]
+                from shotgun.exceptions import ErrorNotPickedUpBySentry
+
+                if isinstance(exc_value, ErrorNotPickedUpBySentry):
+                    # Don't send to Sentry - this is user-actionable, not a bug
+                    return None
+            return event
+
         # Initialize Sentry
         sentry_sdk.init(
             dsn=dsn,
@@ -59,15 +63,18 @@ def setup_sentry_observability() -> bool:
             send_default_pii=False,  # Privacy-first: never send PII
             traces_sample_rate=0.1 if environment == "production" else 1.0,
             profiles_sample_rate=0.1 if environment == "production" else 1.0,
+            before_send=before_send,
         )
 
-        # Set user context with anonymous user ID from config
+        # Set user context with anonymous shotgun instance ID from config
         try:
+            import asyncio
+
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
-            sentry_sdk.set_user({"id": user_id})
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
+            sentry_sdk.set_user({"id": shotgun_instance_id})
             logger.debug("Sentry user context set with anonymous ID")
         except Exception as e:
             logger.warning("Failed to set Sentry user context: %s", e)

shotgun/settings.py

@@ -0,0 +1,238 @@
+"""Centralized application settings using Pydantic Settings.
+
+All environment variables use the SHOTGUN_ prefix to avoid conflicts with other tools.
+Settings are loaded with the following priority:
+1. Environment variables (highest priority)
+2. Build constants (embedded at build time)
+3. Default values (lowest priority)
+
+Example usage:
+    from shotgun.settings import settings
+
+    # Access telemetry settings
+    if settings.telemetry.sentry_dsn:
+        sentry_sdk.init(dsn=settings.telemetry.sentry_dsn)
+
+    # Access logging settings
+    logger.setLevel(settings.logging.log_level)
+
+    # Access API settings
+    response = httpx.get(settings.api.web_base_url)
+"""
+
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _get_build_constant(name: str, default: Any = None) -> Any:
+    """Get a value from build_constants.py, falling back to default.
+
+    Args:
+        name: The constant name to retrieve (e.g., "SENTRY_DSN")
+        default: Default value if constant not found
+
+    Returns:
+        The constant value, or default if not found/import fails
+    """
+    try:
+        from shotgun import build_constants
+
+        return getattr(build_constants, name, default)
+    except ImportError:
+        return default
+
+
+class TelemetrySettings(BaseSettings):
+    """Telemetry and observability settings.
+
+    These settings control error tracking (Sentry), analytics (PostHog),
+    and observability (Logfire) integrations.
+    """
+
+    sentry_dsn: str = Field(
+        default_factory=lambda: _get_build_constant("SENTRY_DSN", ""),
+        description="Sentry DSN for error tracking",
+    )
+    posthog_api_key: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_API_KEY", ""),
+        description="PostHog API key for analytics",
+    )
+    posthog_project_id: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_PROJECT_ID", ""),
+        description="PostHog project ID",
+    )
+    logfire_enabled: bool = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_ENABLED", False),
+        description="Enable Logfire observability (dev builds only)",
+    )
+    logfire_token: str = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_TOKEN", ""),
+        description="Logfire authentication token",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("logfire_enabled", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class LoggingSettings(BaseSettings):
+    """Logging configuration settings.
+
+    Controls log level, console output, and file logging behavior.
+    """
+
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+    logging_to_console: bool = Field(
+        default=False,
+        description="Enable console logging output",
+    )
+    logging_to_file: bool = Field(
+        default=True,
+        description="Enable file logging output",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("log_level")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level is one of the allowed values."""
+        v = v.upper()
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if v not in valid_levels:
+            return "INFO"  # Default to INFO if invalid
+        return v
+
+    @field_validator("logging_to_console", "logging_to_file", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class ApiSettings(BaseSettings):
+    """API endpoint settings.
+
+    Configuration for Shotgun backend services.
+    """
+
+    web_base_url: str = Field(
+        default="https://api-219702594231.us-east4.run.app",
+        description="Shotgun Web API base URL (authentication/subscription)",
+    )
+    account_llm_base_url: str = Field(
+        default="https://litellm-219702594231.us-east4.run.app",
+        description="Shotgun's LiteLLM proxy base URL (AI model requests)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+class DevelopmentSettings(BaseSettings):
+    """Development and testing settings.
+
+    These settings are primarily used for testing and development purposes.
+    """
+
+    home: str | None = Field(
+        default=None,
+        description="Override Shotgun home directory (for testing)",
+    )
+    pipx_simulate: bool = Field(
+        default=False,
+        description="Simulate pipx installation (for testing)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("pipx_simulate", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class Settings(BaseSettings):
+    """Main application settings with SHOTGUN_ prefix.
+
+    This is the main settings class that composes all other settings groups.
+    Access settings via the global `settings` singleton instance.
+
+    Example:
+        from shotgun.settings import settings
+
+        # Telemetry settings
+        settings.telemetry.sentry_dsn
+        settings.telemetry.posthog_api_key
+        settings.telemetry.logfire_enabled
+
+        # Logging settings
+        settings.logging.log_level
+        settings.logging.logging_to_console
+
+        # API settings
+        settings.api.web_base_url
+        settings.api.account_llm_base_url
+
+        # Development settings
+        settings.dev.home
+        settings.dev.pipx_simulate
+    """
+
+    telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    api: ApiSettings = Field(default_factory=ApiSettings)
+    dev: DevelopmentSettings = Field(default_factory=DevelopmentSettings)
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+# Global settings singleton
+# Import this in your modules: from shotgun.settings import settings
+settings = Settings()

shotgun/shotgun_web/__init__.py

@@ -0,0 +1,19 @@
+"""Shotgun Web API client for subscription and authentication."""
+
+from .client import ShotgunWebClient, check_token_status, create_unification_token
+from .models import (
+    TokenCreateRequest,
+    TokenCreateResponse,
+    TokenStatus,
+    TokenStatusResponse,
+)
+
+__all__ = [
+    "ShotgunWebClient",
+    "create_unification_token",
+    "check_token_status",
+    "TokenCreateRequest",
+    "TokenCreateResponse",
+    "TokenStatus",
+    "TokenStatusResponse",
+]

shotgun/shotgun_web/client.py

@@ -0,0 +1,138 @@
+"""HTTP client for Shotgun Web API."""
+
+import httpx
+
+from shotgun.logging_config import get_logger
+
+from .constants import (
+    SHOTGUN_WEB_BASE_URL,
+    UNIFICATION_TOKEN_CREATE_PATH,
+    UNIFICATION_TOKEN_STATUS_PATH,
+)
+from .models import (
+    TokenCreateRequest,
+    TokenCreateResponse,
+    TokenStatusResponse,
+)
+
+logger = get_logger(__name__)
+
+
+class ShotgunWebClient:
+    """HTTP client for Shotgun Web API."""
+
+    def __init__(self, base_url: str | None = None, timeout: float = 10.0):
+        """Initialize Shotgun Web client.
+
+        Args:
+            base_url: Base URL for Shotgun Web API. If None, uses SHOTGUN_WEB_BASE_URL
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url or SHOTGUN_WEB_BASE_URL
+        self.timeout = timeout
+
+    def create_unification_token(self, shotgun_instance_id: str) -> TokenCreateResponse:
+        """Create a unification token for CLI authentication.
+
+        Args:
+            shotgun_instance_id: UUID for this shotgun instance
+
+        Returns:
+            Token creation response with token and auth URL
+
+        Raises:
+            httpx.HTTPError: If request fails
+        """
+        url = f"{self.base_url}{UNIFICATION_TOKEN_CREATE_PATH}"
+        request_data = TokenCreateRequest(shotgun_instance_id=shotgun_instance_id)
+
+        logger.debug("Creating unification token for instance %s", shotgun_instance_id)
+
+        try:
+            response = httpx.post(
+                url,
+                json=request_data.model_dump(),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            result = TokenCreateResponse.model_validate(data)
+
+            logger.info(
+                "Successfully created unification token, expires in %d seconds",
+                result.expires_in_seconds,
+            )
+            return result
+
+        except httpx.HTTPError as e:
+            logger.error("Failed to create unification token: %s", e)
+            raise
+
+    def check_token_status(self, token: str) -> TokenStatusResponse:
+        """Check token status and get keys if completed.
+
+        Args:
+            token: Unification token to check
+
+        Returns:
+            Token status response with status and keys (if completed)
+
+        Raises:
+            httpx.HTTPStatusError: If token not found (404) or expired (410)
+            httpx.HTTPError: For other request failures
+        """
+        url = f"{self.base_url}{UNIFICATION_TOKEN_STATUS_PATH.format(token=token)}"
+
+        logger.debug("Checking status for token %s...", token[:8])
+
+        try:
+            response = httpx.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            data = response.json()
+            result = TokenStatusResponse.model_validate(data)
+
+            logger.debug("Token status: %s", result.status)
+            return result
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                logger.error("Token not found: %s", token[:8])
+            elif e.response.status_code == 410:
+                logger.error("Token expired: %s", token[:8])
+            raise
+        except httpx.HTTPError as e:
+            logger.error("Failed to check token status: %s", e)
+            raise
+
+
+# Convenience functions for standalone use
+def create_unification_token(shotgun_instance_id: str) -> TokenCreateResponse:
+    """Create a unification token.
+
+    Convenience function that creates a client and calls create_unification_token.
+
+    Args:
+        shotgun_instance_id: UUID for this shotgun instance
+
+    Returns:
+        Token creation response
+    """
+    client = ShotgunWebClient()
+    return client.create_unification_token(shotgun_instance_id)
+
+
+def check_token_status(token: str) -> TokenStatusResponse:
+    """Check token status.
+
+    Convenience function that creates a client and calls check_token_status.
+
+    Args:
+        token: Unification token to check
+
+    Returns:
+        Token status response
+    """
+    client = ShotgunWebClient()
+    return client.check_token_status(token)

shotgun/shotgun_web/constants.py

@@ -0,0 +1,21 @@
+"""Constants for Shotgun Web API."""
+
+# Import from centralized API endpoints module
+from shotgun.api_endpoints import SHOTGUN_WEB_BASE_URL
+
+# API endpoints
+UNIFICATION_TOKEN_CREATE_PATH = "/api/unification/token/create"  # noqa: S105
+UNIFICATION_TOKEN_STATUS_PATH = "/api/unification/token/{token}/status"  # noqa: S105
+
+# Polling configuration
+DEFAULT_POLL_INTERVAL_SECONDS = 3
+DEFAULT_TOKEN_TIMEOUT_SECONDS = 1800  # 30 minutes
+
+# Re-export for backward compatibility
+__all__ = [
+    "SHOTGUN_WEB_BASE_URL",
+    "UNIFICATION_TOKEN_CREATE_PATH",
+    "UNIFICATION_TOKEN_STATUS_PATH",
+    "DEFAULT_POLL_INTERVAL_SECONDS",
+    "DEFAULT_TOKEN_TIMEOUT_SECONDS",
+]

shotgun/shotgun_web/models.py

@@ -0,0 +1,47 @@
+"""Pydantic models for Shotgun Web API."""
+
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class TokenStatus(StrEnum):
+    """Token status enum matching API specification."""
+
+    PENDING = "pending"
+    COMPLETED = "completed"
+    AWAITING_PAYMENT = "awaiting_payment"
+    EXPIRED = "expired"
+
+
+class TokenCreateRequest(BaseModel):
+    """Request model for creating a unification token."""
+
+    shotgun_instance_id: str = Field(
+        description="CLI-provided UUID for shotgun instance"
+    )
+
+
+class TokenCreateResponse(BaseModel):
+    """Response model for token creation."""
+
+    token: str = Field(description="Secure authentication token")
+    auth_url: str = Field(description="Web authentication URL for user to complete")
+    expires_in_seconds: int = Field(description="Token expiration time in seconds")
+
+
+class TokenStatusResponse(BaseModel):
+    """Response model for token status check."""
+
+    status: TokenStatus = Field(description="Current token status")
+    supabase_key: str | None = Field(
+        default=None,
+        description="Supabase user JWT (only returned when status=completed)",
+    )
+    litellm_key: str | None = Field(
+        default=None,
+        description="LiteLLM virtual key (only returned when status=completed)",
+    )
+    message: str | None = Field(
+        default=None, description="Human-readable status message"
+    )

shotgun/telemetry.py

@@ -1,9 +1,7 @@
 """Observability setup for Logfire."""
 
-import os
-
 from shotgun.logging_config import get_early_logger
-from shotgun.utils.env_utils import is_falsy, is_truthy
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -15,36 +13,13 @@ def setup_logfire_observability() -> bool:
     Returns:
         True if Logfire was successfully set up, False otherwise
     """
-    # Try to get Logfire configuration from build constants first, fall back to env vars
-    logfire_enabled = None
-    logfire_token = None
-
-    try:
-        from shotgun.build_constants import LOGFIRE_ENABLED, LOGFIRE_TOKEN
-
-        # Use build constants if they're not empty
-        if LOGFIRE_ENABLED:
-            logfire_enabled = LOGFIRE_ENABLED
-        if LOGFIRE_TOKEN:
-            logfire_token = LOGFIRE_TOKEN
-    except ImportError:
-        # No build constants available
-        pass
-
-    # Fall back to environment variables if not set from build constants
-    if not logfire_enabled:
-        logfire_enabled = os.getenv("LOGFIRE_ENABLED", "false")
-    if not logfire_token:
-        logfire_token = os.getenv("LOGFIRE_TOKEN")
-
-    # Allow environment variable to override and disable Logfire
-    env_override = os.getenv("LOGFIRE_ENABLED")
-    if env_override and is_falsy(env_override):
-        logfire_enabled = env_override
+    # Get Logfire configuration from settings (handles build constants + env vars)
+    logfire_enabled = settings.telemetry.logfire_enabled
+    logfire_token = settings.telemetry.logfire_token
 
     # Check if Logfire observability is enabled
-    if not is_truthy(logfire_enabled):
-        logger.debug("Logfire observability disabled via LOGFIRE_ENABLED")
+    if not logfire_enabled:
+        logger.debug("Logfire observability disabled")
         return False
 
     try:
@@ -52,7 +27,7 @@ def setup_logfire_observability() -> bool:
 
         # Check for Logfire token
         if not logfire_token:
-            logger.warning("LOGFIRE_TOKEN not set, Logfire observability disabled")
+            logger.warning("Logfire token not set, Logfire observability disabled")
             return False
 
         # Configure Logfire
@@ -65,19 +40,32 @@ def setup_logfire_observability() -> bool:
         # Instrument Pydantic AI for better observability
         logfire.instrument_pydantic_ai()
 
+        # Add LogfireLoggingHandler to root logger so logfire logs also go to file
+        import logging
+
+        root_logger = logging.getLogger()
+        logfire_handler = logfire.LogfireLoggingHandler()
+        root_logger.addHandler(logfire_handler)
+        logger.debug("Added LogfireLoggingHandler to root logger for file integration")
+
         # Set user context using baggage for all logs and spans
         try:
+            import asyncio
+
             from opentelemetry import baggage, context
 
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
-            # Set user_id as baggage in global context - this will be included in all logs/spans
-            ctx = baggage.set_baggage("user_id", user_id)
+            # Set shotgun_instance_id as baggage in global context - this will be included in all logs/spans
+            ctx = baggage.set_baggage("shotgun_instance_id", shotgun_instance_id)
             context.attach(ctx)
-            logger.debug("Logfire user context set with user_id: %s", user_id)
+            logger.debug(
+                "Logfire user context set with shotgun_instance_id: %s",
+                shotgun_instance_id,
+            )
         except Exception as e:
             logger.warning("Failed to set Logfire user context: %s", e)