prismor-cli 1.3.0__py3-none-any.whl

prismor/api.py

@@ -0,0 +1,770 @@
+"""API client for Prismor security scanning service."""
+
+import os
+import re
+import time
+import requests
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse
+
+
+def _active_org_id() -> Optional[str]:
+    """The org the user switched to via `prismor org switch`, if any."""
+    try:
+        from prismor import cli_config
+        return cli_config.active_org_id()
+    except Exception:
+        return None
+
+DEFAULT_SCAN_POLL_INTERVAL_SECONDS = max(int(os.environ.get("PRISMOR_SCAN_POLL_INTERVAL_SECONDS", "5")), 1)
+DEFAULT_SCAN_MAX_WAIT_SECONDS = max(int(os.environ.get("PRISMOR_SCAN_MAX_WAIT_SECONDS", "1800")), 60)
+DEFAULT_SCAN_STATUS_RETRY_LIMIT = max(int(os.environ.get("PRISMOR_SCAN_STATUS_RETRY_LIMIT", "5")), 0)
+
+
+class PrismorAPIError(Exception):
+    """Custom exception for Prismor API errors."""
+    pass
+
+
+def retry_request(func, max_retries=3, backoff_factor=2):
+    """Retry a request function with exponential backoff.
+    
+    Args:
+        func: Function to retry (should return requests.Response)
+        max_retries: Maximum number of retry attempts
+        backoff_factor: Multiplier for delay between retries
+        
+    Returns:
+        Response from the function
+        
+    Raises:
+        Exception: If all retries fail
+    """
+    last_exception = None
+    
+    for attempt in range(max_retries):
+        try:
+            return func()
+        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:
+            last_exception = e
+            if attempt < max_retries - 1:
+                delay = backoff_factor ** attempt
+                time.sleep(delay)
+                continue
+            raise
+        except Exception as e:
+            # Don't retry on other exceptions
+            raise
+    
+    # If we get here, all retries failed
+    raise last_exception
+
+
+def parse_github_repo(repo_input: str) -> str:
+    """Extract user/repo_name from various GitHub URL formats or return as-is if already in correct format.
+    
+    This function handles multiple GitHub URL formats:
+    - user/repo_name (already in correct format)
+    - https://github.com/user/repo_name
+    - https://www.github.com/user/repo_name
+    - http://github.com/user/repo_name
+    - http://www.github.com/user/repo_name
+    - github.com/user/repo_name
+    - www.github.com/user/repo_name
+    - git@github.com:user/repo_name.git
+    - https://github.com/user/repo_name.git
+    - https://github.com/user/repo_name/
+    - https://github.com/user/repo_name#branch
+    - https://github.com/user/repo_name/tree/branch
+    - https://github.com/user/repo_name/blob/branch/file
+    
+    Args:
+        repo_input: Repository input in any of the supported formats
+        
+    Returns:
+        Repository in "user/repo_name" format
+        
+    Raises:
+        PrismorAPIError: If the input format is not recognized or invalid
+    """
+    if not repo_input or not isinstance(repo_input, str):
+        raise PrismorAPIError("Repository input cannot be empty")
+    
+    # Validate repository name characters (GitHub allows alphanumeric, hyphens, underscores, dots)
+    def validate_repo_part(part: str, part_name: str) -> None:
+        if not part:
+            raise PrismorAPIError(f"{part_name} cannot be empty")
+        if len(part) > 100:
+            raise PrismorAPIError(f"{part_name} is too long (max 100 characters)")
+        # GitHub allows alphanumeric, hyphens, underscores, dots, but not starting/ending with special chars
+        if not re.match(r'^[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?$', part):
+            raise PrismorAPIError(
+                f"Invalid {part_name}: '{part}'. Must contain only alphanumeric characters, "
+                "hyphens, underscores, or dots, and cannot start or end with special characters."
+            )
+    
+    repo_input = repo_input.strip()
+    
+    # If it's already in user/repo format (no protocol, no domain), return as-is
+    if "/" in repo_input and not any(repo_input.startswith(prefix) for prefix in 
+                                    ["http://", "https://", "git@", "github.com", "www.github.com"]):
+        # Validate it has exactly one slash and both parts are non-empty
+        parts = repo_input.split("/")
+        if len(parts) == 2 and parts[0] and parts[1]:
+            validate_repo_part(parts[0], "Username")
+            validate_repo_part(parts[1], "Repository name")
+            return repo_input
+        else:
+            raise PrismorAPIError(f"Invalid repository format: {repo_input}. Expected 'user/repo_name'")
+    
+    # Handle SSH format: git@github.com:user/repo.git
+    if repo_input.startswith("git@github.com:"):
+        repo_part = repo_input[15:]  # Remove "git@github.com:"
+        # Remove .git suffix if present
+        if repo_part.endswith(".git"):
+            repo_part = repo_part[:-4]
+        if "/" in repo_part:
+            return repo_part
+        else:
+            raise PrismorAPIError(f"Invalid SSH repository format: {repo_input}")
+    
+    # Handle HTTP/HTTPS URLs
+    if repo_input.startswith(("http://", "https://")):
+        try:
+            parsed = urlparse(repo_input)
+            hostname = parsed.hostname.lower()
+            
+            # Check if it's a GitHub URL
+            if hostname in ["github.com", "www.github.com"]:
+                path = parsed.path.strip("/")
+                
+                # Remove .git suffix if present
+                if path.endswith(".git"):
+                    path = path[:-4]
+                
+                # Split path and extract user/repo
+                path_parts = path.split("/")
+                if len(path_parts) >= 2:
+                    user = path_parts[0]
+                    repo = path_parts[1]
+                    
+                    # Handle special GitHub paths like /tree/branch, /blob/branch/file
+                    if len(path_parts) > 2 and path_parts[2] in ["tree", "blob"]:
+                        # This is a branch/file reference, just take user/repo
+                        pass
+                    
+                    if user and repo:
+                        return f"{user}/{repo}"
+                    else:
+                        raise PrismorAPIError(f"Invalid GitHub URL format: {repo_input}")
+                else:
+                    raise PrismorAPIError(f"Invalid GitHub URL format: {repo_input}")
+            else:
+                raise PrismorAPIError(f"Not a GitHub URL: {repo_input}")
+                
+        except Exception as e:
+            raise PrismorAPIError(f"Failed to parse URL: {repo_input}. Error: {str(e)}")
+    
+    # Handle bare domain formats: github.com/user/repo or www.github.com/user/repo
+    if repo_input.startswith(("github.com/", "www.github.com/")):
+        # Remove domain prefix
+        if repo_input.startswith("github.com/"):
+            repo_part = repo_input[11:]  # Remove "github.com/"
+        else:  # www.github.com/
+            repo_part = repo_input[15:]  # Remove "www.github.com/"
+        
+        # Remove .git suffix if present
+        if repo_part.endswith(".git"):
+            repo_part = repo_part[:-4]
+        
+        # Remove trailing slash
+        repo_part = repo_part.rstrip("/")
+        
+        # Split and validate
+        parts = repo_part.split("/")
+        if len(parts) >= 2:
+            user = parts[0]
+            repo = parts[1]
+            
+            # Handle special GitHub paths like /tree/branch, /blob/branch/file
+            if len(parts) > 2 and parts[2] in ["tree", "blob"]:
+                # This is a branch/file reference, just take user/repo
+                pass
+            
+            if user and repo:
+                return f"{user}/{repo}"
+            else:
+                raise PrismorAPIError(f"Invalid repository format: {repo_input}")
+        else:
+            raise PrismorAPIError(f"Invalid repository format: {repo_input}")
+    
+    # If we get here, the format is not recognized
+    raise PrismorAPIError(
+        f"Unrecognized repository format: {repo_input}. "
+        "Supported formats: 'user/repo', 'https://github.com/user/repo', "
+        "'git@github.com:user/repo.git', or 'github.com/user/repo'"
+    )
+
+
+class PrismorClient:
+    """Client for interacting with Prismor API."""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the Prismor API client.
+        
+        Args:
+            api_key: Prismor API key. If not provided, will look for PRISMOR_API_KEY env var.
+        """
+        self.api_key = api_key or os.environ.get("PRISMOR_API_KEY")
+        if not self.api_key:
+            raise PrismorAPIError(
+                "PRISMOR_API_KEY environment variable is not set. "
+                "Please specify your API key. You can generate one for free at https://www.prismor.dev/cli\n"
+                "Set it with: export PRISMOR_API_KEY=your_api_key"
+            )
+        
+        # self.base_url = "http://localhost:3000"
+        self.base_url = os.environ.get("PRISMOR_CLI_URL", "https://prismor.dev")
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    def authenticate(self) -> Dict[str, Any]:
+        """Authenticate with the Prismor API using the API key.
+        
+        Returns:
+            Dictionary containing user information and repositories
+            
+        Raises:
+            PrismorAPIError: If authentication fails
+        """
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/cli/auth",
+                json={"apiKey": self.api_key},
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            
+            if response.status_code == 401:
+                raise PrismorAPIError("Invalid API key. Please check your PRISMOR_API_KEY.")
+            
+            if response.status_code == 400:
+                raise PrismorAPIError("API key is required.")
+            
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Authentication failed")
+                raise PrismorAPIError(f"Authentication error: {error_msg}")
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError("Authentication request timed out.")
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Authentication request failed: {str(e)}")
+    
+    def normalize_repo_url(self, repo: str) -> str:
+        """Normalize repository input to a full GitHub URL.
+        
+        Args:
+            repo: Repository in various formats (username/repo, GitHub URL, etc.)
+            
+        Returns:
+            Full GitHub repository URL
+        """
+        # Use the comprehensive parser to extract user/repo_name
+        repo_name = parse_github_repo(repo)
+        
+        # Convert to full GitHub URL
+        return f"https://github.com/{repo_name}"
+    
+    def list_orgs(self) -> Dict[str, Any]:
+        """List the organizations this API key's user belongs to."""
+        resp = requests.post(
+            f"{self.base_url}/api/cli/orgs",
+            json={"api_key": self.api_key},
+            headers=self.headers,
+            timeout=30,
+        )
+        if resp.status_code == 401:
+            raise PrismorAPIError("Invalid API key. Please check your PRISMOR_API_KEY.")
+        resp.raise_for_status()
+        return resp.json()
+
+    # ── Org controls (policy-as-code, read-only listings) ──────────────────
+    def _org_param(self, org_id: Optional[str]) -> str:
+        if not org_id:
+            try:
+                from prismor import cli_config
+                org_id = cli_config.active_org_id()
+            except Exception:
+                org_id = None
+        return f"?orgId={org_id}" if org_id else ""
+
+    def _cli_admin_get(self, path: str, org_id: Optional[str]) -> Dict[str, Any]:
+        resp = requests.get(f"{self.base_url}{path}{self._org_param(org_id)}", headers=self.headers, timeout=30)
+        if not resp.ok:
+            try:
+                msg = resp.json().get("message") or resp.text
+            except Exception:
+                msg = resp.text
+            raise PrismorAPIError(msg or f"Request failed ({resp.status_code})")
+        return resp.json()
+
+    def get_org_policy(self, org_id: Optional[str] = None) -> Dict[str, Any]:
+        """Fetch the active org policy (YAML + version)."""
+        return self._cli_admin_get("/api/cli/admin/policy", org_id)
+
+    def apply_org_policy(self, yaml_text: str, org_id: Optional[str] = None, dry_run: bool = False) -> Dict[str, Any]:
+        """Apply (or dry-run validate) an org policy YAML. Requires an admin-scoped key."""
+        body: Dict[str, Any] = {"yaml": yaml_text, "dryRun": dry_run}
+        if not org_id:
+            try:
+                from prismor import cli_config
+                org_id = cli_config.active_org_id()
+            except Exception:
+                org_id = None
+        if org_id:
+            body["orgId"] = org_id
+        resp = requests.post(
+            f"{self.base_url}/api/cli/admin/policy",
+            json=body,
+            headers={**self.headers, "Content-Type": "application/json"},
+            timeout=30,
+        )
+        if not resp.ok:
+            try:
+                msg = resp.json().get("message") or resp.text
+            except Exception:
+                msg = resp.text
+            raise PrismorAPIError(msg or f"Apply failed ({resp.status_code})")
+        return resp.json()
+
+    def list_devices(self, org_id: Optional[str] = None) -> Dict[str, Any]:
+        return self._cli_admin_get("/api/cli/admin/devices", org_id)
+
+    def list_members(self, org_id: Optional[str] = None) -> Dict[str, Any]:
+        return self._cli_admin_get("/api/cli/admin/members", org_id)
+
+    def scan(
+        self,
+        repo: str,
+        scan: bool = False,
+        sbom: bool = False,
+        detect_secret: bool = False,
+        fullscan: bool = False,
+        branch: Optional[str] = None,
+        action_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Perform security scan on a GitHub repository.
+        
+        Args:
+            repo: Repository URL or username/repo format
+            scan: Enable vulnerability scanning
+            sbom: Enable SBOM generation
+            detect_secret: Enable secret detection
+            fullscan: Enable all scan types
+            branch: Specific branch to scan (defaults to main/master)
+            
+        Returns:
+            Dictionary containing scan results
+        """
+        repo_url = self.normalize_repo_url(repo)
+        
+        # First authenticate to get user info
+        auth_response = self.authenticate()
+        user_info = auth_response.get("user", {})
+        
+        # Prepare request payload for CLI scan
+        payload = {
+            "repo_url": repo_url,
+            "api_key": self.api_key,
+            "scan": scan or fullscan,
+            "sbom": sbom or fullscan,
+            "detect_secret": detect_secret or fullscan,
+            "fullscan": fullscan,
+            "branch": branch,
+            "action_id": action_id,
+            "github_token": os.environ.get("GITHUB_TOKEN"),
+            "org_id": _active_org_id(),  # attribute to the active org (prismor org switch)
+        }
+        
+        try:
+            # Note: Vulnerability scans now run asynchronously and can take up to 10 minutes
+            # The web API handles polling internally, so we just need a longer timeout
+            # Use retry logic for network resilience
+            def make_request():
+                return requests.post(
+                    f"{self.base_url}/api/cli/scan",
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                    timeout=600  # 10 minute timeout to accommodate async vulnerability scans
+                )
+            
+            response = retry_request(make_request, max_retries=3)
+            
+            if response.status_code == 401:
+                error_data = response.json()
+                if error_data.get("action") == "integrate_github":
+                    raise PrismorAPIError(
+                        f"{error_data.get('message', 'GitHub integration required')}\n"
+                        f"Please visit: {error_data.get('integration_url', 'https://prismor.dev/dashboard')}"
+                    )
+                raise PrismorAPIError("Invalid API key. Please check your PRISMOR_API_KEY.")
+            
+            if response.status_code == 404:
+                raise PrismorAPIError("CLI scan endpoint not found. Please check if CLI endpoints are available.")
+            
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Unknown error")
+                raise PrismorAPIError(f"API error: {error_msg}")
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            # Handle the new response format from CLI endpoint
+            if result.get("ok") and result.get("status") == "accepted" and "job_id" in result:
+                job_id = result["job_id"]
+                poll_interval = DEFAULT_SCAN_POLL_INTERVAL_SECONDS
+                max_wait_seconds = DEFAULT_SCAN_MAX_WAIT_SECONDS
+                status_retry_limit = DEFAULT_SCAN_STATUS_RETRY_LIMIT
+                started_at = time.time()
+                transient_failures = 0
+
+                # Poll for completion with a hard timeout to avoid infinite hangs in CI.
+                while True:
+                    elapsed = time.time() - started_at
+                    if elapsed > max_wait_seconds:
+                        raise PrismorAPIError(
+                            f"Scan timed out after {max_wait_seconds} seconds. "
+                            f"Job ID: {job_id}. Check status with: prismor scan-status {job_id}"
+                        )
+
+                    time.sleep(poll_interval)
+                    
+                    try:
+                        status_data = self.check_scan_status(job_id)
+                        transient_failures = 0
+                        status = status_data.get("status")
+                        
+                        if status in {"completed", "success"}:
+                            # Return the results
+                            if "results" in status_data:
+                                return status_data["results"]
+                            return status_data
+                        
+                        if status in {"failed", "error", "cancelled"}:
+                            error_msg = status_data.get("error") or status_data.get("message") or "Unknown error"
+                            raise PrismorAPIError(f"Scan failed: {error_msg}")
+                            
+                    except PrismorAPIError as e:
+                        error_text = str(e).lower()
+                        is_transient = (
+                            "timed out" in error_text
+                            or "failed to connect" in error_text
+                            or "request failed" in error_text
+                            or "502" in error_text
+                            or "503" in error_text
+                            or "504" in error_text
+                        )
+                        if is_transient and transient_failures < status_retry_limit:
+                            transient_failures += 1
+                            continue
+                        raise
+
+            if result.get("ok") and "results" in result:
+                return result["results"]
+            return result
+            
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError(
+                "Request timed out. The repository scan is taking longer than expected. "
+                "Large repositories may require more time. Please try again or check the dashboard for results."
+            )
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Request failed: {str(e)}")
+    
+    def start_vulnerability_scan(
+        self,
+        repo: str,
+        branch: Optional[str] = None,
+        github_token: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Start a vulnerability scan and return immediately with a job_id.
+        
+        This method directly calls the backend API to start an async scan.
+        Use check_scan_status() to poll for completion.
+        
+        Args:
+            repo: Repository URL or username/repo format
+            branch: Specific branch to scan (defaults to main)
+            github_token: Optional GitHub token. If not provided, will try to get from env var GITHUB_TOKEN
+            
+        Returns:
+            Dictionary containing job_id and status information
+            
+        Raises:
+            PrismorAPIError: If request fails
+        """
+        # Directly call the backend API
+        backend_url = os.environ.get(
+            "PRISMOR_BACKEND_URL", 
+            "https://2dlxuia6i5.execute-api.us-east-1.amazonaws.com/prod"
+        )
+        
+        repo_url = self.normalize_repo_url(repo)
+        
+        # Get GitHub token from parameter, env var, or raise error
+        gh_token = github_token or os.environ.get("GITHUB_TOKEN")
+        
+        if not gh_token:
+            raise PrismorAPIError(
+                "GitHub token required. Provide it as --token, set the GITHUB_TOKEN environment variable, "
+                "or use 'prismor --repo <repo> --scan' which handles GitHub authentication automatically."
+            )
+        
+        try:
+            response = requests.post(
+                f"{backend_url}/scan",
+                json={
+                    "repo_url": repo_url,
+                    "token": gh_token,
+                    "branch": branch or "main"
+                },
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Unknown error")
+                raise PrismorAPIError(f"API error: {error_msg}")
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError("Request timed out.")
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Request failed: {str(e)}")
+    
+    def check_scan_status(self, job_id: str) -> Dict[str, Any]:
+        """Check the status of a vulnerability scan job.
+        
+        This method directly calls the backend API to check scan status.
+        Use this when you have a job_id from starting an async scan.
+        
+        Args:
+            job_id: The job ID returned from starting a scan
+            
+        Returns:
+            Dictionary containing scan status and results if completed
+            
+        Raises:
+            PrismorAPIError: If request fails
+        """
+
+        # Call the Web API to check status (which checks the DB populate by callbacks)
+        # We do NOT call the backend directly because the async worker relies on callbacks to update state
+        
+        try:
+            response = requests.get(
+                f"{self.base_url}/api/cli/scan/status/{job_id}",
+                headers={
+                    "Content-Type": "application/json",
+                    # Authenticate so the control plane returns the (org-scoped)
+                    # scan results, not just the bare status. The key also
+                    # scopes the job to the caller's org.
+                    "Authorization": f"Bearer {self.api_key}",
+                },
+                params={"api_key": self.api_key},
+                timeout=30
+            )
+            
+            if response.status_code == 404:
+                raise PrismorAPIError(f"Scan job '{job_id}' not found.")
+            
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Unknown error")
+                raise PrismorAPIError(f"API error: {error_msg}")
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError("Request timed out.")
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Request failed: {str(e)}")
+    
+    def trigger_autofix(
+        self,
+        repo: str,
+        branch: Optional[str] = None,
+        instruction: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Trigger AI auto-fix for a repository and return a job_id immediately.
+
+        Args:
+            repo: Repository URL or username/repo format
+            branch: Base branch to apply fixes on (defaults to main)
+            instruction: Custom fix instruction; if omitted a sensible default is used
+
+        Returns:
+            Dictionary containing job_id and status
+        """
+        repo_url = self.normalize_repo_url(repo)
+
+        payload: Dict[str, Any] = {
+            "api_key": self.api_key,
+            "repo_url": repo_url,
+            "branch": branch,
+            "org_id": _active_org_id(),  # attribute to the active org (prismor org switch)
+        }
+        if instruction:
+            payload["instruction"] = instruction
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/cli/fix",
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=30,
+            )
+
+            if response.status_code == 401:
+                error_data = response.json()
+                raise PrismorAPIError(error_data.get("error", "Unauthorized"))
+
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Unknown error")
+                raise PrismorAPIError(f"API error: {error_msg}")
+
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError("Request timed out.")
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Request failed: {str(e)}")
+
+    def check_fix_status(self, job_id: str) -> Dict[str, Any]:
+        """Check the status of an auto-fix job.
+
+        Args:
+            job_id: The job ID returned by trigger_autofix()
+
+        Returns:
+            Dictionary containing job status, pr_url, etc.
+        """
+        try:
+            response = requests.get(
+                f"{self.base_url}/api/cli/fix/status/{job_id}",
+                params={"api_key": self.api_key},
+                headers={"Content-Type": "application/json"},
+                timeout=30,
+            )
+
+            if response.status_code == 404:
+                raise PrismorAPIError(f"Fix job '{job_id}' not found.")
+
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Unknown error")
+                raise PrismorAPIError(f"API error: {error_msg}")
+
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError("Request timed out.")
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Request failed: {str(e)}")
+
+    def get_repositories(self) -> Dict[str, Any]:
+        """Get user's repositories.
+        
+        Returns:
+            Dictionary containing user repositories
+            
+        Raises:
+            PrismorAPIError: If request fails
+        """
+        auth_response = self.authenticate()
+        user_info = auth_response.get("user", {})
+        return {
+            "repositories": user_info.get("repositories", []),
+            "user": {
+                "id": user_info.get("id"),
+                "email": user_info.get("email"),
+                "name": user_info.get("name")
+            }
+        }
+    
+    def get_repository_by_name(self, repo_name: str) -> Dict[str, Any]:
+        """Get repository ID by repository name.
+        
+        Args:
+            repo_name: Repository name (e.g., "username/repo")
+            
+        Returns:
+            Dictionary containing repository information including ID
+            
+        Raises:
+            PrismorAPIError: If request fails
+        """
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/repositories/by-name",
+                json={
+                    "apiKey": self.api_key,
+                    "repoName": repo_name
+                },
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            
+            if response.status_code == 401:
+                raise PrismorAPIError("Invalid API key. Please check your PRISMOR_API_KEY.")
+            
+            if response.status_code == 404:
+                raise PrismorAPIError(f"Repository '{repo_name}' not found.")
+            
+            if response.status_code >= 400:
+                error_msg = response.json().get("error", "Unknown error")
+                raise PrismorAPIError(f"API error: {error_msg}")
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.Timeout:
+            raise PrismorAPIError("Request timed out.")
+        except requests.exceptions.ConnectionError:
+            raise PrismorAPIError(
+                "Failed to connect to Prismor API. Please check your internet connection."
+            )
+        except requests.exceptions.RequestException as e:
+            raise PrismorAPIError(f"Request failed: {str(e)}")