suprema-biostar-mcp 1.0.1__py3-none-any.whl

biostar_x_mcp_server/handlers/auth_handler.py

@@ -0,0 +1,216 @@
+import logging
+from typing import Sequence, Dict, Any
+from mcp.types import TextContent
+import httpx
+from .base_handler import BaseHandler
+from ..utils import get_timezone_offset, get_timezone_string
+
+logger = logging.getLogger(__name__)
+
+
+class AuthHandler(BaseHandler):
+    """Handle authentication-related operations."""
+    
+    async def login(self, args: Dict[str, Any]) -> Sequence[TextContent]:
+        """Login to BioStar 2."""
+        try:
+            # Get credentials from args or config
+            username = args.get("username") or self.session.config.biostar_username
+            password = args.get("password") or self.session.config.biostar_password
+            
+            if not username or not password:
+                return self.error_response(
+                    "Missing credentials",
+                    {"message": "Username and password are required. Set them in .env or provide as arguments."}
+                )
+            
+            # Make direct login API call
+            logger.info(f"Attempting to login to BioStar at: {self.session.config.biostar_url}")
+            
+            # Create client with SSL settings
+            transport = None
+            if not self.session.config.verify_ssl:
+                import ssl
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+                transport = httpx.AsyncHTTPTransport(verify=ssl_context)
+            
+            api_base = self.session.config.biostar_url
+            # api_base = "https://127.0.0.1:443"
+            async with httpx.AsyncClient(
+                transport=transport,
+                verify=False,
+                follow_redirects=True
+            ) as client:
+                logger.info(f"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Login with: {username} and {password} xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
+                response = await client.post(
+                    f"{api_base}/api/login",
+                    json={
+                        "User": {
+                            "login_id": username,
+                            "password": password
+                        }
+                    },
+                    headers={
+                        "Content-Type": "application/json"
+                    },
+                    timeout=self.session.config.api_timeout
+                )
+                
+                if response.status_code != 200:
+                    return self.error_response(
+                        f"Login failed: {response.status_code}",
+                        {"response": response.text}
+                    )
+                
+                # Extract session ID and user info
+                session_id = response.headers.get("bs-session-id")
+                data = response.json()
+                user_info = data.get("User", {})
+                
+                # Store session info
+                self.session.session_id = session_id
+                self.session.user_id = user_info.get("user_id")
+                
+                # Update the session client to be authenticated
+                if not self.session.client:
+                    await self.session.connect()
+                if session_id:
+                    self.session.client.headers["bs-session-id"] = session_id
+                
+                logger.info(f"Successfully logged in as user {self.session.user_id}")
+                
+                return self.success_response({
+                    "user_id": user_info.get("user_id"),
+                    "name": user_info.get("name"),
+                    "email": user_info.get("email"),
+                    "session_id": session_id,
+                    "message": "Successfully logged in to BioStar 2"
+                })
+            
+        except httpx.ConnectTimeout as e:
+            return self.error_response(
+                "Connection timeout",
+                {
+                    "message": f"Failed to connect to BioStar server at {self.session.config.biostar_url}",
+                    "timeout": f"{self.session.config.api_timeout} seconds",
+                    "suggestions": [
+                        "1. Check if the BioStar server URL is correct in your .env file",
+                        "2. Ensure the server is running and accessible",
+                        "3. Check network connectivity to the server",
+                        "4. Try increasing API_TIMEOUT in .env file",
+                        "5. If using HTTPS with self-signed certificate, set VERIFY_SSL=false"
+                    ]
+                }
+            )
+        except httpx.ConnectError as e:
+            return self.error_response(
+                "Connection error", 
+                {
+                    "message": f"Cannot connect to {self.session.config.biostar_url}",
+                    "error": str(e),
+                    "verify_ssl": self.session.config.verify_ssl
+                }
+            )
+        except Exception as e:
+            return await self.handle_api_error(e)
+            
+    async def logout(self, args: Dict[str, Any]) -> Sequence[TextContent]:
+        """Logout from BioStar 2."""
+        try:
+            if not self.session.is_authenticated():
+                return self.error_response("Not authenticated")
+            
+            # Make logout API call
+            async with httpx.AsyncClient(verify=self.session.config.verify_ssl) as client:
+                response = await client.post(
+                    f"{self.session.config.biostar_url}/api/logout",
+                    headers={"bs-session-id": self.session.session_id},
+                    timeout=self.session.config.api_timeout
+                )
+            
+            # Clear session info regardless of response
+            self.session.session_id = None
+            self.session.user_id = None
+            if self.session.client:
+                self.session.client.headers.pop("bs-session-id", None)
+            
+            return self.success_response({
+                "message": "Successfully logged out from BioStar 2"
+            })
+            
+        except Exception as e:
+            return await self.handle_api_error(e)
+            
+    async def get_session_info(self, args: Dict[str, Any]) -> Sequence[TextContent]:
+        """Get current session information."""
+        try:
+            self.check_auth()
+            
+            headers = {"bs-session-id": self.get_session_id()}
+            
+            async with httpx.AsyncClient(verify=False) as client:
+                response = await client.get(
+                    f"{self.session.config.biostar_url}/api/session",
+                    headers=headers
+                )
+            
+            if response.status_code == 200:
+                self.session.session_id = None
+                return self.success_response({
+                    "message": "Session information retrieved successfully",
+                    "session_data": response.json()
+                })
+            else:
+                return self.error_response(f"Failed to get session info: {response.status_code}")
+                
+        except Exception as e:
+            return await self.handle_api_error(e)
+    
+    async def get_server_preferences(self, args: Dict[str, Any]) -> Sequence[TextContent]:
+        """Get BioStar server preferences including timezone."""
+        try:
+            self.check_auth()
+            
+            headers = {
+                "bs-session-id": self.get_session_id(),
+                "Content-Type": "application/json"
+            }
+            
+            async with httpx.AsyncClient(verify=False) as client:
+                response = await client.get(
+                    f"{self.session.config.biostar_url}/api/preferences/1",
+                    headers=headers
+                )
+            
+            if response.status_code != 200:
+                return self.error_response(f"Failed to get server preferences: {response.status_code} - {response.text}")
+            
+            data = response.json()
+            preference = data.get("Preference", {})
+            
+            # Get timezone info
+            timezone_id = preference.get("time_zone", "26")  # Default to UTC+9 (Seoul)
+            timezone_offset_minutes = get_timezone_offset(timezone_id, default=540)  # Default to +540 minutes (UTC+9)
+            timezone_offset_hours = timezone_offset_minutes / 60
+            tz_str = get_timezone_string(timezone_id, default=540)
+            
+            return self.success_response({
+                "message": "Server preferences retrieved successfully",
+                "language": preference.get("language", "en"),
+                "timezone_id": timezone_id,
+                "timezone_offset_minutes": timezone_offset_minutes,
+                "timezone_offset_hours": timezone_offset_hours,
+                "timezone_string": tz_str,
+                "date_format": preference.get("date_format", "yyyy/MM/dd"),
+                "time_format": preference.get("time_format", "HH:mm"),
+                "user": {
+                    "user_id": preference.get("user_id", {}).get("user_id"),
+                    "name": preference.get("user_id", {}).get("name")
+                }
+            })
+                
+        except Exception as e:
+            logger.exception("get_server_preferences failed")
+            return await self.handle_api_error(e)

biostar_x_mcp_server/handlers/base_handler.py

@@ -0,0 +1,228 @@
+"""
+Base Handler for BioStar X MCP Server
+Provides common functionality for all API handlers
+"""
+import logging
+import json
+from typing import Sequence, Dict, Any, Optional
+from mcp.types import TextContent
+from pydantic import ValidationError
+import httpx
+from ..session import BioStarSession
+
+logger = logging.getLogger(__name__)
+
+
+class BaseHandler:
+    """Base handler class with common functionality for all handlers."""
+
+    def __init__(self, session: BioStarSession):
+        self.session = session
+        self.client_session_id = None
+
+    def get_session_id(self) -> str:
+        """Get the session ID to use for API calls."""
+        if self.client_session_id:
+            logger.info(f"Using client session ID: {self.client_session_id}")
+            return self.client_session_id
+        elif self.session.session_id:
+            logger.info(f"Using internal session ID: {self.session.session_id}")
+            return self.session.session_id
+        else:
+            raise RuntimeError("No session ID available")
+
+    def check_auth(self) -> None:
+        """Ensure session is authenticated."""
+        if self.client_session_id:
+            logger.info("Using client session ID, skipping internal auth check")
+            return
+
+        if not self.session.is_authenticated():
+            raise RuntimeError("Not authenticated. Please login first.")
+
+    @property
+    def api_headers(self) -> Dict[str, str]:
+        """Get standard API headers with session ID."""
+        return {
+            "bs-session-id": self.get_session_id(),
+            "Content-Type": "application/json"
+        }
+
+    async def api_get(self, endpoint: str, params: Optional[Dict[str, Any]] = None, **kwargs) -> httpx.Response:
+        """Make GET request to BioStar API."""
+        async with httpx.AsyncClient(verify=False) as client:
+            response = await client.get(
+                f"{self.session.config.biostar_url}{endpoint}",
+                headers=self.api_headers,
+                params=params,
+                **kwargs
+            )
+            return response
+
+    async def api_post(self, endpoint: str, json: Optional[Dict[str, Any]] = None, **kwargs) -> httpx.Response:
+        """Make POST request to BioStar API."""
+        async with httpx.AsyncClient(verify=False) as client:
+            response = await client.post(
+                f"{self.session.config.biostar_url}{endpoint}",
+                headers=self.api_headers,
+                json=json,
+                **kwargs
+            )
+            return response
+
+    async def api_put(self, endpoint: str, json: Optional[Dict[str, Any]] = None, **kwargs) -> httpx.Response:
+        """Make PUT request to BioStar API."""
+        async with httpx.AsyncClient(verify=False) as client:
+            response = await client.put(
+                f"{self.session.config.biostar_url}{endpoint}",
+                headers=self.api_headers,
+                json=json,
+                **kwargs
+            )
+            return response
+
+    async def api_delete(self, endpoint: str, **kwargs) -> httpx.Response:
+        """Make DELETE request to BioStar API."""
+        async with httpx.AsyncClient(verify=False) as client:
+            response = await client.delete(
+                f"{self.session.config.biostar_url}{endpoint}",
+                headers=self.api_headers,
+                **kwargs
+            )
+            return response
+
+    def success_response(self, data: Any, message: Optional[str] = None) -> list[TextContent]:
+        """Create a success response."""
+        content = {
+            "status": "success",
+            "data": data
+        }
+        if message:
+            content["message"] = message
+
+        return [TextContent(
+            type="text",
+            text=json.dumps(content, ensure_ascii=False, indent=2)
+        )]
+
+    def error_response(self, error: str, details: Optional[Dict[str, Any]] = None) -> list[TextContent]:
+        """Create an error response."""
+        content = {
+            "status": "error",
+            "error": error
+        }
+        if details:
+            content["details"] = details
+
+        return [TextContent(
+            type="text",
+            text=json.dumps(content, ensure_ascii=False, indent=2)
+        )]
+
+    async def handle_api_error(self, error: Exception) -> list[TextContent]:
+        """Handle API errors consistently."""
+        logger.error(f"API error: {error}", exc_info=True)
+
+        error_type = type(error).__name__
+
+        if hasattr(error, 'response'):
+            return self.error_response(
+                f"API error: {error.response.status_code}",
+                {"message": str(error), "response": error.response.text}
+            )
+        elif "TimeoutError" in str(error) or "ConnectTimeout" in str(error):
+            return self.error_response(
+                "Connection timeout",
+                {
+                    "message": "Failed to connect to BioStar server. Please check:",
+                    "suggestions": [
+                        "1. BioStar server URL in .env file (BIOSTAR_URL)",
+                        "2. Server is running and accessible",
+                        "3. Network connectivity",
+                        "4. Firewall settings"
+                    ],
+                    "error_type": error_type,
+                    "details": str(error)
+                }
+            )
+        elif "ConnectionRefused" in str(error):
+            return self.error_response(
+                "Connection refused",
+                {
+                    "message": "BioStar server refused the connection",
+                    "suggestions": [
+                        "1. Check if BioStar server is running",
+                        "2. Verify the server URL and port",
+                        "3. Check server logs"
+                    ],
+                    "error_type": error_type,
+                    "details": str(error)
+                }
+            )
+        else:
+            return self.error_response(
+                f"Error: {error_type}",
+                {"message": str(error), "type": error_type}
+            )
+
+    def handle_validation_error(self, error: ValidationError) -> list[TextContent]:
+        """Handle Pydantic validation errors consistently."""
+        errors = []
+        for err in error.errors():
+            field = ".".join(str(loc) for loc in err["loc"])
+            errors.append({
+                "field": field,
+                "message": err["msg"],
+                "type": err["type"]
+            })
+
+        return self.error_response(
+            "Validation error",
+            {"errors": errors}
+        )
+
+    def validate_required_params(self, params: Dict[str, Any], required: list[str]) -> Optional[list[TextContent]]:
+        """Validate required parameters are present."""
+        missing = [param for param in required if param not in params]
+        if missing:
+            return self.error_response(
+                "Missing required parameters",
+                {"missing": missing}
+            )
+        return None
+
+    def format_user_info(self, user_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Format user information for display."""
+        return {
+            "user_id": user_data.get("user_id"),
+            "name": user_data.get("name"),
+            "email": user_data.get("email"),
+            "phone_number": user_data.get("phone_number"),
+            "user_group_id": user_data.get("user_group_id", {}).get("id"),
+            "disabled": user_data.get("disabled", False),
+            "start_datetime": user_data.get("start_datetime"),
+            "expiry_datetime": user_data.get("expiry_datetime")
+        }
+
+    def format_door_info(self, door_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Format door information for display."""
+        return {
+            "id": door_data.get("id"),
+            "name": door_data.get("name"),
+            "description": door_data.get("description"),
+            "open_duration": door_data.get("open_duration"),
+            "open_status": door_data.get("open_status"),
+            "lock_status": door_data.get("lock_status"),
+            "unlocked": door_data.get("unlocked")
+        }
+
+    def format_device_info(self, device_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Format device information for display."""
+        return {
+            "id": device_data.get("id"),
+            "name": device_data.get("name"),
+            "device_type": device_data.get("device_type", {}).get("name"),
+            "ip": device_data.get("ip"),
+            "status": device_data.get("status", {}).get("online"),
+            "enabled": device_data.get("enabled")
+        }