shotgun-sh 0.2.11.dev7__py3-none-any.whl → 0.2.23.dev1__py3-none-any.whl

shotgun/sentry_telemetry.py

@@ -1,5 +1,6 @@
 """Sentry observability setup for Shotgun."""
 
+from pathlib import Path
 from typing import Any
 
 from shotgun import __version__
@@ -10,6 +11,122 @@ from shotgun.settings import settings
 logger = get_early_logger(__name__)
 
 
+def _scrub_path(path: str) -> str:
+    """Scrub sensitive information from file paths.
+
+    Removes home directory and current working directory prefixes to prevent
+    leaking usernames that might be part of the path.
+
+    Args:
+        path: The file path to scrub
+
+    Returns:
+        The scrubbed path with sensitive prefixes removed
+    """
+    if not path:
+        return path
+
+    try:
+        # Get home and cwd as Path objects for comparison
+        home = Path.home()
+        cwd = Path.cwd()
+
+        # Convert path to Path object
+        path_obj = Path(path)
+
+        # Try to make path relative to cwd first (most common case)
+        try:
+            relative_to_cwd = path_obj.relative_to(cwd)
+            return str(relative_to_cwd)
+        except ValueError:
+            pass
+
+        # Try to replace home directory with ~
+        try:
+            relative_to_home = path_obj.relative_to(home)
+            return f"~/{relative_to_home}"
+        except ValueError:
+            pass
+
+        # If path is absolute but not under cwd or home, just return filename
+        if path_obj.is_absolute():
+            return path_obj.name
+
+        # Return as-is if already relative
+        return path
+
+    except Exception:
+        # If anything goes wrong, return the original path
+        # Better to leak a path than break error reporting
+        return path
+
+
+def _scrub_sensitive_paths(event: dict[str, Any]) -> None:
+    """Scrub sensitive paths from Sentry event data.
+
+    Modifies the event in-place to remove:
+    - Home directory paths (might contain usernames)
+    - Current working directory paths (might contain usernames)
+    - Server name/hostname
+    - Paths in sys.argv
+
+    Args:
+        event: The Sentry event dictionary to scrub
+    """
+    extra = event.get("extra", {})
+    if "sys.argv" in extra:
+        argv = extra["sys.argv"]
+        if isinstance(argv, list):
+            extra["sys.argv"] = [
+                _scrub_path(arg) if isinstance(arg, str) else arg for arg in argv
+            ]
+
+    # Scrub server name if present
+    if "server_name" in event:
+        event["server_name"] = ""
+
+    # Scrub contexts that might contain paths
+    if "contexts" in event:
+        contexts = event["contexts"]
+        # Remove runtime context if it has CWD
+        if "runtime" in contexts:
+            if "cwd" in contexts["runtime"]:
+                del contexts["runtime"]["cwd"]
+            # Scrub sys.argv to remove paths
+            if "sys.argv" in contexts["runtime"]:
+                argv = contexts["runtime"]["sys.argv"]
+                if isinstance(argv, list):
+                    contexts["runtime"]["sys.argv"] = [
+                        _scrub_path(arg) if isinstance(arg, str) else arg
+                        for arg in argv
+                    ]
+
+    # Scrub exception stack traces
+    if "exception" in event and "values" in event["exception"]:
+        for exception in event["exception"]["values"]:
+            if "stacktrace" in exception and "frames" in exception["stacktrace"]:
+                for frame in exception["stacktrace"]["frames"]:
+                    # Scrub file paths
+                    if "abs_path" in frame:
+                        frame["abs_path"] = _scrub_path(frame["abs_path"])
+                    if "filename" in frame:
+                        frame["filename"] = _scrub_path(frame["filename"])
+
+                    # Scrub local variables that might contain paths
+                    if "vars" in frame:
+                        for var_name, var_value in frame["vars"].items():
+                            if isinstance(var_value, str):
+                                frame["vars"][var_name] = _scrub_path(var_value)
+
+    # Scrub breadcrumbs that might contain paths
+    if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
+        for breadcrumb in event["breadcrumbs"]["values"]:
+            if "data" in breadcrumb:
+                for key, value in breadcrumb["data"].items():
+                    if isinstance(value, str):
+                        breadcrumb["data"][key] = _scrub_path(value)
+
+
 def setup_sentry_observability() -> bool:
     """Set up Sentry observability for error tracking.
 
@@ -41,18 +158,38 @@ def setup_sentry_observability() -> bool:
             environment = "production"
 
         def before_send(event: Any, hint: dict[str, Any]) -> Any:
-            """Filter out user-actionable errors from Sentry.
+            """Filter out user-actionable errors and scrub sensitive paths.
 
             User-actionable errors (like context size limits) are expected conditions
             that users need to resolve, not bugs that need tracking.
+
+            Also scrubs sensitive information like usernames from file paths and
+            working directories to protect user privacy.
             """
