iflow-mcp_democratize-technology-chronos-mcp 2.0.0__py3-none-any.whl

chronos_mcp/caldav_utils.py

@@ -0,0 +1,149 @@
+"""
+Shared CalDAV utility functions for calendar operations.
+
+This module provides reusable patterns for working with CalDAV calendars,
+eliminating code duplication across events, tasks, and journals managers.
+"""
+
+import logging
+from typing import Any, Optional
+from icalendar import Calendar as iCalendar
+
+logger = logging.getLogger(__name__)
+
+
+def get_item_with_fallback(
+    calendar,
+    uid: str,
+    item_type: str,
+    request_id: Optional[str] = None,
+) -> Any:
+    """
+    Get CalDAV item by UID with automatic fallback to full search.
+
+    This function implements a two-method approach for finding CalDAV items:
+    1. Method 1: Try the direct UID lookup method if available (fast)
+    2. Method 2: Fallback to iterating all items and matching UID (slow but reliable)
+
+    This pattern is necessary because not all CalDAV servers implement the
+    direct UID lookup methods (event_by_uid, todo_by_uid, journal_by_uid).
+
+    Args:
+        calendar: CalDAV calendar object
+        uid: Item UID to find
+        item_type: Type of item - one of: "event", "task", "journal"
+        request_id: Optional request ID for logging context
+
+    Returns:
+        CalDAV item object (Event, Todo, or Journal)
+
+    Raises:
+        ValueError: If item not found by either method
+        Exception: Any exception from CalDAV operations
+
+    Example:
+        >>> calendar = account.calendar(calendar_uid)
+        >>> event = get_item_with_fallback(calendar, "event-123", "event")
+        >>> task = get_item_with_fallback(calendar, "task-456", "task")
+    """
+    # Map item types to their CalDAV methods and component names
+    type_config = {
+        "event": {
+            "by_uid_method": "event_by_uid",
+            "list_method": "events",
+            "fallback_method": None,  # events don't have fallback
+            "component_name": "VEVENT",
+        },
+        "task": {
+            "by_uid_method": "event_by_uid",  # CalDAV uses event_by_uid for tasks
+            "list_method": "todos",
+            "fallback_method": "events",  # If todos() not available, use events()
+            "component_name": "VTODO",
+        },
+        "journal": {
+            "by_uid_method": "event_by_uid",  # CalDAV uses event_by_uid for journals
+            "list_method": "journals",
+            "fallback_method": "events",  # If journals() not available, use events()
+            "component_name": "VJOURNAL",
+        },
+    }
+
+    if item_type not in type_config:
+        raise ValueError(f"Invalid item_type: {item_type}. Must be 'event', 'task', or 'journal'")
+
+    config = type_config[item_type]
+    by_uid_method = config["by_uid_method"]
+    list_method = config["list_method"]
+    fallback_method = config["fallback_method"]
+    component_name = config["component_name"]
+
+    # Method 1: Try direct UID lookup if available
+    if hasattr(calendar, by_uid_method):
+        try:
+            item = getattr(calendar, by_uid_method)(uid)
+            logger.debug(
+                f"Found {item_type} '{uid}' using {by_uid_method}",
+                extra={"request_id": request_id},
+            )
+            return item
+        except Exception as e:
+            logger.warning(
+                f"{by_uid_method} failed for {item_type} '{uid}': {e}, trying fallback method",
+                extra={"request_id": request_id},
+            )
+
+    # Method 2: Fallback - iterate all items and match UID
+    try:
+        # Get the list of items
+        if hasattr(calendar, list_method):
+            items = getattr(calendar, list_method)()
+        elif fallback_method and hasattr(calendar, fallback_method):
+            # Use fallback method if primary not available (e.g., todos() not available)
+            logger.debug(
+                f"{list_method}() not available, using {fallback_method}() for {item_type}",
+                extra={"request_id": request_id},
+            )
+            items = getattr(calendar, fallback_method)()
+        else:
+            raise ValueError(
+                f"Calendar does not support {list_method}() or {fallback_method}()"
+            )
+
+        # Search through items
+        for item in items:
+            # Check if UID matches in the raw data (fast check)
+            # Handle both bytes (real CalDAV) and string (test mocks)
+            if isinstance(item.data, bytes):
+                uid_to_check = uid.encode('utf-8')
+            else:
+                uid_to_check = uid
+
+            if uid_to_check in item.data:
+                # Parse iCalendar to verify exact UID match
+                try:
+                    ical = iCalendar.from_ical(item.data)
+                    for component in ical.walk():
+                        if component.name == component_name:
+                            item_uid = str(component.get("uid", ""))
+                            if item_uid == uid:
+                                logger.debug(
+                                    f"Found {item_type} '{uid}' using fallback search",
+                                    extra={"request_id": request_id},
+                                )
+                                return item
+                except Exception as parse_error:
+                    logger.warning(
+                        f"Failed to parse {item_type} data: {parse_error}",
+                        extra={"request_id": request_id},
+                    )
+                    continue
+
+    except Exception as e:
+        logger.warning(
+            f"Fallback search failed for {item_type} '{uid}': {e}",
+            extra={"request_id": request_id},
+        )
+        raise
+
+    # Item not found by either method
+    raise ValueError(f"{item_type.capitalize()} with UID '{uid}' not found")

