sitebay-mcp 0.1.1751179164__py3-none-any.whl

sitebay_mcp/__init__.py

@@ -0,0 +1,15 @@
+"""
+SiteBay MCP Server
+
+Provides Model Context Protocol (MCP) integration for SiteBay WordPress hosting platform.
+Allows Claude Code users to manage WordPress sites, execute commands, handle staging,
+backups, and more through natural language interactions.
+"""
+
+__version__ = "0.1.0"
+__author__ = "SiteBay"
+__email__ = "support@sitebay.org"
+
+from .server import main
+
+__all__ = ["main"]

sitebay_mcp/auth.py

@@ -0,0 +1,54 @@
+"""
+Authentication handling for SiteBay API
+"""
+
+import os
+from typing import Optional
+from .exceptions import AuthenticationError, ConfigurationError
+
+
+class SiteBayAuth:
+    """Handles SiteBay API authentication"""
+    
+    def __init__(self, api_token: Optional[str] = None):
+        """
+        Initialize authentication with API token
+        
+        Args:
+            api_token: SiteBay API token. If not provided, will try to get from environment
+        """
+        self.api_token = api_token or self._get_token_from_env()
+        if not self.api_token:
+            raise ConfigurationError(
+                "SiteBay API token is required. Set SITEBAY_API_TOKEN environment variable "
+                "or pass token directly to the server."
+            )
+    
+    def _get_token_from_env(self) -> Optional[str]:
+        """Get API token from environment variables"""
+        return os.getenv("SITEBAY_API_TOKEN")
+    
+    def get_headers(self) -> dict[str, str]:
+        """Get authentication headers for API requests"""
+        if not self.api_token:
+            raise AuthenticationError("No API token available")
+        
+        return {
+            "Authorization": f"Bearer {self.api_token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+    
+    def validate_token(self) -> bool:
+        """
+        Validate that the API token is properly formatted
+        This is a basic validation - actual verification happens on API calls
+        """
+        if not self.api_token:
+            return False
+        
+        # Basic token format validation
+        if len(self.api_token) < 20:  # Reasonable minimum length
+            return False
+            
+        return True

sitebay_mcp/client.py

@@ -0,0 +1,359 @@
+"""
+SiteBay API client for handling all API communications
+"""
+
+import httpx
+from typing import Any, Dict, List, Optional, Union
+from .auth import SiteBayAuth
+from .exceptions import APIError, AuthenticationError, SiteNotFoundError, ValidationError
+
+
+class SiteBayClient:
+    """Client for interacting with SiteBay API"""
+    
+    BASE_URL = "https://my.sitebay.org"
+    API_PREFIX = "/f/api/v1"
+    
+    def __init__(self, auth: SiteBayAuth, timeout: float = 30.0):
+        """
+        Initialize SiteBay API client
+        
+        Args:
+            auth: Authentication instance
+            timeout: Request timeout in seconds
+        """
+        self.auth = auth
+        self.timeout = timeout
+        self._client = httpx.AsyncClient(
+            base_url=self.BASE_URL,
+            timeout=timeout,
+            headers=self.auth.get_headers()
+        )
+    
+    async def __aenter__(self):
+        """Async context manager entry"""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self._client.aclose()
+    
+    async def close(self):
+        """Close the HTTP client"""
+        await self._client.aclose()
+    
+    def _get_url(self, endpoint: str) -> str:
+        """Get full URL for an API endpoint"""
+        if not endpoint.startswith("/"):
+            endpoint = "/" + endpoint
+        return f"{self.API_PREFIX}{endpoint}"
+    
+    def _format_validation_error(self, error_data: dict) -> str:
+        """
+        Format validation error details for better readability
+        
+        Args:
+            error_data: Error response from API
+            
+        Returns:
+            Formatted error message with field-specific details
+        """
+        if not error_data:
+            return "Validation failed"
+        
+        # Handle FastAPI/Pydantic validation error format
+        if "detail" in error_data:
+            detail = error_data["detail"]
+            
+            # If detail is a string, return it directly
+            if isinstance(detail, str):
+                return f"Validation Error: {detail}"
+            
+            # If detail is a list of validation errors
+            if isinstance(detail, list):
+                error_messages = []
+                for error in detail:
+                    if isinstance(error, dict):
+                        loc = error.get("loc", [])
+                        msg = error.get("msg", "Invalid value")
+                        field = " -> ".join(str(x) for x in loc) if loc else "unknown field"
+                        error_messages.append(f"{field}: {msg}")
+                
+                if error_messages:
+                    return f"Validation Error:\n" + "\n".join(f"  • {msg}" for msg in error_messages)
+        
+        # Handle other error formats
+        if "message" in error_data:
+            return f"Validation Error: {error_data['message']}"
+        
+        # Fallback - try to extract any useful information
+        if "errors" in error_data:
+            errors = error_data["errors"]
+            if isinstance(errors, dict):
+                error_messages = []
+                for field, messages in errors.items():
+                    if isinstance(messages, list):
+                        for msg in messages:
+                            error_messages.append(f"{field}: {msg}")
+                    else:
+                        error_messages.append(f"{field}: {messages}")
+                
+                if error_messages:
+                    return f"Validation Error:\n" + "\n".join(f"  • {msg}" for msg in error_messages)
+        
+        return f"Validation Error: {str(error_data)}"
+    
+    def _extract_field_errors(self, error_data: dict) -> dict:
+        """
+        Extract field-specific errors for programmatic access
+        
+        Args:
+            error_data: Error response from API
+            
+        Returns:
+            Dictionary mapping field names to error messages
+        """
+        field_errors = {}
+        
+        if not error_data:
+            return field_errors
+        
+        # Handle FastAPI/Pydantic validation error format
+        if "detail" in error_data and isinstance(error_data["detail"], list):
+            for error in error_data["detail"]:
+                if isinstance(error, dict):
+                    loc = error.get("loc", [])
+                    msg = error.get("msg", "Invalid value")
+                    field = " -> ".join(str(x) for x in loc) if loc else "unknown"
+                    field_errors[field] = msg
+        
+        # Handle other error formats
+        elif "errors" in error_data and isinstance(error_data["errors"], dict):
+            for field, messages in error_data["errors"].items():
+                if isinstance(messages, list):
+                    field_errors[field] = "; ".join(messages)
+                else:
+                    field_errors[field] = str(messages)
+        
+        return field_errors
+    
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Any:
+        """
+        Make an HTTP request to the SiteBay API
+        
+        Args:
+            method: HTTP method (GET, POST, PATCH, DELETE)
+            endpoint: API endpoint path
+            params: Query parameters
+            json_data: JSON body data
+            **kwargs: Additional httpx request arguments
+        
+        Returns:
+            Response data (parsed JSON or raw response)
+        
+        Raises:
+            APIError: For API errors
+            AuthenticationError: For authentication failures
+        """
+        url = self._get_url(endpoint)
+        
+        try:
+            response = await self._client.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json_data,
+                **kwargs
+            )
+            
+            # Handle different response codes
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid or expired API token")
+            elif response.status_code == 404:
+                raise SiteNotFoundError("Requested resource not found")
+            elif response.status_code == 422:
+                # Handle validation errors with detailed information
+                try:
+                    error_data = response.json()
+                    error_message = self._format_validation_error(error_data)
+                    field_errors = self._extract_field_errors(error_data)
+                except Exception:
+                    error_message = f"Validation Error: {response.text}"
+                    error_data = None
+                    field_errors = {}
+                
+                raise ValidationError(
+                    message=error_message,
+                    field_errors=field_errors
+                )
+            elif response.status_code >= 400:
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get("detail", f"API Error: {response.status_code}")
+                except Exception:
+                    error_message = f"API Error: {response.status_code} - {response.text}"
+                
+                raise APIError(
+                    message=error_message,
+                    status_code=response.status_code,
+                    response_data=error_data if 'error_data' in locals() else None
+                )
+            
+            # Try to parse JSON response
+            try:
+                return response.json()
+            except Exception:
+                # Return raw response if not JSON
+                return response.text
+                
+        except httpx.RequestError as e:
+            raise APIError(f"Network error: {str(e)}")
+    
+    async def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Make GET request"""
+        return await self._request("GET", endpoint, params=params)
+    
+    async def post(self, endpoint: str, json_data: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Make POST request"""
+        return await self._request("POST", endpoint, params=params, json_data=json_data)
+    
+    async def patch(self, endpoint: str, json_data: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Make PATCH request"""
+        return await self._request("PATCH", endpoint, params=params, json_data=json_data)
+    
+    async def delete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Make DELETE request"""
+        return await self._request("DELETE", endpoint, params=params)
+    
+    # Site Management Methods
+    async def list_sites(self, team_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List all sites for the user"""
+        params = {"team_id": team_id} if team_id else None
+        response = await self.get("/site", params=params)
+        return response.get("results", [])
+    
+    async def get_site(self, fqdn: str) -> Dict[str, Any]:
+        """Get details for a specific site"""
+        return await self.get(f"/site/{fqdn}")
+    
+    async def create_site(self, site_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new site"""
+        return await self.post("/site", json_data=site_data)
+    
+    async def update_site(self, fqdn: str, site_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update an existing site"""
+        return await self.patch(f"/site/{fqdn}", json_data=site_data)
+    
+    async def delete_site(self, fqdn: str) -> Dict[str, Any]:
+        """Delete a site"""
+        return await self.delete(f"/site/{fqdn}")
+    
+    # Site Operations Methods
+    async def execute_shell_command(self, fqdn: str, command: str) -> Any:
+        """Execute a shell command on a site"""
+        return await self.post(f"/site/{fqdn}/cmd", json_data={"cmd": command})
+    
+    async def edit_file(self, fqdn: str, file_path: str, content: str) -> str:
+        """Edit a file in the site's wp-content directory"""
+        return await self.post(
+            f"/site/{fqdn}/wpfile_diff_edit",
+            json_data={"path": file_path, "content": content}
+        )
+    
+    async def get_site_events(self, fqdn: str, after_datetime: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get site events"""
+        params = {"after_datetime": after_datetime} if after_datetime else None
+        response = await self.get(f"/site/{fqdn}/event", params=params)
+        return response.get("results", [])
+    
+    # Staging Methods
+    async def create_staging_site(self, fqdn: str, staging_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a staging site"""
+        return await self.post(f"/site/{fqdn}/stage", json_data=staging_data)
+    
+    async def delete_staging_site(self, fqdn: str) -> Dict[str, Any]:
+        """Delete a staging site"""
+        return await self.delete(f"/site/{fqdn}/stage")
+    
+    async def commit_staging_site(self, fqdn: str) -> Dict[str, Any]:
+        """Commit staging site to live"""
+        return await self.post(f"/site/{fqdn}/stage/commit")
+    
+    # Backup/Restore Methods
+    async def get_backup_commits(self, fqdn: str, number_to_fetch: int = 10) -> List[Dict[str, Any]]:
+        """Get backup commits for a site"""
+        params = {"number_to_fetch": number_to_fetch}
+        return await self.get(f"/site/{fqdn}/pit_restore/commits", params=params)
+    
+    async def create_restore(self, fqdn: str, restore_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a point-in-time restore"""
+        return await self.post(f"/site/{fqdn}/pit_restore", json_data=restore_data)
+    
+    async def list_restores(self, fqdn: str) -> List[Dict[str, Any]]:
+        """List all restores for a site"""
+        response = await self.get(f"/site/{fqdn}/pit_restore")
+        return response.get("results", [])
+    
+    # External Path Methods
+    async def list_external_paths(self, fqdn: str) -> List[Dict[str, Any]]:
+        """List external paths for a site"""
+        response = await self.get(f"/site/{fqdn}/external_path")
+        return response.get("results", [])
+    
+    async def create_external_path(self, fqdn: str, path_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create an external path"""
+        return await self.post(f"/site/{fqdn}/external_path", json_data=path_data)
+    
+    async def update_external_path(self, fqdn: str, path_id: str, path_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update an external path"""
+        return await self.patch(f"/site/{fqdn}/external_path/{path_id}", json_data=path_data)
+    
+    async def delete_external_path(self, fqdn: str, path_id: str) -> Dict[str, Any]:
+        """Delete an external path"""
+        return await self.delete(f"/site/{fqdn}/external_path/{path_id}")
+    
+    # Proxy Methods
+    async def wordpress_proxy(self, proxy_data: Dict[str, Any]) -> Any:
+        """Proxy request to WordPress API"""
+        return await self.post("/wp-proxy", json_data=proxy_data)
+    
+    async def shopify_proxy(self, proxy_data: Dict[str, Any]) -> Any:
+        """Proxy request to Shopify API"""
+        return await self.post("/shopify-proxy", json_data=proxy_data)
+    
+    async def posthog_proxy(self, proxy_data: Dict[str, Any]) -> Any:
+        """Proxy request to PostHog API"""
+        return await self.post("/posthog-proxy", json_data=proxy_data)
+    
+    # Team Methods
+    async def list_teams(self) -> List[Dict[str, Any]]:
+        """List user teams"""
+        response = await self.get("/team")
+        return response.get("results", [])
+    
+    # Template and Region Methods
+    async def list_templates(self) -> List[Dict[str, Any]]:
+        """List available templates"""
+        response = await self.get("/template")
+        return response.get("results", [])
+    
+    async def list_regions(self) -> List[Dict[str, Any]]:
+        """List available regions"""
+        return await self.get("/region")
+    
+    # Account Methods
+    async def get_affiliate_referrals(self) -> List[Dict[str, Any]]:
+        """Get affiliate referrals"""
+        response = await self.get("/account/referred_user")
+        return response.get("results", [])
+    
+    async def create_checkout_session(self, checkout_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create Stripe checkout session"""
+        return await self.post("/create_checkout_session", json_data=checkout_data)

sitebay_mcp/exceptions.py

@@ -0,0 +1,45 @@
+"""
+Custom exceptions for SiteBay MCP Server
+"""
+
+
+class SiteBayError(Exception):
+    """Base exception for SiteBay MCP operations"""
+    pass
+
+
+class AuthenticationError(SiteBayError):
+    """Raised when authentication fails"""
+    pass
+
+
+class APIError(SiteBayError):
+    """Raised when SiteBay API returns an error"""
+    
+    def __init__(self, message: str, status_code: int = None, response_data: dict = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_data = response_data
+
+
+class ValidationError(SiteBayError):
+    """Raised when request validation fails"""
+    
+    def __init__(self, message: str, field_errors: dict = None):
+        super().__init__(message)
+        self.field_errors = field_errors or {}
+
+
+class SiteNotFoundError(SiteBayError):
+    """Raised when requested site is not found"""
+    pass
+
+
+class TeamNotFoundError(SiteBayError):
+    """Raised when requested team is not found"""
+    pass
+
+
+class ConfigurationError(SiteBayError):
+    """Raised when configuration is invalid"""
+    pass

sitebay_mcp/resources.py

@@ -0,0 +1,171 @@
+"""
+SiteBay MCP Resources
+
+Provides readable resources for site configurations, logs, and metrics.
+"""
+
+import json
+from typing import Any, Dict, List
+from fastmcp.server import Context
+from .client import SiteBayClient
+from .exceptions import SiteBayError
+
+
+async def get_site_config_resource(ctx: Context, site_fqdn: str) -> str:
+    """
+    Get site configuration as a resource.
+    
+    Args:
+        ctx: FastMCP context
+        site_fqdn: Site domain name
+    
+    Returns:
+        JSON formatted site configuration
+    """
+    try:
+        ctx.logger.info(f"Fetching configuration resource for: {site_fqdn}")
+        
+        from .server import initialize_client
+        client = await initialize_client()
+        
+        site = await client.get_site(site_fqdn)
+        
+        # Format as readable configuration
+        config = {
+            "site_info": {
+                "domain": site.get("fqdn"),
+                "title": site.get("wp_title"),
+                "status": site.get("status"),
+                "region": site.get("region_name"),
+                "created": site.get("created_at"),
+                "updated": site.get("updated_at")
+            },
+            "technical_specs": {
+                "php_version": site.get("php_version"),
+                "mysql_version": site.get("mysql_version"),
+                "wordpress_version": site.get("wp_version"),
+                "git_enabled": site.get("git_enabled", False)
+            },
+            "urls": {
+                "site_url": site.get("site_url"),
+                "admin_url": site.get("admin_url")
+            },
+            "features": {
+                "staging_available": bool(site.get("staging_site")),
+                "git_integration": site.get("git_enabled", False),
+                "backup_enabled": True  # SiteBay always has backups
+            }
+        }
+        
+        return json.dumps(config, indent=2)
+        
+    except SiteBayError as e:
+        ctx.logger.error(f"Error fetching config for {site_fqdn}: {str(e)}")
+        return f"Error: {str(e)}"
+
+
+async def get_site_events_resource(ctx: Context, site_fqdn: str, limit: int = 50) -> str:
+    """
+    Get site events/logs as a resource.
+    
+    Args:
+        ctx: FastMCP context
+        site_fqdn: Site domain name
+        limit: Maximum number of events to fetch
+    
+    Returns:
+        JSON formatted site events
+    """
+    try:
+        ctx.logger.info(f"Fetching events resource for: {site_fqdn}")
+        
+        from .server import initialize_client
+        client = await initialize_client()
+        
+        events = await client.get_site_events(site_fqdn)
+        
+        # Limit and format events
+        limited_events = events[:limit]
+        
+        formatted_events = {
+            "site": site_fqdn,
+            "total_events": len(events),
+            "showing": len(limited_events),
+            "events": [
+                {
+                    "timestamp": event.get("created_at"),
+                    "type": event.get("event_type"),
+                    "status": event.get("status"),
+                    "description": event.get("description"),
+                    "metadata": event.get("metadata", {})
+                }
+                for event in limited_events
+            ]
+        }
+        
+        return json.dumps(formatted_events, indent=2)
+        
+    except SiteBayError as e:
+        ctx.logger.error(f"Error fetching events for {site_fqdn}: {str(e)}")
+        return f"Error: {str(e)}"
+
+
+async def get_account_summary_resource(ctx: Context) -> str:
+    """
+    Get account summary as a resource.
+    
+    Args:
+        ctx: FastMCP context
+    
+    Returns:
+        JSON formatted account summary
+    """
+    try:
+        ctx.logger.info("Fetching account summary resource")
+        
+        from .server import initialize_client
+        client = await initialize_client()
+        
+        # Get sites and teams in parallel
+        sites = await client.list_sites()
+        teams = await client.list_teams()
+        regions = await client.list_regions()
+        templates = await client.list_templates()
+        
+        summary = {
+            "account_overview": {
+                "total_sites": len(sites),
+                "total_teams": len(teams),
+                "available_regions": len(regions),
+                "available_templates": len(templates)
+            },
+            "sites_by_status": {},
+            "sites_by_region": {},
+            "recent_sites": []
+        }
+        
+        # Analyze sites
+        for site in sites:
+            status = site.get("status", "unknown")
+            summary["sites_by_status"][status] = summary["sites_by_status"].get(status, 0) + 1
+            
+            region = site.get("region_name", "unknown")
+            summary["sites_by_region"][region] = summary["sites_by_region"].get(region, 0) + 1
+        
+        # Get 5 most recent sites
+        sorted_sites = sorted(sites, key=lambda x: x.get("created_at", ""), reverse=True)
+        summary["recent_sites"] = [
+            {
+                "domain": site.get("fqdn"),
+                "status": site.get("status"),
+                "created": site.get("created_at"),
+                "region": site.get("region_name")
+            }
+            for site in sorted_sites[:5]
+        ]
+        
+        return json.dumps(summary, indent=2)
+        
+    except SiteBayError as e:
+        ctx.logger.error(f"Error fetching account summary: {str(e)}")
+        return f"Error: {str(e)}"