+
+            log_record = hint.get("log_record")
+            if log_record:
+                # Scrub pathname using the helper function
+                log_record.pathname = _scrub_path(log_record.pathname)
+
+                # Scrub traceback text if it exists
+                if hasattr(log_record, "exc_text") and isinstance(
+                    log_record.exc_text, str
+                ):
+                    # Replace home directory in traceback text
+                    home = Path.home()
+                    log_record.exc_text = log_record.exc_text.replace(str(home), "~")
+
             if "exc_info" in hint:
-                exc_type, exc_value, tb = hint["exc_info"]
+                _, exc_value, _ = 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
+
+            # Scrub sensitive paths from the event
+            _scrub_sensitive_paths(event)
             return event
 
         # Initialize Sentry
@@ -61,6 +198,7 @@ def setup_sentry_observability() -> bool:
             release=f"shotgun-sh@{__version__}",
             environment=environment,
             send_default_pii=False,  # Privacy-first: never send PII
+            server_name="",  # Privacy: don't send hostname (may contain username)
             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,

shotgun/settings.py

@@ -108,6 +108,11 @@ class LoggingSettings(BaseSettings):
         default=True,
         description="Enable file logging output",
     )
+    max_log_files: int = Field(
+        default=10,
+        description="Maximum number of log files to keep (older files are deleted)",
+        ge=1,
+    )
 
     model_config = SettingsConfigDict(
         env_prefix="SHOTGUN_",

shotgun/tui/app.py

@@ -6,12 +6,18 @@ from textual.binding import Binding
 from textual.screen import Screen
 
 from shotgun.agents.agent_manager import AgentManager
-from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.agents.config import (
+    ConfigManager,
+    get_config_manager,
+)
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
 from shotgun.tui.containers import TUIContainer
 from shotgun.tui.screens.splash import SplashScreen
-from shotgun.utils.file_system_utils import get_shotgun_base_path
+from shotgun.utils.file_system_utils import (
+    ensure_shotgun_directory_exists,
+    get_shotgun_base_path,
+)
 from shotgun.utils.update_checker import (
     detect_installation_method,
     perform_auto_update_async,
@@ -31,10 +37,10 @@ logger = get_logger(__name__)
 class ShotgunApp(App[None]):
     # ChatScreen removed from SCREENS dict since it requires dependency injection
     # and is instantiated manually in refresh_startup_screen()
+    # DirectorySetupScreen also removed since it requires error_message parameter
     SCREENS = {
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
-        "directory_setup": DirectorySetupScreen,
         "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
@@ -99,7 +105,10 @@ class ShotgunApp(App[None]):
         # Run async config loading in worker
         async def _check_config() -> None:
             # Show welcome screen if no providers are configured OR if user hasn't seen it yet
+            # Note: If config migration fails, ConfigManager will auto-create fresh config
+            # and set migration_failed flag, which WelcomeScreen will display
             config = await self.config_manager.load()
+
             has_any_key = await self.config_manager.has_any_provider_key()
             if not has_any_key or not config.shown_welcome_screen:
                 if isinstance(self.screen, WelcomeScreen):
@@ -111,16 +120,32 @@ class ShotgunApp(App[None]):
                 )
                 return
 
+            # Try to create .shotgun directory if it doesn't exist
             if not self.check_local_shotgun_directory_exists():
-                if isinstance(self.screen, DirectorySetupScreen):
+                try:
+                    path = ensure_shotgun_directory_exists()
+                    # Verify directory was created successfully
+                    if not path.is_dir():
+                        # Show error screen if creation failed
+                        if isinstance(self.screen, DirectorySetupScreen):
+                            return
+                        self.push_screen(
+                            DirectorySetupScreen(
+                                error_message="Unable to create .shotgun directory due to filesystem conflict."
+                            ),
+                            callback=lambda _arg: self.refresh_startup_screen(),
+                        )
+                        return
+                except Exception as exc:
+                    # Show error screen if creation failed with exception
+                    if isinstance(self.screen, DirectorySetupScreen):
+                        return
+                    self.push_screen(
+                        DirectorySetupScreen(error_message=str(exc)),
+                        callback=lambda _arg: self.refresh_startup_screen(),
+                    )
                     return
 
-                self.push_screen(
-                    DirectorySetupScreen(),
-                    callback=lambda _arg: self.refresh_startup_screen(),
-                )
-                return
-
             if isinstance(self.screen, ChatScreen):
                 return