recce-cloud 1.31.0__tar.gz → 1.33.1__tar.gz

{recce_cloud-1.31.0 → recce_cloud-1.33.1}/.gitignore

@@ -20,7 +20,10 @@ recce.yml
 
 # Ignore build artifacts from frontend
 recce/data
-.worktrees
 
-# ignore Claude logs and plans
-docs/plans
+# ignore Claude logs and plans at any nesting
+**/docs/plans/**/*.md
+**/docs/plans/**/*.json
+
+# Git worktrees for isolated development
+.worktrees/

{recce_cloud-1.31.0 → recce_cloud-1.33.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: recce-cloud
-Version: 1.31.0
+Version: 1.33.1
 Summary: Lightweight CLI for Recce Cloud operations
 Project-URL: Bug Tracker, https://github.com/InfuseAI/recce/issues
 Author-email: InfuseAI Dev Team <dev@infuseai.io>
@@ -15,8 +15,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Requires-Dist: click>=7.1
+Requires-Dist: cryptography>=3.4
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.28.1
 Requires-Dist: rich>=12.0.0
+Provides-Extra: dev
+Requires-Dist: flake8>=7.2.0; extra == 'dev'
+Requires-Dist: pytest>=4.6; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Recce Cloud CLI
@@ -33,7 +38,8 @@ The Recce Cloud CLI (`recce-cloud`) is a standalone tool designed for CI/CD pipe
 - 🤖 Auto-detection - automatically detects CI platform, repository, and PR/MR context
 - ⬆️ Upload - push dbt artifacts to Recce Cloud sessions
 - ⬇️ Download - pull dbt artifacts from Recce Cloud sessions
-- 🔐 Flexible authentication - works with CI tokens or explicit API tokens
+- 🔐 Flexible authentication - browser-based login, token-based auth, or CI tokens
+- 🔗 Project binding - link local projects to Recce Cloud organizations
 - ✅ Platform-specific - optimized for GitHub Actions and GitLab CI
 
 ## Installation
@@ -57,6 +63,34 @@ install:
 
 ## Quick Start
 
+### Local Development
+
+**Login to Recce Cloud:**
+
+```bash
+# Browser-based login (recommended)
+recce-cloud login
+
+# Token-based login (for headless environments)
+recce-cloud login --token <your-api-token>
+```
+
+**Initialize project binding:**
+
+```bash
+# Interactive project selection
+recce-cloud init
+
+# Check current status
+recce-cloud status
+```
+
+**Logout:**
+
+```bash
+recce-cloud logout
+```
+
 ### GitHub Actions
 
 **Upload artifacts:**
@@ -232,6 +266,85 @@ recce-cloud download --session-id abc123 --force
 
 ## Command Reference
 
+### `recce-cloud login`
+
+Authenticate with Recce Cloud.
+
+**Options:**
+
+| Option    | Type   | Default | Description                                      |
+| --------- | ------ | ------- | ------------------------------------------------ |
+| `--token` | string | -       | API token for direct authentication (optional)   |
+
+**Usage:**
+
+```bash
+# Browser-based login (opens browser for OAuth)
+recce-cloud login
+
+# Direct token authentication (for CI/headless environments)
+recce-cloud login --token <your-api-token>
+```
+
+**Notes:**
+
+- Browser login opens Recce Cloud in your default browser for secure OAuth authentication
+- If the browser doesn't open automatically, the URL is displayed for manual access
+- Token-based login is useful for CI/CD environments or when browser access is unavailable
+- Credentials are saved to `~/.recce/profile.yml`
+
+### `recce-cloud logout`
+
+Clear stored Recce Cloud credentials.
+
+**Usage:**
+
+```bash
+recce-cloud logout
+```
+
+### `recce-cloud init`
+
+Initialize project binding to link a local project with a Recce Cloud organization and project.
+
+**Usage:**
+
+```bash
+recce-cloud init
+```
+
+**Workflow:**
+
+1. Verifies you are logged in (prompts for login if not)
+2. Lists available organizations (shows display names)
+3. Prompts you to select an organization
+4. Lists available projects in selected organization (excludes archived projects)
+5. Prompts you to select a project
+6. Saves binding to `.recce/config`
+7. Optionally adds `.recce/` to `.gitignore`
+
+**Notes:**
+
+- Requires authentication (run `recce-cloud login` first)
+- Creates `.recce/config` file in current directory
+- Binding can be overridden with environment variables (`RECCE_ORG`, `RECCE_PROJECT`)
+
+### `recce-cloud status`
+
+Display current authentication and project binding status.
+
+**Usage:**
+
+```bash
+recce-cloud status
+```
+
+**Output:**
+
+- Shows logged-in user email (or "Not logged in")
+- Shows current project binding (organization/project or "Not bound")
+- Indicates configuration source (CLI flags, environment variables, or local config)
+
 ### `recce-cloud upload`
 
 Upload dbt artifacts to Recce Cloud session.

{recce_cloud-1.31.0 → recce_cloud-1.33.1}/pyproject.toml

@@ -8,6 +8,8 @@ license = {text = "Apache-2.0"}
 
 dependencies = [
     "click>=7.1",
+    "cryptography>=3.4",
+    "pyyaml>=6.0",
     "requests>=2.28.1",
     "rich>=12.0.0",
 ]
@@ -23,6 +25,12 @@ classifiers = [
     "Development Status :: 4 - Beta",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=4.6",
+    "flake8>=7.2.0",
+]
+
 [project.scripts]
 recce-cloud = "recce_cloud.cli:cloud_cli"
 
@@ -34,7 +42,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.version]
-path = "VERSION"
+path = "recce_cloud/VERSION"
 pattern = "(?P<version>.+)"
 
 [tool.hatch.metadata]
