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

chronos_mcp/credentials.py

@@ -0,0 +1,190 @@
+"""
+Secure credential management for Chronos MCP using system keyring.
+
+This module provides secure storage for CalDAV passwords using the system keyring
+when available, with fallback to configuration file (with warnings).
+"""
+
+from typing import Any, Dict, Optional
+
+# Try to import keyring, but handle its absence gracefully
+try:
+    import keyring
+
+    KEYRING_AVAILABLE = True
+except ImportError:
+    KEYRING_AVAILABLE = False
+    keyring = None
+
+from .logging_config import setup_logging
+
+logger = setup_logging()
+
+
+class CredentialManager:
+    """
+    Manages secure credential storage using system keyring with fallback.
+
+    Keyring service name follows the pattern: chronos-mcp
+    Keyring keys follow the pattern: caldav:{alias}
+    """
+
+    SERVICE_NAME = "chronos-mcp"
+    KEY_PREFIX = "caldav:"
+
+    def __init__(self):
+        """Initialize the credential manager."""
+        self.keyring_available = KEYRING_AVAILABLE
+        self._keyring_backend = None
+
+        if self.keyring_available:
+            try:
+                # Test keyring availability by getting the backend
+                self._keyring_backend = keyring.get_keyring()
+                backend_name = type(self._keyring_backend).__name__
+
+                # Check if we have a null/fail backend
+                if "fail" in backend_name.lower() or "null" in backend_name.lower():
+                    self.keyring_available = False
+                    logger.warning(f"Keyring backend is non-functional: {backend_name}")
+                else:
+                    logger.info(f"Using keyring backend: {backend_name}")
+            except Exception as e:
+                self.keyring_available = False
+                logger.warning(f"Keyring initialization failed: {e}")
+        else:
+            logger.warning(
+                "Keyring module not available - passwords will be stored in config file"
+            )
+
+    def _get_keyring_key(self, alias: str) -> str:
+        """Generate the keyring key for an account alias."""
+        return f"{self.KEY_PREFIX}{alias}"
+
+    def get_password(
+        self, alias: str, fallback_password: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Retrieve password from keyring, with fallback to provided value.
+
+        Args:
+            alias: Account alias
+            fallback_password: Password from config file (used if keyring fails)
+
+        Returns:
+            Password string or None if not found
+        """
+        if self.keyring_available:
+            try:
+                key = self._get_keyring_key(alias)
+                password = keyring.get_password(self.SERVICE_NAME, key)
+
+                if password:
+                    logger.debug(
+                        "Retrieved password from keyring for account: [REDACTED]"
+                    )
+                    return password
+                elif fallback_password:
+                    logger.warning(
+                        f"Password for '{alias}' found in config file but not in keyring. "
+                        "Consider running the migration script to securely store passwords in keyring: "
+                        "python -m chronos_mcp.scripts.migrate_to_keyring"
+                    )
+
+            except Exception as e:
+                logger.error(f"Failed to retrieve password from keyring: {e}")
+
+        if fallback_password:
+            if not self.keyring_available:
+                logger.debug("Using password from config file for account: [REDACTED]")
+            return fallback_password
+
+        return None
+
+    def set_password(self, alias: str, password: str) -> bool:
+        """
+        Store password in keyring.
+
+        Args:
+            alias: Account alias
+            password: Password to store
+
+        Returns:
+            True if successfully stored, False otherwise
+        """
+        if not self.keyring_available:
+            logger.debug(
+                "Keyring not available, cannot store password for account: [REDACTED]"
+            )
+            return False
+
+        try:
+            key = self._get_keyring_key(alias)
+            keyring.set_password(self.SERVICE_NAME, key, password)
+            logger.info("Password stored in keyring for account: [REDACTED]")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to store password in keyring: {e}")
+            return False
+
+    def delete_password(self, alias: str) -> bool:
+        """
+        Remove password from keyring.
+
+        Args:
+            alias: Account alias
+
+        Returns:
+            True if successfully deleted, False otherwise
+        """
+        if not self.keyring_available:
+            return False
+
+        try:
+            key = self._get_keyring_key(alias)
+            keyring.delete_password(self.SERVICE_NAME, key)
+            logger.info("Password removed from keyring for account: [REDACTED]")
+            return True
+        except keyring.errors.PasswordDeleteError:
+            logger.debug("No password in keyring for account: [REDACTED]")
+            return False
+        except Exception as e:
+            logger.error(f"Failed to delete password from keyring: {e}")
+            return False
+
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Get credential manager status information.
+
+        Returns:
+            Dictionary with status information
+        """
+        status = {
+            "keyring_available": self.keyring_available,
+            "backend": None,
+            "backend_type": None,
+            "secure": False,
+        }
+
+        if self.keyring_available and self._keyring_backend:
+            backend_name = type(self._keyring_backend).__name__
+            status["backend"] = str(self._keyring_backend)
+            status["backend_type"] = backend_name
+
+            # Determine if backend is secure
+            secure_backends = ["Keychain", "SecretService", "KWallet", "Windows"]
+            status["secure"] = any(sb in backend_name for sb in secure_backends)
+
+        return status
+
+
+# Singleton instance
+_credential_manager = None
+
+
+def get_credential_manager() -> CredentialManager:
+    """Get the singleton credential manager instance."""
+    global _credential_manager
+    if _credential_manager is None:
+        _credential_manager = CredentialManager()
+    return _credential_manager

chronos_mcp/events.py

@@ -0,0 +1,515 @@
+"""
+Event operations for Chronos MCP
+"""
+
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+
+import caldav
+from caldav import Event as CalDAVEvent
+from icalendar import Calendar as iCalendar
+from icalendar import Event as iEvent
+
+from .caldav_utils import get_item_with_fallback
+from .calendars import CalendarManager
+from .exceptions import (
+    CalendarNotFoundError,
+    EventCreationError,
+    EventDeletionError,
+    EventNotFoundError,
+)
+from .logging_config import setup_logging
+from .models import Alarm, Attendee, Event
+from .utils import ical_to_datetime, validate_rrule
+
+logger = setup_logging()
+
+
+class EventManager:
+    """Manage calendar events"""
+
+    def __init__(self, calendar_manager: CalendarManager):
+        self.calendars = calendar_manager
+
+    def _get_default_account(self) -> Optional[str]:
+        try:
+            return self.calendars.accounts.config.config.default_account
+        except Exception:
+            return None
+
+    def create_event(
+        self,
+        calendar_uid: str,
+        summary: str,
+        start: datetime,
+        end: datetime,
+        description: Optional[str] = None,
+        location: Optional[str] = None,
+        all_day: bool = False,
+        attendees: Optional[List[Dict[str, Any]]] = None,
+        alarm_minutes: Optional[int] = None,
+        recurrence_rule: Optional[str] = None,
+        related_to: Optional[List[str]] = None,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> Optional[Event]:
+        """Create a new event - raises exceptions on failure"""
+        request_id = request_id or str(uuid.uuid4())
+
+        calendar = self.calendars.get_calendar(
+            calendar_uid, account_alias, request_id=request_id
+        )
+        if not calendar:
+            raise CalendarNotFoundError(
+                calendar_uid, account_alias, request_id=request_id
+            )
+
+        try:
+            # Fix all-day event times
+            if all_day:
+                # Ensure start is at midnight
+                start = start.replace(hour=0, minute=0, second=0, microsecond=0)
+                # End should be midnight of the next day (24 hours later)
+                end = start + timedelta(days=1)
+
+            # Validate RRULE if provided
+            if recurrence_rule:
+                is_valid, error_msg = validate_rrule(recurrence_rule)
+                if not is_valid:
+                    raise EventCreationError(
+                        summary, f"Invalid RRULE: {error_msg}", request_id=request_id
+                    )
+
+            cal = iCalendar()
+            event = iEvent()
+
+            # Generate UID if not provided
+            event_uid = str(uuid.uuid4())
+
+            event.add("uid", event_uid)
+            event.add("summary", summary)
+            event.add("dtstart", start)
+            event.add("dtend", end)
+            event.add("dtstamp", datetime.now(timezone.utc))
+
+            if description:
+                event.add("description", description)
+            if location:
+                event.add("location", location)
+            if recurrence_rule:
+                event.add("rrule", recurrence_rule)
+
+            if attendees:
+                for att in attendees:
+                    attendee_str = f"mailto:{att['email']}"
+                    event.add(
+                        "attendee",
+                        attendee_str,
+                        parameters={
+                            "CN": att.get("name", att["email"]),
+                            "ROLE": att.get("role", "REQ-PARTICIPANT"),
+                            "PARTSTAT": att.get("status", "NEEDS-ACTION"),
+                            "RSVP": "TRUE" if att.get("rsvp", True) else "FALSE",
+                        },
+                    )
+
+            if related_to:
+                for related_uid in related_to:
+                    event.add("related-to", related_uid)
+
+            if alarm_minutes:
+                from icalendar import Alarm as iAlarm
+
+                alarm = iAlarm()
+                alarm.add("action", "DISPLAY")
+                alarm.add("trigger", timedelta(minutes=-alarm_minutes))
+                alarm.add("description", summary)
+                event.add_component(alarm)
+
+            cal.add_component(event)
+
+            # Save to CalDAV server
+            caldav_event = calendar.save_event(cal.to_ical().decode("utf-8"))
+
+            event_model = Event(
+                uid=event_uid,
+                summary=summary,
+                description=description,
+                start=start,
+                end=end,
+                all_day=all_day,
+                location=location,
+                calendar_uid=calendar_uid,
+                account_alias=account_alias or self._get_default_account() or "default",
+                recurrence_rule=recurrence_rule,
+                related_to=related_to or [],
+            )
+
+            # Add attendees to model
+            if attendees:
+                event_model.attendees = [
+                    Attendee(
+                        email=att["email"],
+                        name=att.get("name", att["email"]),
+                        role=att.get("role", "REQ-PARTICIPANT"),
+                        status=att.get("status", "NEEDS-ACTION"),
+                        rsvp=att.get("rsvp", True),
+                    )
+                    for att in attendees
+                ]
+
+            # Add alarm to model
+            if alarm_minutes:
+                event_model.alarms = [
+                    Alarm(
+                        action="DISPLAY",
+                        trigger=f"-PT{alarm_minutes}M",
+                        description=summary,
+                    )
+                ]
+
+            return event_model
+
+        except caldav.lib.error.AuthorizationError as e:
+            logger.error(
+                f"Authorization error creating event '{summary}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise EventCreationError(
+                summary, "Authorization failed", request_id=request_id
+            )
+        except Exception as e:
+            logger.error(
+                f"Error creating event '{summary}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise EventCreationError(summary, str(e), request_id=request_id)
+
+    def get_events_range(
+        self,
+        calendar_uid: str,
+        start_date: datetime,
+        end_date: datetime,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> List[Event]:
+        """Get events within a date range - raises exceptions on failure"""
+        request_id = request_id or str(uuid.uuid4())
+
+        calendar = self.calendars.get_calendar(
+            calendar_uid, account_alias, request_id=request_id
+        )
+        if not calendar:
+            raise CalendarNotFoundError(
+                calendar_uid, account_alias, request_id=request_id
+            )
+
+        events = []
+        try:
+            # Search for events in date range
+            results = calendar.date_search(start=start_date, end=end_date, expand=True)
+
+            for caldav_event in results:
+                event_data = self._parse_caldav_event(
+                    caldav_event, calendar_uid, account_alias
+                )
+                if event_data:
+                    events.append(event_data)
+
+        except Exception as e:
+            logger.error(f"Error getting events: {e}")
+
+        return events
+
+    def _parse_caldav_event(
+        self, caldav_event: CalDAVEvent, calendar_uid: str, account_alias: Optional[str]
+    ) -> Optional[Event]:
+        """Parse CalDAV event to Event model"""
+        try:
+            # Parse iCalendar data
+            ical = iCalendar.from_ical(caldav_event.data)
+
+            for component in ical.walk():
+                if component.name == "VEVENT":
+                    # Parse date/time values
+                    dtstart = component.get("dtstart")
+                    dtend = component.get("dtend")
+
+                    start_dt = ical_to_datetime(dtstart)
+                    end_dt = ical_to_datetime(dtend)
+
+                    # Detect all-day events
+                    # Check if the original values were DATE (not DATE-TIME) or if it's midnight to midnight
+                    is_all_day = False
+                    if dtstart and dtend:
+                        # Check if values are DATE type (no time component)
+                        if hasattr(dtstart, "dt") and not hasattr(dtstart.dt, "hour"):
+                            is_all_day = True
+                        # Also check for midnight-to-midnight pattern
+                        elif (
+                            start_dt.hour == 0
+                            and start_dt.minute == 0
+                            and start_dt.second == 0
+                            and end_dt.hour == 0
+                            and end_dt.minute == 0
+                            and end_dt.second == 0
+                            and (end_dt - start_dt).days >= 1
+                        ):
+                            is_all_day = True
+
+                    # Parse basic event data
+                    event = Event(
+                        uid=str(component.get("uid", "")),
+                        summary=str(component.get("summary", "No Title")),
+                        description=(
+                            str(component.get("description", ""))
+                            if component.get("description")
+                            else None
+                        ),
+                        start=start_dt,
+                        end=end_dt,
+                        all_day=is_all_day,
+                        location=(
+                            str(component.get("location", ""))
+                            if component.get("location")
+                            else None
+                        ),
+                        calendar_uid=calendar_uid,
+                        account_alias=account_alias
+                        or self._get_default_account()
+                        or "default",
+                        recurrence_rule=(
+                            str(component.get("rrule", ""))
+                            if component.get("rrule")
+                            else None
+                        ),
+                    )
+
+                    # Parse attendees
+                    attendees = component.get("attendee", [])
+                    if attendees:
+                        if not isinstance(attendees, list):
+                            attendees = [attendees]
+
+                        for attendee in attendees:
+                            params = (
+                                attendee.params if hasattr(attendee, "params") else {}
+                            )
+                            email = str(attendee).replace("mailto:", "")
+                            event.attendees.append(
+                                Attendee(
+                                    email=email,
+                                    name=params.get("CN", email),
+                                    role=params.get("ROLE", "REQ-PARTICIPANT"),
+                                    status=params.get("PARTSTAT", "NEEDS-ACTION"),
+                                    rsvp=params.get("RSVP", "TRUE").upper() == "TRUE",
+                                )
+                            )
+
+                    return event
+
+        except Exception as e:
+            logger.error(f"Error parsing event: {e}")
+
+        return None
+
+    def delete_event(
+        self,
+        calendar_uid: str,
+        event_uid: str,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> bool:
+        """Delete an event by UID - raises exceptions on failure"""
+        request_id = request_id or str(uuid.uuid4())
+
+        calendar = self.calendars.get_calendar(
+            calendar_uid, account_alias, request_id=request_id
+        )
+        if not calendar:
+            raise CalendarNotFoundError(
+                calendar_uid, account_alias, request_id=request_id
+            )
+
+        try:
+            # Use utility function to find event with automatic fallback
+            event = get_item_with_fallback(
+                calendar, event_uid, "event", request_id=request_id
+            )
+            event.delete()
+            logger.info(
+                f"Deleted event '{event_uid}'",
+                extra={"request_id": request_id},
+            )
+            return True
+        except ValueError:
+            # get_item_with_fallback raises ValueError when not found
+            raise EventNotFoundError(event_uid, calendar_uid, request_id=request_id)
+
+        except EventNotFoundError:
+            raise  # Re-raise our own exception
+        except caldav.lib.error.AuthorizationError as e:
+            logger.error(
+                f"Authorization error deleting event '{event_uid}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise EventDeletionError(
+                event_uid, "Authorization failed", request_id=request_id
+            )
+        except Exception as e:
+            logger.error(
+                f"Error deleting event '{event_uid}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise EventDeletionError(event_uid, str(e), request_id=request_id)
+
+    def update_event(
+        self,
+        calendar_uid: str,
+        event_uid: str,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+        location: Optional[str] = None,
+        all_day: Optional[bool] = None,
+        attendees: Optional[List[Dict[str, Any]]] = None,
+        alarm_minutes: Optional[int] = None,
+        recurrence_rule: Optional[str] = None,
+        account_alias: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> Optional[Event]:
+        """Update an existing event - raises exceptions on failure
+
+        Only provided fields will be updated. Other fields remain unchanged.
+        """
+        request_id = request_id or str(uuid.uuid4())
+
+        calendar = self.calendars.get_calendar(
+            calendar_uid, account_alias, request_id=request_id
+        )
+        if not calendar:
+            raise CalendarNotFoundError(
+                calendar_uid, account_alias, request_id=request_id
+            )
+
+        try:
+            # Get existing event using utility function with automatic fallback
+            try:
+                caldav_event = get_item_with_fallback(
+                    calendar, event_uid, "event", request_id=request_id
+                )
+            except ValueError:
+                raise EventNotFoundError(event_uid, calendar_uid, request_id=request_id)
+            # Parse existing event data
+            ical = iCalendar.from_ical(caldav_event.data)
+            existing_event = None
+
+            for component in ical.walk():
+                if component.name == "VEVENT":
+                    existing_event = component
+                    break
+
+            if not existing_event:
+                raise EventCreationError(
+                    f"Event {event_uid}",
+                    "Could not parse existing event data",
+                    request_id=request_id,
+                )
+
+            # Validate RRULE if provided
+            if recurrence_rule is not None:
+                is_valid, error_msg = validate_rrule(recurrence_rule)
+                if not is_valid:
+                    raise EventCreationError(
+                        summary or str(existing_event.get("summary", "")),
+                        f"Invalid RRULE: {error_msg}",
+                        request_id=request_id,
+                    )
+
+            # Update only provided fields
+            if summary is not None:
+                existing_event["summary"] = summary
+
+            if description is not None:
+                if description:
+                    existing_event["description"] = description
+                elif "description" in existing_event:
+                    del existing_event["description"]
+
+            if start is not None:
+                existing_event["dtstart"].dt = start
+
+            if end is not None:
+                existing_event["dtend"].dt = end
+
+            if location is not None:
+                if location:
+                    existing_event["location"] = location
+                elif "location" in existing_event:
+                    del existing_event["location"]
+            if recurrence_rule is not None:
+                if recurrence_rule:
+                    existing_event["rrule"] = recurrence_rule
+                elif "rrule" in existing_event:
+                    del existing_event["rrule"]
+
+            # Update attendees if provided
+            if attendees is not None:
+                # Remove existing attendees
+                if "attendee" in existing_event:
+                    del existing_event["attendee"]
+
+                # Add new attendees
+                for att in attendees:
+                    attendee_str = f"mailto:{att['email']}"
+                    existing_event.add(
+                        "attendee",
+                        attendee_str,
+                        parameters={
+                            "CN": att.get("name", att["email"]),
+                            "ROLE": att.get("role", "REQ-PARTICIPANT"),
+                            "PARTSTAT": att.get("status", "NEEDS-ACTION"),
+                            "RSVP": "TRUE" if att.get("rsvp", True) else "FALSE",
+                        },
+                    )
+
+            # Update alarm if provided
+            if alarm_minutes is not None:
+                # Remove existing alarms
+                for component in list(existing_event.subcomponents):
+                    if component.name == "VALARM":
+                        existing_event.subcomponents.remove(component)
+
+                # Add new alarm if specified
+                if alarm_minutes > 0:
+                    from icalendar import Alarm as iAlarm
+
+                    alarm = iAlarm()
+                    alarm.add("action", "DISPLAY")
+                    alarm.add("trigger", timedelta(minutes=-alarm_minutes))
+                    alarm.add("description", existing_event.get("summary", ""))
+                    existing_event.add_component(alarm)
+
+            # Update last-modified timestamp
+            existing_event["last-modified"] = datetime.now(timezone.utc)
+
+            # Save the updated event
+            caldav_event.data = ical.to_ical().decode("utf-8")
+            caldav_event.save()
+            # Parse and return the updated event
+            return self._parse_caldav_event(caldav_event, calendar_uid, account_alias)
+
+        except EventNotFoundError:
+            raise
+        except EventCreationError:
+            raise
+        except Exception as e:
+            logger.error(
+                f"Error updating event '{event_uid}': {e}",
+                extra={"request_id": request_id},
+            )
+            raise EventCreationError(
+                event_uid, f"Failed to update event: {str(e)}", request_id=request_id
+            )