mindroom 0.0.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

mindroom/config_confirmation.py

@@ -0,0 +1,411 @@
+"""Configuration change confirmation system using Matrix reactions with persistence."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+import nio
+
+from .logging_config import get_logger
+
+if TYPE_CHECKING:
+    from .bot import AgentBot
+
+logger = get_logger(__name__)
+
+# Event type for pending config changes in Matrix state
+PENDING_CONFIG_EVENT_TYPE = "com.mindroom.pending.config"
+
+# Maximum age for pending confirmations (24 hours)
+MAX_PENDING_AGE_HOURS = 24
+
+
+@dataclass
+class PendingConfigChange:
+    """Represents a pending configuration change awaiting confirmation."""
+
+    room_id: str
+    thread_id: str | None
+    config_path: str
+    old_value: Any
+    new_value: Any
+    requester: str  # User who requested the change
+    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+
+    def is_expired(self) -> bool:
+        """Check if this pending change has expired."""
+        age = datetime.now(UTC) - self.created_at
+        return age.total_seconds() > MAX_PENDING_AGE_HOURS * 3600
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for Matrix state storage."""
+        return {
+            "room_id": self.room_id,
+            "thread_id": self.thread_id,
+            "config_path": self.config_path,
+            "old_value": self.old_value,
+            "new_value": self.new_value,
+            "requester": self.requester,
+            "created_at": self.created_at.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PendingConfigChange:
+        """Create from dictionary retrieved from Matrix state."""
+        # Parse the ISO format datetime
+        created_at = datetime.fromisoformat(data["created_at"])
+
+        return cls(
+            room_id=data["room_id"],
+            thread_id=data.get("thread_id"),
+            config_path=data["config_path"],
+            old_value=data["old_value"],
+            new_value=data["new_value"],
+            requester=data["requester"],
+            created_at=created_at,
+        )
+
+
+# Track pending configuration changes by event_id
+_pending_changes: dict[str, PendingConfigChange] = {}
+
+
+def register_pending_change(
+    event_id: str,
+    room_id: str,
+    thread_id: str | None,
+    config_path: str,
+    old_value: Any,  # noqa: ANN401
+    new_value: Any,  # noqa: ANN401
+    requester: str,
+) -> None:
+    """Register a pending configuration change for confirmation.
+
+    Args:
+        event_id: The event ID of the confirmation message
+        room_id: The room ID
+        thread_id: Thread ID if in a thread
+        config_path: The configuration path being changed
+        old_value: The current value
+        new_value: The proposed new value
+        requester: User ID who requested the change
+
+    """
+    _pending_changes[event_id] = PendingConfigChange(
+        room_id=room_id,
+        thread_id=thread_id,
+        config_path=config_path,
+        old_value=old_value,
+        new_value=new_value,
+        requester=requester,
+    )
+    logger.info(
+        "Registered pending config change",
+        event_id=event_id,
+        path=config_path,
+        requester=requester,
+    )
+
+
+def get_pending_change(event_id: str) -> PendingConfigChange | None:
+    """Get a pending configuration change by event ID.
+
+    Args:
+        event_id: The event ID of the confirmation message
+
+    Returns:
+        The pending change or None if not found
+
+    """
+    return _pending_changes.get(event_id)
+
+
+def remove_pending_change(event_id: str) -> PendingConfigChange | None:
+    """Remove and return a pending configuration change.
+
+    Args:
+        event_id: The event ID of the confirmation message
+
+    Returns:
+        The removed pending change or None if not found
+
+    """
+    return _pending_changes.pop(event_id, None)
+
+
+async def store_pending_change_in_matrix(
+    client: nio.AsyncClient,
+    event_id: str,
+    pending_change: PendingConfigChange,
+) -> None:
+    """Store pending config change in Matrix room state for persistence.
+
+    Args:
+        client: The Matrix client
+        event_id: The event ID of the confirmation message
+        pending_change: The pending configuration change
+
+    """
+    try:
+        response = await client.room_put_state(
+            room_id=pending_change.room_id,
+            event_type=PENDING_CONFIG_EVENT_TYPE,
+            content=pending_change.to_dict(),
+            state_key=event_id,
+        )
+
+        if isinstance(response, nio.RoomPutStateResponse):
+            logger.info(
+                "Stored pending config change in Matrix state",
+                event_id=event_id,
+                room_id=pending_change.room_id,
+                config_path=pending_change.config_path,
+            )
+        else:
+            logger.error(
+                "Failed to store pending config change in Matrix state",
+                event_id=event_id,
+                error=str(response),
+            )
+    except Exception:
+        logger.exception("Error storing pending config change in Matrix state")
+
+
+async def remove_pending_change_from_matrix(
+    client: nio.AsyncClient,
+    room_id: str,
+    event_id: str,
+) -> None:
+    """Remove pending config change from Matrix room state.
+
+    Args:
+        client: The Matrix client
+        room_id: The room ID
+        event_id: The event ID of the confirmation message
+
+    """
+    try:
+        # To remove a state event, set it with empty content
+        response = await client.room_put_state(
+            room_id=room_id,
+            event_type=PENDING_CONFIG_EVENT_TYPE,
+            content={},
+            state_key=event_id,
+        )
+
+        if isinstance(response, nio.RoomPutStateResponse):
+            logger.info(
+                "Removed pending config change from Matrix state",
+                event_id=event_id,
+                room_id=room_id,
+            )
+        else:
+            logger.error(
+                "Failed to remove pending config change from Matrix state",
+                event_id=event_id,
+                error=str(response),
+            )
+    except Exception:
+        logger.exception("Error removing pending config change from Matrix state")
+
+
+async def restore_pending_changes(client: nio.AsyncClient, room_id: str) -> int:
+    """Restore pending config changes from Matrix state after bot restart.
+
+    Args:
+        client: The Matrix client
+        room_id: The room ID to restore from
+
+    Returns:
+        Number of pending changes restored
+
+    """
+    try:
+        response = await client.room_get_state(room_id)
+        if not isinstance(response, nio.RoomGetStateResponse):
+            logger.warning(
+                "Failed to get room state for pending config changes",
+                room_id=room_id,
+                error=str(response),
+            )
+            return 0
+
+        restored_count = 0
+        expired_count = 0
+
+        for event in response.events:
+            if event.get("type") != PENDING_CONFIG_EVENT_TYPE:
+                continue
+
+            state_key = event.get("state_key")
+            content = event.get("content", {})
+
+            # Skip empty content (deleted state events)
+            if not content:
+                continue
+
+            try:
+                pending_change = PendingConfigChange.from_dict(content)
+
+                # Check if expired
+                if pending_change.is_expired():
+                    logger.info(
+                        "Skipping expired pending config change",
+                        event_id=state_key,
+                        created_at=pending_change.created_at,
+                    )
+                    # Remove from Matrix state
+                    await remove_pending_change_from_matrix(client, room_id, state_key)
+                    expired_count += 1
+                else:
+                    # Restore to memory
+                    _pending_changes[state_key] = pending_change
+                    restored_count += 1
+                    logger.info(
+                        "Restored pending config change",
+                        event_id=state_key,
+                        config_path=pending_change.config_path,
+                        requester=pending_change.requester,
+                    )
+            except Exception:
+                logger.exception(
+                    "Error restoring pending config change",
+                    event_id=state_key,
+                )
+
+        if restored_count > 0 or expired_count > 0:
+            logger.info(
+                "Completed restoration of pending config changes",
+                room_id=room_id,
+                restored=restored_count,
+                expired=expired_count,
+            )
+
+        return restored_count  # noqa: TRY300
+
+    except Exception:
+        logger.exception("Error restoring pending config changes from Matrix state")
+        return 0
+
+
+def cleanup() -> None:
+    """Clean up when shutting down."""
+    _pending_changes.clear()
+
+
+async def add_confirmation_reactions(client: nio.AsyncClient, room_id: str, event_id: str) -> None:
+    """Add confirmation reaction buttons to a config change message.
+
+    Args:
+        client: The Matrix client
+        room_id: The room ID
+        event_id: The event ID of the message to add reactions to
+
+    """
+    # Add ✅ reaction
+    confirm_response = await client.room_send(
+        room_id=room_id,
+        message_type="m.reaction",
+        content={
+            "m.relates_to": {
+                "rel_type": "m.annotation",
+                "event_id": event_id,
+                "key": "✅",
+            },
+        },
+    )
+    if not isinstance(confirm_response, nio.RoomSendResponse):
+        logger.warning("Failed to add confirm reaction", error=str(confirm_response))
+
+    # Add ❌ reaction
+    cancel_response = await client.room_send(
+        room_id=room_id,
+        message_type="m.reaction",
+        content={
+            "m.relates_to": {
+                "rel_type": "m.annotation",
+                "event_id": event_id,
+                "key": "❌",
+            },
+        },
+    )
+    if not isinstance(cancel_response, nio.RoomSendResponse):
+        logger.warning("Failed to add cancel reaction", error=str(cancel_response))
+
+
+async def handle_confirmation_reaction(
+    bot: AgentBot,
+    room: nio.MatrixRoom,
+    event: nio.ReactionEvent,
+    pending_change: PendingConfigChange,
+) -> None:
+    """Handle reactions to config confirmation messages.
+
+    Args:
+        bot: The agent bot instance
+        room: The room the reaction occurred in
+        event: The reaction event
+        pending_change: The pending configuration change
+
+    """
+    # Only process reactions from the requester
+    if event.sender != pending_change.requester:
+        logger.debug(
+            "Ignoring config reaction from non-requester",
+            sender=event.sender,
+            requester=pending_change.requester,
+        )
+        return
+
+    # Don't process our own reactions
+    assert bot.client is not None
+    if event.sender == bot.client.user_id:
+        return
+
+    reaction_key = event.key
+
+    # Only handle ✅ and ❌ reactions
+    if reaction_key not in ["✅", "❌"]:
+        return
+
+    # Remove the pending change from memory and Matrix state
+    remove_pending_change(event.reacts_to)
+    await remove_pending_change_from_matrix(
+        bot.client,
+        pending_change.room_id,
+        event.reacts_to,
+    )
+
+    if reaction_key == "✅":
+        # User confirmed - apply the change
+        from .config_commands import apply_config_change  # noqa: PLC0415
+
+        response_text = await apply_config_change(
+            pending_change.config_path,
+            pending_change.new_value,
+        )
+
+        logger.info(
+            "Config change confirmed",
+            path=pending_change.config_path,
+            requester=event.sender,
+        )
+    else:
+        # User cancelled
+        response_text = "❌ Configuration change cancelled."
+        logger.info(
+            "Config change cancelled",
+            path=pending_change.config_path,
+            requester=event.sender,
+        )
+
+    # Send the response
+    await bot._send_response(
+        room.room_id,
+        event.reacts_to,  # Reply to the confirmation message
+        response_text,
+        pending_change.thread_id,
+        skip_mentions=True,
+    )

mindroom/constants.py

@@ -0,0 +1,52 @@
+"""Shared constants for the mindroom package.
+
+This module contains constants that are used across multiple modules
+to avoid circular imports. It does not import anything from the internal
+codebase.
+"""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Agent names
+ROUTER_AGENT_NAME = "router"
+
+# Default path to agents configuration file. Allow overriding via environment
+# variable so deployments can place the writable configuration file on a
+# persistent volume instead of the package directory (which may be read-only).
+_CONFIG_PATH_ENV = os.getenv("MINDROOM_CONFIG_PATH") or os.getenv("CONFIG_PATH")
+DEFAULT_AGENTS_CONFIG = (
+    Path(_CONFIG_PATH_ENV).expanduser() if _CONFIG_PATH_ENV else Path(__file__).parent.parent.parent / "config.yaml"
+)
+
+# Optional template path used to seed the writable config file if it does not
+# exist yet. Defaults to the same location as DEFAULT_AGENTS_CONFIG so the
+# behaviour is unchanged when no overrides are provided.
+_CONFIG_TEMPLATE_ENV = os.getenv("MINDROOM_CONFIG_TEMPLATE") or os.getenv("CONFIG_TEMPLATE_PATH")
+DEFAULT_CONFIG_TEMPLATE = Path(_CONFIG_TEMPLATE_ENV).expanduser() if _CONFIG_TEMPLATE_ENV else DEFAULT_AGENTS_CONFIG
+
+STORAGE_PATH = os.getenv("STORAGE_PATH", "mindroom_data")
+STORAGE_PATH_OBJ = Path(STORAGE_PATH)
+
+# Specific files and directories
+MATRIX_STATE_FILE = STORAGE_PATH_OBJ / "matrix_state.yaml"
+SESSIONS_DIR = STORAGE_PATH_OBJ / "sessions"
+TRACKING_DIR = STORAGE_PATH_OBJ / "tracking"
+MEMORY_DIR = STORAGE_PATH_OBJ / "memory"
+CREDENTIALS_DIR = STORAGE_PATH_OBJ / "credentials"
+ENCRYPTION_KEYS_DIR = STORAGE_PATH_OBJ / "encryption_keys"
+
+# Other constants
+VOICE_PREFIX = "🎤 "
+ENABLE_STREAMING = os.getenv("MINDROOM_ENABLE_STREAMING", "true").lower() != "false"
+ENABLE_AI_CACHE = os.getenv("ENABLE_AI_CACHE", "true").lower() != "false"
+
+# Matrix
+MATRIX_HOMESERVER = os.getenv("MATRIX_HOMESERVER", "http://localhost:8008")
+# (for federation setups where hostname != server_name)
+MATRIX_SERVER_NAME = os.getenv("MATRIX_SERVER_NAME", None)
+MATRIX_SSL_VERIFY = os.getenv("MATRIX_SSL_VERIFY", "true").lower() != "false"

mindroom/credentials.py

@@ -0,0 +1,146 @@
+"""Unified credentials management for MindRoom.
+
+This module provides centralized credential storage and retrieval for all integrations,
+used by both agents and the widget interface.
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .constants import CREDENTIALS_DIR
+
+
+class CredentialsManager:
+    """Centralized credentials storage and retrieval for MindRoom."""
+
+    def __init__(self, base_path: Path | None = None) -> None:
+        """Initialize the credentials manager.
+
+        Args:
+            base_path: Base directory for storing credentials.
+                      Defaults to STORAGE_PATH/credentials (usually mindroom_data/credentials)
+
+        """
+        if base_path is None:
+            self.base_path = CREDENTIALS_DIR
+        else:
+            self.base_path = Path(base_path)
+
+        # Ensure the directory exists
+        self.base_path.mkdir(parents=True, exist_ok=True)
+
+    def get_credentials_path(self, service: str) -> Path:
+        """Get the path for a service's credentials file.
+
+        Args:
+            service: Name of the service (e.g., 'google', 'homeassistant')
+
+        Returns:
+            Path to the credentials file
+
+        """
+        return self.base_path / f"{service}_credentials.json"
+
+    def load_credentials(self, service: str) -> dict[str, Any] | None:
+        """Load credentials for a service.
+
+        Args:
+            service: Name of the service
+
+        Returns:
+            Credentials dictionary or None if not found
+
+        """
+        credentials_path = self.get_credentials_path(service)
+        if credentials_path.exists():
+            try:
+                with credentials_path.open() as f:
+                    data: dict[str, Any] = json.load(f)
+                    return data
+            except Exception:
+                return None
+        return None
+
+    def save_credentials(self, service: str, credentials: dict[str, Any]) -> None:
+        """Save credentials for a service.
+
+        Args:
+            service: Name of the service
+            credentials: Credentials dictionary to save
+
+        """
+        credentials_path = self.get_credentials_path(service)
+        with credentials_path.open("w") as f:
+            json.dump(credentials, f, indent=2)
+
+    def delete_credentials(self, service: str) -> None:
+        """Delete credentials for a service.
+
+        Args:
+            service: Name of the service
+
+        """
+        credentials_path = self.get_credentials_path(service)
+        if credentials_path.exists():
+            credentials_path.unlink()
+
+    def list_services(self) -> list[str]:
+        """List all services with stored credentials.
+
+        Returns:
+            List of service names
+
+        """
+        services = []
+        if self.base_path.exists():
+            for path in self.base_path.glob("*_credentials.json"):
+                service = path.stem.replace("_credentials", "")
+                services.append(service)
+        return sorted(services)
+
+    def get_api_key(self, service: str, key_name: str = "api_key") -> str | None:
+        """Get an API key for a service.
+
+        Args:
+            service: Name of the service (e.g., 'openai', 'anthropic')
+            key_name: Name of the key field (default: 'api_key')
+
+        Returns:
+            API key string or None if not found
+
+        """
+        credentials = self.load_credentials(service)
+        if credentials:
+            return credentials.get(key_name)
+        return None
+
+    def set_api_key(self, service: str, api_key: str, key_name: str = "api_key") -> None:
+        """Set an API key for a service.
+
+        Args:
+            service: Name of the service
+            api_key: The API key to store
+            key_name: Name of the key field (default: 'api_key')
+
+        """
+        credentials = self.load_credentials(service) or {}
+        credentials[key_name] = api_key
+        self.save_credentials(service, credentials)
+
+
+# Global instance for convenience (lazy initialization)
+_credentials_manager: CredentialsManager | None = None
+
+
+def get_credentials_manager() -> CredentialsManager:
+    """Get the global credentials manager instance.
+
+    Returns:
+        The global CredentialsManager instance
+
+    """
+    global _credentials_manager
+    if _credentials_manager is None:
+        _credentials_manager = CredentialsManager()
+    return _credentials_manager