recce-cloud 1.32.0__py3-none-any.whl → 1.33.1__py3-none-any.whl

recce_cloud/services/diagnostic_service.py

@@ -0,0 +1,380 @@
+"""
+Diagnostic service for checking Recce Cloud setup and configuration.
+
+This service contains the business logic for health checks, separated from
+CLI presentation concerns.
+"""
+
+import logging
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class CheckStatus(Enum):
+    """Status of a diagnostic check."""
+
+    PASS = "pass"
+    FAIL = "fail"
+    SKIP = "skip"  # When check cannot be performed due to missing prerequisites
+
+
+@dataclass
+class CheckResult:
+    """Result of a single diagnostic check."""
+
+    status: CheckStatus
+    message: Optional[str] = None
+    suggestion: Optional[str] = None
+    details: dict = field(default_factory=dict)
+
+    @property
+    def passed(self) -> bool:
+        return self.status == CheckStatus.PASS
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        result = {
+            "status": self.status.value,
+            "message": self.message,
+            "suggestion": self.suggestion,
+        }
+        result.update(self.details)
+        return result
+
+
+@dataclass
+class DiagnosticResults:
+    """Aggregated results of all diagnostic checks."""
+
+    login: CheckResult
+    project_binding: CheckResult
+    production_metadata: CheckResult
+    dev_session: CheckResult
+
+    @property
+    def all_passed(self) -> bool:
+        return all(
+            [
+                self.login.passed,
+                self.project_binding.passed,
+                self.production_metadata.passed,
+                self.dev_session.passed,
+            ]
+        )
+
+    @property
+    def passed_count(self) -> int:
+        return sum(
+            1
+            for check in [self.login, self.project_binding, self.production_metadata, self.dev_session]
+            if check.passed
+        )
+
+    @property
+    def total_count(self) -> int:
+        return 4
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "login": self.login.to_dict(),
+            "project_binding": self.project_binding.to_dict(),
+            "production_metadata": self.production_metadata.to_dict(),
+            "dev_session": self.dev_session.to_dict(),
+            "all_passed": self.all_passed,
+        }
+
+
+class DiagnosticService:
+    """
+    Service for performing Recce Cloud diagnostic checks.
+
+    This service checks:
+    1. Login status - Is the user authenticated?
+    2. Project binding - Is the project configured?
+    3. Production metadata - Does a production session exist?
+    4. Dev session - Does a development session exist?
+    """
+
+    def __init__(self):
+        self._token: Optional[str] = None
+        self._org: Optional[str] = None
+        self._project: Optional[str] = None
+
+    def run_all_checks(self) -> DiagnosticResults:
+        """
+        Run all diagnostic checks and return aggregated results.
+
+        Returns:
+            DiagnosticResults containing the status of all checks.
+        """
+        login_result = self._check_login()
+        project_result = self._check_project_binding()
+
+        # Session checks depend on login and project binding
+        if login_result.passed and project_result.passed:
+            prod_result, dev_result = self._check_sessions()
+        else:
+            skip_message = "Cannot check - requires login and project binding"
+            prod_result = CheckResult(
+                status=CheckStatus.SKIP,
+                message=skip_message,
+            )
+            dev_result = CheckResult(
+                status=CheckStatus.SKIP,
+                message=skip_message,
+            )
+
+        return DiagnosticResults(
+            login=login_result,
+            project_binding=project_result,
+            production_metadata=prod_result,
+            dev_session=dev_result,
+        )
+
+    def _check_login(self) -> CheckResult:
+        """Check if user is logged in with a valid token."""
+        from recce_cloud.auth.login import check_login_status
+        from recce_cloud.auth.profile import get_api_token
+
+        self._token = os.getenv("RECCE_API_TOKEN") or get_api_token()
+
+        if not self._token:
+            return CheckResult(
+                status=CheckStatus.FAIL,
+                message="Not logged in",
+                suggestion="Run 'recce-cloud login' to authenticate",
+            )
+
+        is_logged_in, email = check_login_status()
+
+        if is_logged_in:
+            return CheckResult(
+                status=CheckStatus.PASS,
+                details={"email": email},
+            )
+        else:
+            return CheckResult(
+                status=CheckStatus.FAIL,
+                message="Token invalid or expired",
+                suggestion="Run 'recce-cloud login' to authenticate",
+            )
+
+    def _check_project_binding(self) -> CheckResult:
+        """Check if project is bound to Recce Cloud."""
+        from recce_cloud.config.project_config import get_project_binding
+
+        binding = get_project_binding()
+
+        if binding:
+            self._org = binding.get("org")
+            self._project = binding.get("project")
+            return CheckResult(
+                status=CheckStatus.PASS,
+                details={
+                    "org": self._org,
+                    "project": self._project,
+                    "source": "config_file",
+                },
+            )
+
+        # Check environment variables as fallback
+        env_org = os.environ.get("RECCE_ORG")
+        env_project = os.environ.get("RECCE_PROJECT")
+
+        if env_org and env_project:
+            self._org = env_org
+            self._project = env_project
+            return CheckResult(
+                status=CheckStatus.PASS,
+                details={
+                    "org": self._org,
+                    "project": self._project,
+                    "source": "env_vars",
+                },
+            )
+
+        return CheckResult(
+            status=CheckStatus.FAIL,
+            message="No project binding found",
+            suggestion="Run 'recce-cloud init' to bind this directory to a project",
+        )
+
+    def _check_sessions(self) -> tuple[CheckResult, CheckResult]:
+        """
+        Check for production and development sessions.
+
+        Returns:
+            Tuple of (production_result, dev_result)
+        """
+        from recce_cloud.api.client import RecceCloudClient
+        from recce_cloud.api.exceptions import RecceCloudException
+
+        try:
+            client = RecceCloudClient(self._token)
+
+            # Get org and project IDs
+            org_info = client.get_organization(self._org)
+            if not org_info:
+                raise RecceCloudException(f"Organization '{self._org}' not found", 404)
+            org_id = org_info.get("id")
+            if not org_id:
+                raise RecceCloudException(f"Organization '{self._org}' response missing ID", 500)
+
+            project_info = client.get_project(org_id, self._project)
+            if not project_info:
+                raise RecceCloudException(f"Project '{self._project}' not found", 404)
+            project_id = project_info.get("id")
+            if not project_id:
+                raise RecceCloudException(f"Project '{self._project}' response missing ID", 500)
+
+            # List sessions
+            sessions = client.list_sessions(org_id, project_id)
+
+            prod_session = None
+            dev_sessions = []
+
+            for s in sessions:
+                if s.get("is_base"):
+                    prod_session = s
+                elif not s.get("pr_link"):  # dev = not base and no PR link
+                    dev_sessions.append(s)
+
+            # Check production
+            prod_result = self._evaluate_production_session(prod_session)
+
+            # Check dev
+            dev_result = self._evaluate_dev_sessions(dev_sessions)
+
+            return prod_result, dev_result
+
+        except RecceCloudException as e:
+            error_result = CheckResult(
+                status=CheckStatus.FAIL,
+                message=f"Failed to fetch sessions: {e}",
+            )
+            return error_result, error_result
+
+        except Exception as e:
+            logger.debug("Unexpected error during session check: %s", e, exc_info=True)
+            error_result = CheckResult(
+                status=CheckStatus.FAIL,
+                message=f"Unexpected error: {e}",
+                suggestion="Check your network connection and try again.",
+            )
+            return error_result, error_result
+
+    def _evaluate_production_session(self, prod_session: Optional[dict]) -> CheckResult:
+        """Evaluate the production session check."""
+        if not prod_session:
+            return CheckResult(
+                status=CheckStatus.FAIL,
+                message="No production artifacts found",
+                suggestion=(
+                    "To upload production metadata:\n"
+                    "  1. Check out your main branch:\n"
+                    "     $ git checkout main\n"
+                    "  2. Generate and upload production artifacts:\n"
+                    "     $ dbt docs generate --target prod\n"
+                    "     $ recce-cloud upload --type prod"
+                ),
+            )
+
+        # Check if the session has actual data (adapter_type is not null)
+        # An empty session created by default will have adapter_type=null
+        if not prod_session.get("adapter_type"):
+            return CheckResult(
+                status=CheckStatus.FAIL,
+                message="Production session exists but has no data",
+                suggestion=(
+                    "To upload production metadata:\n"
+                    "  1. Check out your main branch:\n"
+                    "     $ git checkout main\n"
+                    "  2. Generate and upload production artifacts:\n"
+                    "     $ dbt docs generate --target prod\n"
+                    "     $ recce-cloud upload --type prod"
+                ),
+            )
+
+        session_name = prod_session.get("name") or "(unnamed)"
+        uploaded_at = prod_session.get("updated_at") or prod_session.get("created_at")
+
+        return CheckResult(
+            status=CheckStatus.PASS,
+            details={
+                "session_name": session_name,
+                "uploaded_at": uploaded_at,
+                "relative_time": self._format_relative_time(uploaded_at),
+            },
+        )
+
+    def _evaluate_dev_sessions(self, dev_sessions: list) -> CheckResult:
+        """Evaluate the dev session check."""
+        if not dev_sessions:
+            return CheckResult(
+                status=CheckStatus.FAIL,
+                message="No dev session found",
+                suggestion=(
+                    "To create and upload a dev session:\n"
+                    "  1. Check out a feature branch with your changes:\n"
+                    "     $ git checkout -b my-feature-branch\n"
+                    "     (make some changes to your dbt models)\n"
+                    "  2. Generate and upload dev artifacts:\n"
+                    "     $ dbt docs generate\n"
+                    "     $ recce-cloud upload --session-name my-feature-branch"
+                ),
+            )
+
+        # Sort by updated_at/created_at to get most recent
+        dev_sessions.sort(
+            key=lambda x: x.get("updated_at") or x.get("created_at") or "",
+            reverse=True,
+        )
+        latest_dev = dev_sessions[0]
+        session_name = latest_dev.get("name") or "(unnamed)"
+        uploaded_at = latest_dev.get("updated_at") or latest_dev.get("created_at")
+
+        return CheckResult(
+            status=CheckStatus.PASS,
+            details={
+                "session_name": session_name,
+                "uploaded_at": uploaded_at,
+                "relative_time": self._format_relative_time(uploaded_at),
+            },
+        )
+
+    @staticmethod
+    def _format_relative_time(iso_timestamp: Optional[str]) -> Optional[str]:
+        """Format an ISO timestamp as a human-readable relative time."""
+        if not iso_timestamp:
+            return None
+
+        try:
+            # Parse ISO timestamp
+            if iso_timestamp.endswith("Z"):
+                dt = datetime.fromisoformat(iso_timestamp.replace("Z", "+00:00"))
+            else:
+                dt = datetime.fromisoformat(iso_timestamp)
+
+            now = datetime.now(timezone.utc)
+            diff = now - dt
+
+            seconds = diff.total_seconds()
+            if seconds < 60:
+                return "just now"
+            elif seconds < 3600:
+                mins = int(seconds / 60)
+                return f"{mins}m ago"
+            elif seconds < 86400:
+                hours = int(seconds / 3600)
+                return f"{hours}h ago"
+            else:
+                days = int(seconds / 86400)
+                return f"{days}d ago"
+        except (ValueError, TypeError):
+            return None