@@ -43,7 +51,12 @@ allow-direct-references = true
 [tool.hatch.metadata.hooks.custom]
 
 [tool.hatch.build.targets.wheel]
-packages = ["."]
+packages = ["recce_cloud"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "recce_cloud/**/*.py",
+    "recce_cloud/**/*.html",
+    "recce_cloud/VERSION",
+]
 
-[tool.hatch.build.targets.wheel.sources]
-"." = "recce_cloud"

recce_cloud-1.33.1/recce_cloud/VERSION

@@ -0,0 +1 @@
+1.33.1

recce_cloud-1.33.1/recce_cloud/__init__.py

@@ -0,0 +1,28 @@
+"""Recce Cloud - Lightweight CLI for Recce Cloud operations."""
+
+import os
+from importlib.metadata import PackageNotFoundError, version
+
+
+def get_version():
+    """Get version from package metadata or VERSION file."""
+    # Try importlib.metadata first (works for installed packages)
+    # Try both package names (nightly and official)
+    for pkg_name in ["recce-cloud-nightly", "recce-cloud"]:
+        try:
+            return version(pkg_name)
+        except PackageNotFoundError:
+            pass
+
+    # Fallback to VERSION file (for development with editable install)
+    # VERSION is now at recce_cloud/recce_cloud/VERSION (same dir as __init__.py)
+    version_file = os.path.join(os.path.dirname(__file__), "VERSION")
+    if os.path.exists(version_file):
+        with open(version_file) as fh:
+            return fh.read().strip()
+
+    # Last resort
+    return "unknown"
+
+
+__version__ = get_version()

{recce_cloud-1.31.0 → recce_cloud-1.33.1/recce_cloud}/api/client.py

@@ -1,13 +1,13 @@
 """
 Recce Cloud API clients for lightweight operations.
 
-Provides clients for session management and report generation.
+Provides clients for session management, organization/project listing, and report generation.
 """
 
 import json
 import logging
 import os
-from typing import Optional
+from typing import Any, Dict, List, Optional
 
 import requests
 
@@ -224,6 +224,285 @@ class RecceCloudClient:
             status_code=response.status_code,
         )
 
