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

biostar_x_mcp_server/session.py

@@ -0,0 +1,221 @@
+"""
+BioStar X Session Management
+Handles API authentication and session lifecycle
+"""
+import asyncio
+import logging
+from datetime import datetime
+from typing import Optional, Dict, Any
+import httpx
+from .config import Config
+
+logger = logging.getLogger(__name__)
+
+
+class BioStarSession:
+    """Manages BioStar X API session and authentication."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.client: Optional[httpx.AsyncClient] = None
+        self.session_id: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.last_refresh: Optional[datetime] = None
+        self.timezone_offset_minutes: Optional[int] = None
+        self._lock = asyncio.Lock()
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+
+    async def connect(self):
+        """Initialize HTTP client."""
+        if not self.client:
+            logger.info(f"Connecting to BioStar server at: {self.config.biostar_url}")
+            logger.info(f"SSL verification: {self.config.verify_ssl}, Timeout: {self.config.api_timeout}s")
+
+            self.client = httpx.AsyncClient(
+                base_url=self.config.biostar_url,
+                timeout=httpx.Timeout(self.config.api_timeout),
+                verify=self.config.verify_ssl,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json"
+                }
+            )
+
+    async def set_session_id_async(self, session_id: str):
+        """Set session ID from external source (async version)."""
+        logger.info(f"Setting external session ID: {session_id}")
+        self.session_id = session_id
+        self.last_refresh = datetime.now()
+
+        if not self.client:
+            await self.connect()
+            logger.info("Client initialized for external session")
+
+        if self.client and self.session_id:
+            self.client.headers["bs-session-id"] = self.session_id
+            logger.info(f"Updated client headers with session ID: {session_id[:8]}...")
+
+    def set_session_id(self, session_id: str):
+        """Set session ID from external source (sync version)."""
+        logger.info(f"Setting external session ID: {session_id}")
+        self.session_id = session_id
+        self.last_refresh = datetime.now()
+
+        if self.client and self.session_id:
+            self.client.headers["bs-session-id"] = self.session_id
+            logger.info("Updated client headers with session ID")
+
+    async def disconnect(self):
+        """Close HTTP client and logout."""
+        if self.session_id:
+            try:
+                await self.logout()
+            except Exception as e:
+                logger.error(f"Error during logout: {e}")
+
+        if self.client:
+            await self.client.aclose()
+            self.client = None
+
+    async def login(self, username: Optional[str] = None, password: Optional[str] = None) -> Dict[str, Any]:
+        """Login to BioStar X API."""
+        async with self._lock:
+            if not self.client:
+                await self.connect()
+
+            login_username = username or self.config.biostar_username
+            login_password = password or self.config.biostar_password
+
+            if not login_username or not login_password:
+                raise ValueError("Username and password are required. Set them in .env or provide as arguments.")
+
+            try:
+                response = await self.client.post(
+                    "/api/login",
+                    json={
+                        "User": {
+                            "login_id": login_username,
+                            "password": login_password
+                        }
+                    }
+                )
+                response.raise_for_status()
+
+                data = response.json()
+                self.session_id = response.headers.get("bs-session-id")
+                self.user_id = data.get("User", {}).get("user_id")
+                self.last_refresh = datetime.now()
+
+                if self.session_id:
+                    self.client.headers["bs-session-id"] = self.session_id
+
+                logger.info(f"Successfully logged in as user {self.user_id}")
+                return data
+
+            except httpx.HTTPStatusError as e:
+                logger.error(f"Login failed: {e.response.status_code} - {e.response.text}")
+                raise
+            except Exception as e:
+                logger.error(f"Login error: {e}")
+                raise
+
+    async def logout(self) -> None:
+        """Logout from BioStar X API."""
+        if not self.session_id:
+            return
+
+        try:
+            await self.client.post("/api/logout")
+            logger.info("Successfully logged out")
+        except Exception as e:
+            logger.error(f"Logout error: {e}")
+        finally:
+            self.session_id = None
+            self.user_id = None
+            self.last_refresh = None
+            self.timezone_offset_minutes = None
+            if self.client:
+                self.client.headers.pop("bs-session-id", None)
+
+    async def refresh_session(self) -> None:
+        """Refresh session if needed."""
+        if not self.session_id:
+            await self.login()
+            return
+
+        if self.last_refresh:
+            elapsed = datetime.now() - self.last_refresh
+            if elapsed.total_seconds() > self.config.session_refresh_interval:
+                logger.info("Session refresh needed")
+                await self.login()
+
+    async def request(
+        self,
+        method: str,
+        endpoint: str,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> httpx.Response:
+        """Make authenticated request to BioStar X API."""
+        if not self.client:
+            await self.connect()
+            logger.info("Client initialized on first request")
+
+            if self.session_id:
+                self.client.headers["bs-session-id"] = self.session_id
+                logger.info(f"Session headers set on first request: {self.session_id[:8]}...")
+
+        await self.refresh_session()
+
+        try:
+            response = await self.client.request(
+                method=method,
+                url=endpoint,
+                json=json,
+                params=params,
+                **kwargs
+            )
+            response.raise_for_status()
+            return response
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                logger.info("Session expired, re-authenticating")
+                await self.login()
+                response = await self.client.request(
+                    method=method,
+                    url=endpoint,
+                    json=json,
+                    params=params,
+                    **kwargs
+                )
+                response.raise_for_status()
+                return response
+            raise
+
+    async def get(self, endpoint: str, **kwargs) -> httpx.Response:
+        """Make GET request."""
+        return await self.request("GET", endpoint, **kwargs)
+
+    async def post(self, endpoint: str, json: Dict[str, Any], **kwargs) -> httpx.Response:
+        """Make POST request."""
+        return await self.request("POST", endpoint, json=json, **kwargs)
+
+    async def put(self, endpoint: str, json: Dict[str, Any], **kwargs) -> httpx.Response:
+        """Make PUT request."""
+        return await self.request("PUT", endpoint, json=json, **kwargs)
+
+    async def delete(self, endpoint: str, **kwargs) -> httpx.Response:
+        """Make DELETE request."""
+        return await self.request("DELETE", endpoint, **kwargs)
+
+    def is_authenticated(self) -> bool:
+        """Check if session is authenticated."""
+        return self.session_id is not None

biostar_x_mcp_server/tool_manager.py

@@ -0,0 +1,172 @@
+"""
+BioStar X MCP Server Tool Manager
+Dynamic loading and management of tool categories
+"""
+import logging
+from typing import List, Set, Optional, Dict
+from mcp.types import Tool
+
+from .tools.categories import (
+    get_tools_for_category,
+    get_category_for_tool,
+    get_all_categories,
+    CATEGORY_DESCRIPTIONS
+)
+from .tools.auth import AUTH_TOOLS
+from .tools.users import USER_TOOLS
+from .tools.events import EVENT_TOOLS
+from .tools.doors import DOOR_TOOLS
+from .tools.devices import DEVICE_TOOLS
+from .tools.access import ACCESS_TOOLS
+from .tools.audit import AUDIT_TOOLS
+from .tools.cards import CARD_TOOLS
+from .tools.navigation import NAVIGATION_TOOLS
+from .tools.occupancy import OCCUPANCY_TOOLS
+from .tools.files import FILE_TOOLS
+from .tools.logs import LOG_TOOLS
+from .tools.help import HELP_TOOLS
+
+logger = logging.getLogger(__name__)
+
+
+class ToolManager:
+    """Manages dynamic loading and unloading of tool categories."""
+
+    def __init__(self, max_categories: int = 15):
+        self.max_categories = max_categories
+        self.active_categories: Set[str] = set()
+        self.loaded_tools: Dict[str, List[Tool]] = {}
+        self.usage_count: Dict[str, int] = {}
+
+    def load_category(self, category: str) -> bool:
+        """Load tools for a specific category."""
+        logger.debug(f"Attempting to load category: {category}")
+
+        if category in self.active_categories:
+            logger.debug(f"Category {category} already loaded")
+            return True
+
+        if category not in get_all_categories():
+            logger.warning(f"Unknown category: {category}")
+            return False
+
+        # Check if we need to unload a category
+        if len(self.active_categories) >= self.max_categories:
+            logger.debug(f"Max categories reached ({self.max_categories}), unloading least used")
+            self._unload_least_used_category()
+
+        # Load the tools for this category
+        tools = self._get_tools_for_category(category)
+        logger.debug(f"Retrieved {len(tools)} tools for category: {category}")
+
+        if tools:
+            self.loaded_tools[category] = tools
+            self.active_categories.add(category)
+            self.usage_count[category] = 0
+            logger.info(f"Loaded category: {category} with {len(tools)} tools")
+            return True
+        else:
+            logger.error(f"No tools found for category: {category}")
+            return False
+
+    def unload_category(self, category: str) -> bool:
+        """Unload tools for a specific category."""
+        if category not in self.active_categories:
+            return False
+
+        self.active_categories.remove(category)
+        self.loaded_tools.pop(category, None)
+        self.usage_count.pop(category, None)
+        logger.info(f"Unloaded category: {category}")
+        return True
+
+    def get_active_tools(self) -> List[Tool]:
+        """Get all currently loaded tools."""
+        tools = []
+        seen_names = set()
+
+        for category in self.active_categories:
+            category_tools = self.loaded_tools.get(category, [])
+            for tool in category_tools:
+                tool_name = tool.name
+                if tool_name not in seen_names:
+                    seen_names.add(tool_name)
+                    tools.append(tool)
+                else:
+                    logger.warning(f"Duplicate tool name found: {tool_name} from category {category}, skipping")
+
+        logger.info(f"Returning {len(tools)} unique tools from {len(self.active_categories)} categories")
+        return tools
+
+    def get_tool_category(self, tool_name: str) -> Optional[str]:
+        """Get the category a tool belongs to."""
+        return get_category_for_tool(tool_name)
+
+    def record_tool_usage(self, tool_name: str) -> None:
+        """Record that a tool was used."""
+        category = self.get_tool_category(tool_name)
+        if category and category in self.usage_count:
+            self.usage_count[category] += 1
+
+    def _unload_least_used_category(self) -> None:
+        """Unload the least recently used category."""
+        if not self.active_categories:
+            return
+
+        # Never unload auth category
+        candidates = [c for c in self.active_categories if c != "auth"]
+        if not candidates:
+            return
+
+        # Find least used category
+        least_used = min(candidates, key=lambda c: self.usage_count.get(c, 0))
+        self.unload_category(least_used)
+
+    # Category to tools mapping (without vector_solis)
+    _CATEGORY_TOOLS_MAP = {
+        "auth": AUTH_TOOLS,
+        "users": USER_TOOLS,
+        "events": EVENT_TOOLS,
+        "doors": DOOR_TOOLS,
+        "access": ACCESS_TOOLS,
+        "devices": DEVICE_TOOLS,
+        "audit": AUDIT_TOOLS,
+        "cards": CARD_TOOLS,
+        "navigation": NAVIGATION_TOOLS,
+        "occupancy": OCCUPANCY_TOOLS,
+        "files": FILE_TOOLS,
+        "logs": LOG_TOOLS,
+        "help": HELP_TOOLS,
+    }
+
+    def _get_tools_for_category(self, category: str) -> List[Tool]:
+        """Get tool definitions for a category."""
+        logger.debug(f"Getting tools for category: {category}")
+
+        tools = self._CATEGORY_TOOLS_MAP.get(category)
+
+        if tools is None:
+            logger.warning(f"Unknown category: {category}")
+            return []
+
+        return tools
+
+    def get_category_info(self) -> Dict[str, Dict[str, any]]:
+        """Get information about all categories."""
+        info = {}
+        for category in get_all_categories():
+            info[category] = {
+                "description": CATEGORY_DESCRIPTIONS.get(category, ""),
+                "tools": get_tools_for_category(category),
+                "loaded": category in self.active_categories,
+                "usage_count": self.usage_count.get(category, 0)
+            }
+        return info
+
+    def load_all_categories(self) -> int:
+        """Load all available categories. Returns number of categories loaded."""
+        count = 0
+        for category in get_all_categories():
+            if self.load_category(category):
+                count += 1
+        return count

biostar_x_mcp_server/tools/__init__.py

@@ -0,0 +1,45 @@
+"""
+BioStar X MCP Server - Tool Definitions
+"""
+
+from .auth import AUTH_TOOLS
+from .users import USER_TOOLS
+from .doors import DOOR_TOOLS
+from .access import ACCESS_TOOLS
+from .devices import DEVICE_TOOLS
+from .events import EVENT_TOOLS
+from .audit import AUDIT_TOOLS
+from .cards import CARD_TOOLS
+from .navigation import NAVIGATION_TOOLS
+from .occupancy import OCCUPANCY_TOOLS
+from .files import FILE_TOOLS
+from .logs import LOG_TOOLS
+from .categories import (
+    TOOL_CATEGORIES,
+    CATEGORY_DESCRIPTIONS,
+    get_tools_for_category,
+    get_category_for_tool,
+    get_all_categories
+)
+
+__all__ = [
+    # Tool lists
+    "AUTH_TOOLS",
+    "USER_TOOLS",
+    "DOOR_TOOLS",
+    "ACCESS_TOOLS",
+    "DEVICE_TOOLS",
+    "EVENT_TOOLS",
+    "AUDIT_TOOLS",
+    "CARD_TOOLS",
+    "NAVIGATION_TOOLS",
+    "OCCUPANCY_TOOLS",
+    "FILE_TOOLS",
+    "LOG_TOOLS",
+    # Categories
+    "TOOL_CATEGORIES",
+    "CATEGORY_DESCRIPTIONS",
+    "get_tools_for_category",
+    "get_category_for_tool",
+    "get_all_categories",
+]