recce_cloud/upload.py

@@ -2,14 +2,19 @@
 Upload helper functions for recce-cloud CLI.
 """
 
+import logging
 import os
 import sys
 
+import click
 import requests
 
 from recce_cloud.api.client import RecceCloudClient
 from recce_cloud.api.exceptions import RecceCloudException
 from recce_cloud.api.factory import create_platform_client
+from recce_cloud.config.resolver import ConfigurationError, resolve_config
+
+logger = logging.getLogger(__name__)
 
 
 def upload_to_existing_session(
@@ -225,3 +230,209 @@ def upload_with_platform_apis(
         console.print(f"Change request: {ci_info.cr_url}")
 
     sys.exit(0)
+
+
+def upload_with_session_name(
+    console,
+    token: str,
+    session_name: str,
+    manifest_path: str,
+    catalog_path: str,
+    adapter_type: str,
+    target_path: str,
+    skip_confirmation: bool = False,
+):
+    """
+    Upload artifacts to a session identified by name.
+
+    If the session exists, uploads to it. If not, prompts to create a new session
+    (unless skip_confirmation is True, which auto-creates).
+
+    This workflow requires org/project configuration from either:
+    - Local config file (.recce/config) via 'recce-cloud init'
+    - Environment variables (RECCE_ORG, RECCE_PROJECT)
+    """
+    # 1. Resolve org/project configuration
+    console.rule("Session Name Resolution", style="blue")
+    try:
+        config = resolve_config()
+        org = config.org
+        project = config.project
+        console.print(f"[cyan]Organization:[/cyan] {org}")
+        console.print(f"[cyan]Project:[/cyan] {project}")
+        console.print(f"[cyan]Config Source:[/cyan] {config.source}")
+    except ConfigurationError as e:
+        console.print("[red]Error:[/red] Could not resolve org/project configuration")
+        console.print(f"Reason: {e}")
+        console.print()
+        console.print("To use --session-name, you need to either:")
+        console.print("  1. Run 'recce-cloud init' to bind this directory to a project")
+        console.print("  2. Set RECCE_ORG and RECCE_PROJECT environment variables")
+        sys.exit(2)
+
+    # 2. Initialize API client
+    try:
+        client = RecceCloudClient(token)
+    except Exception as e:
+        console.print("[red]Error:[/red] Failed to initialize API client")
+        console.print(f"Reason: {e}")
+        sys.exit(2)
+
+    # 3. Resolve org/project IDs (they might be slugs/names in config)
+    try:
+        org_info = client.get_organization(org)
+        if not org_info:
+            console.print(f"[red]Error:[/red] Organization '{org}' not found or you don't have access")
+            sys.exit(2)
+        org_id = org_info.get("id")
+        if not org_id:
+            console.print(f"[red]Error:[/red] Organization '{org}' response missing ID")
+            sys.exit(2)
+
+        project_info = client.get_project(org_id, project)
+        if not project_info:
+            console.print(f"[red]Error:[/red] Project '{project}' not found in organization '{org}'")
+            sys.exit(2)
+        project_id = project_info.get("id")
+        if not project_id:
+            console.print(f"[red]Error:[/red] Project '{project}' response missing ID")
+            sys.exit(2)
+    except RecceCloudException as e:
+        console.print("[red]Error:[/red] Failed to resolve organization/project")
+        console.print(f"Reason: {e.reason}")
+        sys.exit(2)
+    except Exception as e:
+        logger.debug("Failed to resolve organization/project: %s", e, exc_info=True)
+        console.print("[red]Error:[/red] Failed to resolve organization/project")
+        console.print(f"  Reason: {e}")
+        console.print("  Check your authentication and network connection.")
+        sys.exit(2)
+
+    # 4. Look up session by name
+    console.print(f'Looking up session "{session_name}"...')
+    try:
+        existing_session = client.get_session_by_name(org_id, project_id, session_name)
+    except RecceCloudException as e:
+        console.print("[red]Error:[/red] Failed to look up session")
+        console.print(f"Reason: {e.reason}")
+        sys.exit(2)
+    except Exception as e:
+        logger.debug("Failed to look up session: %s", e, exc_info=True)
+        console.print("[red]Error:[/red] Failed to look up session")
+        console.print(f"  Reason: {e}")
+        console.print("  Check your network connection and try again.")
+        sys.exit(2)
+
+    session_id = None
+    if existing_session:
+        # Session found, use it
+        session_id = existing_session.get("id")
+        console.print(f'[green]Found existing session:[/green] "{session_name}" (ID: {session_id})')
+    else:
+        # Session not found, prompt to create
+        console.print(f'[yellow]Session "{session_name}" not found[/yellow]')
+
+        if skip_confirmation:
+            # Auto-create with --yes flag
+            console.print("Creating new session (--yes flag specified)...")
+        else:
+            # Interactive confirmation
+            console.print()
+            if not click.confirm(f'Create new session "{session_name}"?', default=True):
+                console.print("[yellow]Upload cancelled[/yellow]")
+                sys.exit(0)
+
+        # Create the session
+        try:
+            new_session = client.create_session(
+                org_id=org_id,
+                project_id=project_id,
+                session_name=session_name,
+                adapter_type=adapter_type,
+                session_type="manual",
+            )
+            session_id = new_session.get("id")
+            console.print(f'[green]Created new session:[/green] "{session_name}" (ID: {session_id})')
+        except RecceCloudException as e:
+            console.print("[red]Error:[/red] Failed to create session")
+            console.print(f"Reason: {e.reason}")
+            sys.exit(4)
+        except Exception as e:
+            console.print("[red]Error:[/red] Failed to create session")
+            console.print(f"Reason: {e}")
+            sys.exit(4)
+
+    # 5. Get presigned URLs and upload
+    console.rule("Uploading Artifacts", style="blue")
+    try:
+        presigned_urls = client.get_upload_urls_by_session_id(org_id, project_id, session_id)
+    except RecceCloudException as e:
+        console.print("[red]Error:[/red] Failed to get upload URLs")
+        console.print(f"Reason: {e.reason}")
+        sys.exit(4)
+    except Exception as e:
+        console.print("[red]Error:[/red] Failed to get upload URLs")
+        console.print(f"Reason: {e}")
+        sys.exit(4)
+
+    # Upload manifest.json
+    console.print(f'Uploading manifest from path "{manifest_path}"')
+    try:
+        with open(manifest_path, "rb") as f:
+            response = requests.put(presigned_urls["manifest_url"], data=f.read())
+        if response.status_code not in [200, 204]:
+            raise Exception(f"Upload failed with status {response.status_code}: {response.text}")
+    except Exception as e:
+        console.print("[red]Error:[/red] Failed to upload manifest.json")
+        console.print(f"Reason: {e}")
+        sys.exit(4)
+
+    # Upload catalog.json
+    console.print(f'Uploading catalog from path "{catalog_path}"')
+    try:
+        with open(catalog_path, "rb") as f:
+            response = requests.put(presigned_urls["catalog_url"], data=f.read())
+        if response.status_code not in [200, 204]:
+            raise Exception(f"Upload failed with status {response.status_code}: {response.text}")
+    except Exception as e:
+        console.print("[red]Error:[/red] Failed to upload catalog.json")
+        console.print(f"Reason: {e}")
+        sys.exit(4)
+
+    # Update session metadata (if session already existed, update adapter_type)
+    if existing_session:
+        try:
+            client.update_session(org_id, project_id, session_id, adapter_type)
+        except RecceCloudException as e:
+            console.print("[yellow]Warning:[/yellow] Failed to update session metadata")
+            console.print(f"Reason: {e.reason}")
+            # Non-fatal for existing sessions
+        except Exception as e:
+            console.print("[yellow]Warning:[/yellow] Failed to update session metadata")
+            console.print(f"Reason: {e}")
+            # Non-fatal for existing sessions
+
+    # Notify upload completion
+    console.print("Notifying upload completion...")
+    try:
+        client.upload_completed(session_id)
+    except RecceCloudException as e:
+        console.print("[yellow]Warning:[/yellow] Failed to notify upload completion")
+        console.print(f"Reason: {e.reason}")
+        # Non-fatal, continue
+    except Exception as e:
+        console.print("[yellow]Warning:[/yellow] Failed to notify upload completion")
+        console.print(f"Reason: {e}")
+        # Non-fatal, continue
+
+    # Success!
+    console.rule("Uploaded Successfully", style="green")
+    console.print("Uploaded dbt artifacts to Recce Cloud")
+    console.print()
+    console.print(f"[cyan]Session Name:[/cyan] {session_name}")
+    console.print(f"[cyan]Session ID:[/cyan] {session_id}")
+    console.print(f"[cyan]Organization:[/cyan] {org}")
+    console.print(f"[cyan]Project:[/cyan] {project}")
+    console.print(f"[cyan]Artifacts from:[/cyan] {os.path.abspath(target_path)}")
+
+    sys.exit(0)