+    def upload_completed(self, session_id: str) -> dict:
+        """
+        Notify Recce Cloud that upload is complete for a session.
+
+        This triggers post-upload processing such as AI summary generation.
+
+        Args:
+            session_id: Session ID to notify completion for
+
+        Returns:
+            dict containing acknowledgement or empty dict
+
+        Raises:
+            RecceCloudException: If the request fails
+        """
+        api_url = f"{self.base_url_v2}/sessions/{session_id}/upload-completed"
+        response = self._request("POST", api_url)
+        if response.status_code in [200, 204]:
+            if response.status_code == 204 or not response.content:
+                return {}
+            return response.json()
+        if response.status_code == 403:
+            raise RecceCloudException(
+                reason=response.json().get("detail", "Permission denied"),
+                status_code=response.status_code,
+            )
+        if response.status_code == 404:
+            raise RecceCloudException(
+                reason="Session not found",
+                status_code=response.status_code,
+            )
+        raise RecceCloudException(
+            reason=response.text,
+            status_code=response.status_code,
+        )
+
+    def list_organizations(self) -> List[Dict[str, Any]]:
+        """
+        List all organizations the user has access to.
+
+        Returns:
+            List of organization dictionaries with id, name, slug fields.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations"
+        response = self._request("GET", api_url)
+
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+        return data.get("organizations", [])
+
+    def list_projects(self, org_id: str) -> List[Dict[str, Any]]:
+        """
+        List all projects in an organization.
+
+        Args:
+            org_id: Organization ID or slug.
+
+        Returns:
+            List of project dictionaries with id, name, slug fields.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects"
+        response = self._request("GET", api_url)
+
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+        return data.get("projects", [])
+
+    def get_organization(self, org_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific organization by ID or slug.
+
+        Args:
+            org_id: Organization ID or slug.
+
+        Returns:
+            Organization dictionary, or None if not found.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        orgs = self.list_organizations()
+        for org in orgs:
+            # Compare as strings to handle both int and str IDs
+            if str(org.get("id")) == str(org_id) or org.get("slug") == org_id or org.get("name") == org_id:
+                return org
+        return None
+
+    def get_project(self, org_id: str, project_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific project by ID or slug.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+
+        Returns:
+            Project dictionary, or None if not found.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        projects = self.list_projects(org_id)
+        for project in projects:
+            # Compare as strings to handle both int and str IDs
+            if (
+                str(project.get("id")) == str(project_id)
+                or project.get("slug") == project_id
+                or project.get("name") == project_id
+            ):
+                return project
+        return None
+
+    def list_sessions(
+        self,
+        org_id: str,
+        project_id: str,
+        session_name: Optional[str] = None,
+        session_type: Optional[str] = None,
+        branch: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List sessions in a project with optional filtering.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+            session_name: Filter by session name (exact match).
+            session_type: Filter by session type (e.g., "pr", "prod", "manual").
+            branch: Filter by branch name (exact match).
+            limit: Maximum number of results to return (1-1000).
+            offset: Number of results to skip for pagination.
+
+        Returns:
+            List of session dictionaries.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions"
+        params = {}
+        if session_name:
+            params["name"] = session_name
+        if session_type:
+            params["type"] = session_type
+        if branch:
+            params["branch"] = branch
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+
+        response = self._request("GET", api_url, params=params if params else None)
+
+        if response.status_code == 404:
+            raise RecceCloudException(
+                reason="Organization or project not found",
+                status_code=response.status_code,
+            )
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+        return data.get("sessions", [])
+
+    def get_session_by_name(
+        self,
+        org_id: str,
+        project_id: str,
+        session_name: str,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get a session by its name.
+
+        Uses the list sessions endpoint with filtering to find a session
+        by name, which is unique within a project.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+            session_name: The session name to look up.
+
+        Returns:
+            Session dictionary if found, None otherwise.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        sessions = self.list_sessions(
+            org_id=org_id,
+            project_id=project_id,
+            session_name=session_name,
+            limit=1,
+        )
+        if sessions:
+            return sessions[0]
+        return None
+
+    def create_session(
+        self,
+        org_id: str,
+        project_id: str,
+        session_name: str,
+        adapter_type: Optional[str] = None,
+        session_type: str = "manual",
+    ) -> Dict[str, Any]:
+        """
+        Create a new session with the given name.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+            session_name: The name for the new session.
+            adapter_type: dbt adapter type (e.g., "postgres", "snowflake").
+            session_type: Session type (default: "manual").
+
+        Returns:
+            Created session dictionary with id, name, and other fields.
+
+        Raises:
+            RecceCloudException: If the API call fails or session creation fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions"
+        data = {
+            "name": session_name,
+            "type": session_type,
+        }
+        if adapter_type:
+            data["adapter_type"] = adapter_type
+
+        response = self._request("POST", api_url, json=data)
+
+        if response.status_code == 404:
+            raise RecceCloudException(
+                reason="Organization or project not found",
+                status_code=response.status_code,
+            )
+        if response.status_code == 409:
+            raise RecceCloudException(
+                reason=f"Session with name '{session_name}' already exists",
+                status_code=response.status_code,
+            )
+        if response.status_code == 403:
+            raise RecceCloudException(
+                reason=response.json().get("detail", "Permission denied"),
+                status_code=response.status_code,
+            )
+        if response.status_code not in [200, 201]:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        result = response.json()
+        # Handle both direct session response and wrapped response
+        if "session" in result:
+            return result["session"]
+        return result
+
 
 class ReportClient:
     """Client for fetching reports from Recce Cloud API."""

recce_cloud-1.33.1/recce_cloud/auth/__init__.py

@@ -0,0 +1,21 @@
+"""
+Authentication module for Recce Cloud CLI.
+
+This module provides browser-based OAuth authentication and credential management.
+It is designed to be standalone (duplicated from Recce OSS) to support future
+repository separation.
+"""
+
+from recce_cloud.auth.profile import (
+    get_api_token,
+    get_user_id,
+    load_profile,
+    update_api_token,
+)
+
+__all__ = [
+    "get_api_token",
+    "get_user_id",
+    "load_profile",
+    "update_api_token",
+]

recce_cloud-1.33.1/recce_cloud/auth/callback_server.py

@@ -0,0 +1,128 @@
+"""
+One-time HTTP callback server for OAuth authentication.
+
+This server receives the encrypted token from Recce Cloud after
+browser-based authentication.
+"""
+
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import Optional
+from urllib.parse import parse_qs, urlparse
+
+
+class CallbackResult:
+    """Container for callback result."""
+
+    def __init__(self):
+        self.code: Optional[str] = None
+        self.error: Optional[str] = None
+
+
+def make_callback_handler(result: CallbackResult, on_success_html: str, on_error_html: str):
+    """
+    Create a one-time HTTP request handler.
+
+    Args:
+        result: CallbackResult object to store the received code.
+        on_success_html: HTML content to return on success.
+        on_error_html: HTML content to return on error.
+
+    Returns:
+        HTTP request handler class.
+    """
+
+    class OneTimeHTTPRequestHandler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            try:
+                parsed_url = urlparse(self.path)
+                query_params = parse_qs(parsed_url.query)
+
+                code = query_params.get("code", [None])[0]
+                if not code:
+                    result.error = "Missing 'code' parameter in callback"
+                    self._send_response(400, on_error_html)
+                    return
+
+                result.code = code
+                self._send_response(200, on_success_html)
+
+            except Exception as e:
+                result.error = str(e)
+                self._send_response(500, on_error_html)
+            finally:
+                # Shutdown server after handling the request
+                self.server.server_close()
+                threading.Thread(target=self.server.shutdown, daemon=True).start()
+
+        def _send_response(self, status_code: int, html_content: str):
+            self.send_response(status_code)
+            self.send_header("Content-Type", "text/html")
+            self.send_header("Content-Length", str(len(html_content.encode())))
+            self.end_headers()
+            self.wfile.write(html_content.encode())
+
+        def log_message(self, format, *args):
+            # Suppress default logging
+            pass
+
+    return OneTimeHTTPRequestHandler
+
+
+def run_callback_server(
+    port: int,
+    result: CallbackResult,
+    on_success_html: str,
+    on_error_html: str,
+    timeout: int = 300,
+) -> bool:
+    """
+    Run a one-time HTTP server to receive the OAuth callback.
+
+    Args:
+        port: Port to listen on.
+        result: CallbackResult object to store the received code.
+        on_success_html: HTML content to return on success.
+        on_error_html: HTML content to return on error.
+        timeout: Server timeout in seconds (default 5 minutes).
+
+    Returns:
+        True if callback was received, False if timeout or error.
+    """
+    handler = make_callback_handler(result, on_success_html, on_error_html)
+    server = HTTPServer(("localhost", port), handler)
+    server.timeout = timeout
+
+    try:
+        # Handle a single request
+        server.handle_request()
+        return result.code is not None
+    except Exception:
+        return False
+    finally:
+        server.server_close()
+
+
+def _load_template(filename: str) -> str:
+    """
+    Load HTML template from the templates directory.
+
+    Args:
+        filename: Name of the template file (e.g., 'success.html').
+
+    Returns:
+        HTML content as string.
+
+    Raises:
+        FileNotFoundError: If template file is not found.
+    """
+    templates_dir = Path(__file__).parent / "templates"
+    template_path = templates_dir / filename
+    with open(template_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# Load HTML templates from separate files
+SUCCESS_HTML = _load_template("success.html")
+ERROR_HTML = _load_template("error.html")