chronos_mcp/calendars.py

@@ -0,0 +1,204 @@
+"""
+Calendar operations for Chronos MCP
+"""
+
+import uuid
+from typing import List, Optional
+
+import caldav
+from caldav import Calendar as CalDAVCalendar
+
+from .accounts import AccountManager
+from .exceptions import (
+    AccountNotFoundError,
+    CalendarCreationError,
+    CalendarDeletionError,
+    CalendarNotFoundError,
+    ErrorHandler,
+)
+from .logging_config import setup_logging
+from .models import Calendar
+
+logger = setup_logging()
+
+
+class CalendarManager:
+    """Manage calendar operations"""
+
+    def __init__(self, account_manager: AccountManager):
+        self.accounts = account_manager
+
+    def list_calendars(
+        self, account_alias: Optional[str] = None, request_id: Optional[str] = None
+    ) -> List[Calendar]:
+        """List all calendars for an account - raises exceptions on failure"""
+        request_id = request_id or str(uuid.uuid4())
+
+        principal = self.accounts.get_principal(account_alias)
+        if not principal:
+            raise AccountNotFoundError(
+                account_alias
+                or self.accounts.config.config.default_account
+                or "default",
+                request_id=request_id,
+            )
+
+        calendars = []
+        try:
+            for cal in principal.calendars():
+                # Extract calendar properties
+                cal_info = Calendar(
+                    uid=(
+                        str(cal.url).split("/")[-2]
+                        if str(cal.url).endswith("/")
+                        else str(cal.url).split("/")[-1]
+                    ),
+                    name=cal.name or "Unnamed Calendar",
+                    description=None,  # Will need to fetch from properties
+                    color=None,  # Will need to fetch from properties
+                    account_alias=account_alias
+                    or self.accounts.config.config.default_account,
+                    url=str(cal.url),
+                    read_only=False,  # Will need to check permissions
+                )
+                calendars.append(cal_info)
+
+        except Exception as e:
+            logger.error(f"Error listing calendars: {e}")
+
+        return calendars
+
+    def create_calendar(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        color: Optional[str] = None,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> Optional[Calendar]:
+        """Create a new calendar - raises exceptions on failure"""
+        request_id = request_id or str(uuid.uuid4())
+
+        principal = self.accounts.get_principal(account_alias)
+        if not principal:
+            raise AccountNotFoundError(
+                account_alias
+                or self.accounts.config.config.default_account
+                or "default",
+                request_id=request_id,
+            )
+
+        try:
+            cal_id = name.lower().replace(" ", "_")
+            cal = principal.make_calendar(name=name, cal_id=cal_id)
+
+            # Note: description and color properties would need CalDAV server support
+            # for setting calendar properties beyond name
+
+            return Calendar(
+                uid=cal_id,
+                name=name,
+                description=description,
+                color=color,
+                account_alias=account_alias
+                or self.accounts.config.config.default_account,
+                url=str(cal.url),
+                read_only=False,
+            )
+
+        except caldav.lib.error.AuthorizationError as e:
+            logger.error(
+                f"Authorization error creating calendar '{name}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise CalendarCreationError(
+                name, "Authorization failed", request_id=request_id
+            )
+        except Exception as e:
+            logger.error(
+                f"Error creating calendar '{name}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise CalendarCreationError(name, str(e), request_id=request_id)
+
+    def delete_calendar(
+        self,
+        calendar_uid: str,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> bool:
+        """Delete a calendar - raises exceptions on failure"""
+        request_id = request_id or str(uuid.uuid4())
+
+        principal = self.accounts.get_principal(account_alias)
+        if not principal:
+            raise AccountNotFoundError(
+                account_alias
+                or self.accounts.config.config.default_account
+                or "default",
+                request_id=request_id,
+            )
+
+        try:
+            # Find calendar by UID
+            for cal in principal.calendars():
+                cal_id = (
+                    str(cal.url).split("/")[-2]
+                    if str(cal.url).endswith("/")
+                    else str(cal.url).split("/")[-1]
+                )
+                if cal_id == calendar_uid:
+                    cal.delete()
+                    logger.info(
+                        f"Deleted calendar '{calendar_uid}'",
+                        extra={"request_id": request_id},
+                    )
+                    return True
+
+            # Calendar not found
+            raise CalendarNotFoundError(
+                calendar_uid, account_alias, request_id=request_id
+            )
+
+        except CalendarNotFoundError:
+            raise  # Re-raise our own exception
+        except caldav.lib.error.AuthorizationError as e:
+            logger.error(
+                f"Authorization error deleting calendar '{calendar_uid}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise CalendarDeletionError(
+                calendar_uid, "Authorization failed", request_id=request_id
+            )
+        except Exception as e:
+            logger.error(
+                f"Error deleting calendar '{calendar_uid}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise CalendarDeletionError(calendar_uid, str(e), request_id=request_id)
+
+    @ErrorHandler.safe_operation(logger, default_return=None)
+    def get_calendar(
+        self,
+        calendar_uid: str,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> Optional[CalDAVCalendar]:
+        """Get CalDAV calendar object by UID - internal utility method"""
+        principal = self.accounts.get_principal(account_alias)
+        if not principal:
+            return None
+
+        try:
+            for cal in principal.calendars():
+                cal_id = (
+                    str(cal.url).split("/")[-2]
+                    if str(cal.url).endswith("/")
+                    else str(cal.url).split("/")[-1]
+                )
+                if cal_id == calendar_uid:
+                    return cal
+        except Exception as e:
+            logger.error(f"Error getting calendar: {e}")
+
+        return None

chronos_mcp/config.py

@@ -0,0 +1,187 @@
+"""
+Configuration management for Chronos MCP
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from .credentials import get_credential_manager
+from .logging_config import setup_logging
+from .models import Account
+
+logger = setup_logging()
+
+
+class ChronosConfig(BaseModel):
+    """Main configuration"""
+
+    accounts: Dict[str, Account] = Field(
+        default_factory=dict, description="Configured accounts"
+    )
+    default_account: Optional[str] = Field(None, description="Default account alias")
+
+
+class ConfigManager:
+    """Manage Chronos configuration"""
+
+    def __init__(self):
+        self.config_dir = Path.home() / ".chronos"
+        self.config_file = self.config_dir / "accounts.json"
+        self.config: ChronosConfig = ChronosConfig()
+        self._load_config()
+
+    def _load_config(self):
+        """Load configuration from file and environment"""
+        # First, try to load from config file
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, "r") as f:
+                    data = json.load(f)
+                    # Convert account dicts to Account objects
+                    accounts = {}
+                    for alias, acc_data in data.get("accounts", {}).items():
+                        acc_data["alias"] = alias
+                        if "url" in acc_data and isinstance(acc_data["url"], str):
+                            accounts[alias] = Account(**acc_data)
+
+                    self.config = ChronosConfig(
+                        accounts=accounts, default_account=data.get("default_account")
+                    )
+                    logger.info(f"Loaded {len(accounts)} accounts from config file")
+            except Exception as e:
+                logger.error(f"Error loading config file: {e}")
+
+        env_url = os.getenv("CALDAV_BASE_URL")
+        env_username = os.getenv("CALDAV_USERNAME")
+        env_password = os.getenv("CALDAV_PASSWORD")
+
+        # Validate environment variables before use (defense-in-depth)
+        if env_url and env_username:
+            from .validation import InputValidator
+
+            try:
+                # Allow local URLs for development environments
+                env_url = InputValidator.validate_url(
+                    env_url, allow_private_ips=True, field_name="CALDAV_BASE_URL"
+                )
+                env_username = InputValidator.validate_text_field(
+                    env_username, "CALDAV_USERNAME", required=True
+                )
+                if env_password:
+                    env_password = InputValidator.validate_text_field(
+                        env_password, "CALDAV_PASSWORD", required=True
+                    )
+            except Exception as e:
+                logger.error(f"Invalid environment variable values: {e}")
+                return  # Skip environment account creation if validation fails
+
+        if env_url and env_username:
+            env_account = Account(
+                alias="default",
+                url=env_url,
+                username=env_username,
+                password=env_password,
+                display_name="Default Account (from environment)",
+            )
+
+            if "default" not in self.config.accounts:
+                # Store password in keyring if available
+                if env_password:
+                    credential_manager = get_credential_manager()
+                    if credential_manager.keyring_available:
+                        if credential_manager.set_password("default", env_password):
+                            logger.info("Environment password stored in keyring")
+                            # Don't include password in account object if stored in keyring
+                            env_account.password = None
+
+                self.config.accounts["default"] = env_account
+                if not self.config.default_account:
+                    self.config.default_account = "default"
+                logger.info("Added default account from environment variables")
+
+    def save_config(self):
+        """Save configuration to file"""
+        self.config_dir.mkdir(exist_ok=True)
+
+        credential_manager = get_credential_manager()
+
+        data = {"accounts": {}, "default_account": self.config.default_account}
+
+        for alias, acc in self.config.accounts.items():
+            account_data = {
+                "url": str(acc.url),
+                "username": acc.username,
+                "display_name": acc.display_name,
+            }
+
+            # Only save password to config if keyring is not available
+            if not credential_manager.keyring_available and acc.password:
+                account_data["password"] = acc.password
+                logger.warning(
+                    f"Saving password for '{alias}' to config file (keyring not available)"
+                )
+
+            data["accounts"][alias] = account_data
+
+        with open(self.config_file, "w") as f:
+            json.dump(data, f, indent=2)
+        logger.info("Configuration saved")
+
+    def add_account(self, account: Account):
+        """Add a new account
+
+        Args:
+            account: The Account object to add
+
+        Raises:
+            AccountAlreadyExistsError: If an account with the same alias already exists
+        """
+        if account.alias in self.config.accounts:
+            from .exceptions import AccountAlreadyExistsError
+
+            raise AccountAlreadyExistsError(account.alias)
+
+        # Store password in keyring if available
+        if account.password:
+            credential_manager = get_credential_manager()
+            if credential_manager.keyring_available:
+                if credential_manager.set_password(account.alias, account.password):
+                    logger.info(f"Password for '{account.alias}' stored in keyring")
+                else:
+                    logger.warning(
+                        f"Failed to store password in keyring for '{account.alias}'"
+                    )
+
+        self.config.accounts[account.alias] = account
+        if not self.config.default_account:
+            self.config.default_account = account.alias
+        self.save_config()
+
+    def remove_account(self, alias: str):
+        """Remove an account"""
+        if alias in self.config.accounts:
+            # Remove password from keyring if stored there
+            credential_manager = get_credential_manager()
+            if credential_manager.delete_password(alias):
+                logger.info(f"Password removed from keyring for account: {alias}")
+
+            del self.config.accounts[alias]
+            if self.config.default_account == alias:
+                self.config.default_account = next(iter(self.config.accounts), None)
+            self.save_config()
+
+    def get_account(self, alias: Optional[str] = None) -> Optional[Account]:
+        """Get an account by alias or return default"""
+        if alias:
+            return self.config.accounts.get(alias)
+        elif self.config.default_account:
+            return self.config.accounts.get(self.config.default_account)
+        return None
+
+    def list_accounts(self) -> Dict[str, Account]:
+        """List all configured accounts"""
+        return self.config.accounts