shotgun-sh 0.2.17__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/tui/screens/shotgun_auth.py

@@ -1,6 +1,7 @@
 """Shotgun Account authentication screen."""
 
 import asyncio
+import time
 import webbrowser
 from typing import TYPE_CHECKING, cast
 
@@ -8,17 +9,20 @@ import httpx
 from textual import on
 from textual.app import ComposeResult
 from textual.containers import Vertical
+from textual.events import Resize
 from textual.screen import Screen
 from textual.widgets import Button, Label, Markdown, Static
 from textual.worker import Worker, WorkerState
 
 from shotgun.agents.config import ConfigManager
 from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
 from shotgun.shotgun_web import (
     ShotgunWebClient,
     TokenStatus,
 )
 from shotgun.shotgun_web.constants import DEFAULT_POLL_INTERVAL_SECONDS
+from shotgun.tui.layout import COMPACT_HEIGHT_THRESHOLD
 
 if TYPE_CHECKING:
     from ..app import ShotgunApp
@@ -76,25 +80,52 @@ class ShotgunAuthScreen(Screen[bool]):
             padding: 1;
             align: center middle;
         }
+
+        /* Compact styles for short terminals */
+        ShotgunAuthScreen.compact #titlebox {
+            margin: 0;
+            padding: 0;
+            border: none;
+        }
+
+        ShotgunAuthScreen.compact #auth-subtitle {
+            display: none;
+        }
+
+        ShotgunAuthScreen.compact #content {
+            padding: 0;
+        }
+
+        ShotgunAuthScreen.compact #instructions {
+            display: none;
+        }
+
+        ShotgunAuthScreen.compact #actions {
+            padding: 0;
+        }
     """
 
     BINDINGS = [
         ("escape", "cancel", "Cancel"),
     ]
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        title: str = "Shotgun Account Setup",
+        subtitle: str = "Authenticate with your Shotgun Account to get started",
+    ) -> None:
         super().__init__()
+        self._title = title
+        self._subtitle = subtitle
         self.token: str | None = None
         self.auth_url: str | None = None
         self.poll_worker: Worker[None] | None = None
+        self._auth_start_time: float | None = None
 
     def compose(self) -> ComposeResult:
         with Vertical(id="titlebox"):
-            yield Static("Shotgun Account Setup", id="auth-title")
-            yield Static(
-                "Authenticate with your Shotgun Account to get started",
-                id="auth-subtitle",
-            )
+            yield Static(self._title, id="auth-title")
+            yield Static(self._subtitle, id="auth-subtitle")
 
         with Vertical(id="content"):
             yield Label("Initializing...", id="status")
@@ -113,10 +144,24 @@ class ShotgunAuthScreen(Screen[bool]):
 
     def on_mount(self) -> None:
         """Start authentication flow when screen is mounted."""
+        self._apply_layout_for_height(self.app.size.height)
         self.run_worker(self._start_auth_flow(), exclusive=True)
 
+    @on(Resize)
+    def handle_resize(self, event: Resize) -> None:
+        """Adjust layout based on terminal height."""
+        self._apply_layout_for_height(event.size.height)
+
+    def _apply_layout_for_height(self, height: int) -> None:
+        """Apply appropriate layout based on terminal height."""
+        if height < COMPACT_HEIGHT_THRESHOLD:
+            self.add_class("compact")
+        else:
+            self.remove_class("compact")
+
     def action_cancel(self) -> None:
         """Cancel authentication and close screen."""
+        track_event("auth_cancelled")
         if self.poll_worker and self.poll_worker.state == WorkerState.RUNNING:
             self.poll_worker.cancel()
         self.dismiss(False)
@@ -133,6 +178,9 @@ class ShotgunAuthScreen(Screen[bool]):
 
     async def _start_auth_flow(self) -> None:
         """Start the authentication flow."""
+        self._auth_start_time = time.time()
+        track_event("auth_started")
+
         try:
             # Get shotgun instance ID from config
             shotgun_instance_id = await self.config_manager.get_shotgun_instance_id()
@@ -179,15 +227,21 @@ class ShotgunAuthScreen(Screen[bool]):
 
         except httpx.HTTPError as e:
             logger.error("Failed to create auth token: %s", e)
+            track_event(
+                "auth_failed",
+                {"phase": "token_creation", "error_type": type(e).__name__},
+            )
             self.query_one("#status", Label).update(
                 f"❌ Error: Failed to create authentication token\n{e}"
             )
-            self.notify("Failed to start authentication", severity="error")
 
         except Exception as e:
             logger.error("Unexpected error during auth flow: %s", e)
+            track_event(
+                "auth_failed",
+                {"phase": "token_creation", "error_type": type(e).__name__},
+            )
             self.query_one("#status", Label).update(f"❌ Unexpected error: {e}")
-            self.notify("Authentication failed", severity="error")
 
     async def _poll_token_status(self) -> None:
         """Poll token status until completed or expired."""
@@ -215,26 +269,49 @@ class ShotgunAuthScreen(Screen[bool]):
                     logger.info("Authentication completed successfully")
 
                     if status_response.litellm_key and status_response.supabase_key:
+                        # Fetch user info to get workspace_id
+                        workspace_id: str | None = None
+                        try:
+                            me_response = client.get_me(status_response.supabase_key)
+                            workspace_id = me_response.workspace.id
+                            logger.info("Fetched workspace_id: %s", workspace_id)
+                        except Exception as e:
+                            # Log warning but continue - workspace_id can be fetched later
+                            logger.warning(
+                                "Failed to fetch workspace_id from /api/me: %s", e
+                            )
+
                         await self.config_manager.update_shotgun_account(
                             api_key=status_response.litellm_key,
                             supabase_jwt=status_response.supabase_key,
+                            workspace_id=workspace_id,
+                        )
+
+                        # Track successful auth
+                        duration = (
+                            time.time() - self._auth_start_time
+                            if self._auth_start_time
+                            else 0
+                        )
+                        track_event(
+                            "auth_completed",
+                            {"duration_seconds": round(duration, 2)},
                         )
 
                         self.query_one("#status", Label).update(
                             "✅ Authentication successful! Saving credentials..."
                         )
                         await asyncio.sleep(1)
-                        self.notify(
-                            "Shotgun Account configured successfully!",
-                            severity="information",
-                        )
                         self.dismiss(True)
                     else:
                         logger.error("Completed but missing keys")
+                        track_event(
+                            "auth_failed",
+                            {"phase": "polling", "error_type": "MissingKeys"},
+                        )
                         self.query_one("#status", Label).update(
                             "❌ Error: Authentication completed but keys are missing"
                         )
-                        self.notify("Authentication failed", severity="error")
                         await asyncio.sleep(3)
                         self.dismiss(False)
                     return
@@ -246,11 +323,14 @@ class ShotgunAuthScreen(Screen[bool]):
 
                 elif status_response.status == TokenStatus.EXPIRED:
                     logger.error("Token expired")
+                    track_event(
+                        "auth_failed",
+                        {"phase": "token_expired", "error_type": "TokenExpired"},
+                    )
                     self.query_one("#status", Label).update(
                         "❌ Authentication token expired (30 minutes)\n"
                         "Please try again."
                     )
-                    self.notify("Authentication token expired", severity="error")
                     await asyncio.sleep(3)
                     self.dismiss(False)
                     return
@@ -266,15 +346,22 @@ class ShotgunAuthScreen(Screen[bool]):
                 if e.response.status_code == 410:
                     # Token expired
                     logger.error("Token expired (410)")
+                    track_event(
+                        "auth_failed",
+                        {"phase": "token_expired", "error_type": "TokenExpired"},
+                    )
                     self.query_one("#status", Label).update(
                         "❌ Authentication token expired"
                     )
-                    self.notify("Authentication token expired", severity="error")
                     await asyncio.sleep(3)
                     self.dismiss(False)
                     return
                 else:
                     logger.error("HTTP error polling status: %s", e)
+                    track_event(
+                        "auth_failed",
+                        {"phase": "polling_error", "error_type": type(e).__name__},
+                    )
                     self.query_one("#status", Label).update(
                         f"❌ Error checking status: {e}"
                     )
@@ -282,14 +369,21 @@ class ShotgunAuthScreen(Screen[bool]):
 
             except Exception as e:
                 logger.error("Error polling token status: %s", e)
+                track_event(
+                    "auth_failed",
+                    {"phase": "polling_error", "error_type": type(e).__name__},
+                )
                 self.query_one("#status", Label).update(f"⚠️ Error checking status: {e}")
                 await asyncio.sleep(5)  # Wait a bit longer on error
 
         # Timeout reached
         logger.error("Polling timeout reached")
+        track_event(
+            "auth_failed",
+            {"phase": "timeout", "error_type": "Timeout"},
+        )
         self.query_one("#status", Label).update(
             "❌ Authentication timeout (30 minutes)\nPlease try again."
         )
-        self.notify("Authentication timeout", severity="error")
         await asyncio.sleep(3)
         self.dismiss(False)

shotgun/tui/screens/spec_pull.py

@@ -0,0 +1,288 @@
+"""Screen showing download progress for pulling specs."""
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.events import Resize
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, ProgressBar, Static
+from textual.worker import Worker, get_current_worker
+
+from shotgun.cli.spec.models import PullSource
+from shotgun.cli.spec.pull_service import (
+    CancelledError,
+    PullProgress,
+    SpecPullService,
+)
+from shotgun.logging_config import get_logger
+from shotgun.shotgun_web.exceptions import (
+    ForbiddenError,
+    NotFoundError,
+    UnauthorizedError,
+)
+from shotgun.tui.layout import COMPACT_HEIGHT_THRESHOLD
+from shotgun.utils.file_system_utils import get_shotgun_base_path
+
+logger = get_logger(__name__)
+
+
+class SpecPullScreen(ModalScreen[bool]):
+    """Screen to pull a spec version with progress display.
+
+    Returns True if pull was successful, False otherwise.
+    """
+
+    DEFAULT_CSS = """
+        SpecPullScreen {
+            align: center middle;
+            background: rgba(0, 0, 0, 0.0);
+        }
+
+        SpecPullScreen > #dialog-container {
+            width: 80%;
+            max-width: 90;
+            height: auto;
+            border: wide $primary;
+            padding: 1 2;
+            layout: vertical;
+            background: $surface;
+        }
+
+        #dialog-title {
+            text-style: bold;
+            color: $text-accent;
+            padding-bottom: 1;
+            text-align: center;
+        }
+
+        #phase-label {
+            padding: 0;
+        }
+
+        #progress-bar {
+            width: 100%;
+            padding: 0;
+        }
+
+        #file-label {
+            color: $text-muted;
+        }
+
+        #error-label {
+            color: $error;
+        }
+
+        #success-label {
+            color: $success;
+            text-style: bold;
+        }
+
+        #dialog-buttons {
+            layout: horizontal;
+            align-horizontal: center;
+            height: auto;
+        }
+
+        #dialog-buttons Button {
+            margin: 0 1;
+        }
+
+        /* Hide elements initially */
+        #success-label {
+            display: none;
+        }
+
+        #error-label {
+            display: none;
+        }
+
+        /* Compact styles for short terminals */
+        SpecPullScreen.compact #dialog-container {
+            padding: 0 2;
+            max-height: 98%;
+        }
+
+        SpecPullScreen.compact #dialog-title {
+            padding-bottom: 0;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, version_id: str) -> None:
+        """Initialize the screen.
+
+        Args:
+            version_id: Version UUID to pull.
+        """
+        super().__init__()
+        self.version_id = version_id
+        self._success = False
+        self._download_worker: Worker[None] | None = None
+        self._cancelled = False
+
+    def compose(self) -> ComposeResult:
+        """Compose the screen widgets."""
+        with Container(id="dialog-container"):
+            yield Label("Pulling spec from cloud", id="dialog-title")
+
+            # Progress section
+            yield Static("Fetching version info...", id="phase-label")
+            yield ProgressBar(total=100, id="progress-bar")
+            yield Static("", id="file-label")
+
+            # Error section (hidden by default)
+            yield Static("", id="error-label")
+
+            # Success section (hidden by default)
+            yield Static("Spec pulled successfully!", id="success-label")
+
+            # Buttons
+            with Horizontal(id="dialog-buttons"):
+                yield Button("Cancel", id="cancel-btn")
+                yield Button("Continue", variant="primary", id="done-btn")
+
+    def on_mount(self) -> None:
+        """Start the download when screen is mounted."""
+        # Hide done button initially
+        self.query_one("#done-btn", Button).display = False
+
+        # Apply compact layout if starting in a short terminal
+        self._apply_compact_layout(self.app.size.height < COMPACT_HEIGHT_THRESHOLD)
+
+        # Start the download
+        self._start_download()
+
+    @on(Resize)
+    def handle_resize(self, event: Resize) -> None:
+        """Adjust layout based on terminal height."""
+        self._apply_compact_layout(event.size.height < COMPACT_HEIGHT_THRESHOLD)
+
+    def _apply_compact_layout(self, compact: bool) -> None:
+        """Apply or remove compact layout class for short terminals."""
+        if compact:
+            self.add_class("compact")
+        else:
+            self.remove_class("compact")
+
+    @work(exclusive=True)
+    async def _start_download(self) -> None:
+        """Run the download pipeline."""
+        worker = get_current_worker()
+        self._download_worker = worker
+
+        shotgun_dir = get_shotgun_base_path()
+        service = SpecPullService()
+
+        def on_progress(p: PullProgress) -> None:
+            pct = 0.0
+            if p.total_files and p.file_index is not None:
+                pct = ((p.file_index + 1) / p.total_files) * 100
+            self._update_phase(p.phase, progress=pct, current_file=p.current_file)
+
+        try:
+            result = await service.pull_version(
+                version_id=self.version_id,
+                shotgun_dir=shotgun_dir,
+                on_progress=on_progress,
+                is_cancelled=lambda: worker.is_cancelled,
+                source=PullSource.TUI,
+            )
+
+            if result.success:
+                self._update_title(f"Pulled: {result.spec_name}")
+                self._success = True
+                self._show_success()
+            else:
+                self._show_error(result.error or "Unknown error")
+
+        except CancelledError:
+            self._cancelled = True
+            self._show_cancelled()
+        except UnauthorizedError:
+            self._show_error("Not authenticated. Please try again.")
+        except NotFoundError:
+            self._show_error(f"Version not found: {self.version_id}")
+        except ForbiddenError:
+            self._show_error("You don't have access to this spec.")
+        except Exception as e:
+            logger.exception(f"Download failed: {type(e).__name__}: {e}")
+            error_msg = str(e) if str(e) else type(e).__name__
+            self._show_error(error_msg)
+
+    def _update_title(self, title: str) -> None:
+        """Update the dialog title."""
+        self.query_one("#dialog-title", Label).update(title)
+
+    def _update_phase(
+        self,
+        phase_text: str,
+        progress: float = 0,
+        current_file: str | None = None,
+    ) -> None:
+        """Update the progress UI."""
+        self.query_one("#phase-label", Static).update(phase_text)
+        self.query_one("#progress-bar", ProgressBar).update(progress=progress)
+
+        file_label = self.query_one("#file-label", Static)
+        if current_file:
+            file_label.update(f"Current: {current_file}")
+        else:
+            file_label.update("")
+
+    def _show_success(self) -> None:
+        """Show success state."""
+        self.query_one("#phase-label", Static).update("Download complete!")
+        self.query_one("#progress-bar", ProgressBar).update(progress=100)
+        self.query_one("#success-label", Static).display = True
+        self.query_one("#cancel-btn", Button).display = False
+        self.query_one("#done-btn", Button).display = True
+
+    def _show_error(self, error: str) -> None:
+        """Show error state."""
+        error_label = self.query_one("#error-label", Static)
+        error_label.update(f"Error: {error}")
+        error_label.display = True
+        self.query_one("#cancel-btn", Button).display = False
+        self.query_one("#done-btn", Button).display = True
+        self.query_one("#done-btn", Button).label = "Close"
+
+    def _show_cancelled(self) -> None:
+        """Show cancelled state."""
+        self.query_one("#phase-label", Static).update("Download cancelled")
+        self.query_one("#cancel-btn", Button).display = False
+        self.query_one("#done-btn", Button).display = True
+        self.query_one("#done-btn", Button).label = "Close"
+
+    @on(Button.Pressed, "#cancel-btn")
+    def _on_cancel(self, event: Button.Pressed) -> None:
+        """Handle cancel button."""
+        event.stop()
+        self._cancel_download()
+
+    @on(Button.Pressed, "#done-btn")
+    def _on_done(self, event: Button.Pressed) -> None:
+        """Handle done button."""
+        event.stop()
+        self.dismiss(self._success)
+
+    def action_cancel(self) -> None:
+        """Handle escape key."""
+        if (
+            self._success
+            or self._cancelled
+            or self.query_one("#error-label", Static).display
+        ):
+            # Already finished, just dismiss
+            self.dismiss(self._success)
+        else:
+            # Download in progress, cancel it
+            self._cancel_download()
+
+    def _cancel_download(self) -> None:
+        """Cancel the download."""
+        if self._download_worker and not self._download_worker.is_cancelled:
+            self._cancelled = True
+            self._download_worker.cancel()