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

mindroom/matrix/rooms.py

@@ -0,0 +1,311 @@
+"""Matrix room management functions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import nio
+
+from mindroom.logging_config import get_logger
+from mindroom.topic_generator import ensure_room_has_topic, generate_room_topic_ai
+
+from .client import check_and_set_avatar, create_room, join_room, matrix_client
+from .identity import MatrixID, extract_server_name_from_homeserver
+from .state import MatrixRoom, MatrixState
+
+if TYPE_CHECKING:
+    from mindroom.config import Config
+
+logger = get_logger(__name__)
+
+
+def room_key_to_name(room_key: str) -> str:
+    """Convert a room key to a human-readable room name.
+
+    Args:
+        room_key: The room key (e.g., 'dev', 'analysis_room')
+
+    Returns:
+        Human-readable room name (e.g., 'Dev', 'Analysis Room')
+
+    """
+    return room_key.replace("_", " ").title()
+
+
+def load_rooms() -> dict[str, MatrixRoom]:
+    """Load room state from YAML file."""
+    state = MatrixState.load()
+    return state.rooms
+
+
+def get_room_aliases() -> dict[str, str]:
+    """Get mapping of room aliases to room IDs."""
+    state = MatrixState.load()
+    return state.get_room_aliases()
+
+
+def get_room_id(room_key: str) -> str | None:
+    """Get room ID for a given room key/alias."""
+    state = MatrixState.load()
+    room = state.get_room(room_key)
+    return room.room_id if room else None
+
+
+def add_room(room_key: str, room_id: str, alias: str, name: str) -> None:
+    """Add a new room to the state."""
+    state = MatrixState.load()
+    state.add_room(room_key, room_id, alias, name)
+    state.save()
+
+
+def remove_room(room_key: str) -> bool:
+    """Remove a room from the state."""
+    state = MatrixState.load()
+    if room_key in state.rooms:
+        del state.rooms[room_key]
+        state.save()
+        return True
+    return False
+
+
+def resolve_room_aliases(room_list: list[str]) -> list[str]:
+    """Resolve room aliases to room IDs.
+
+    Args:
+        room_list: List of room aliases or IDs
+
+    Returns:
+        List of room IDs (aliases resolved to IDs, IDs passed through)
+
+    """
+    room_aliases = get_room_aliases()
+    return [room_aliases.get(room, room) for room in room_list]
+
+
+def get_room_alias_from_id(room_id: str) -> str | None:
+    """Get room alias from room ID (reverse lookup).
+
+    Args:
+        room_id: Matrix room ID
+
+    Returns:
+        Room alias if found, None otherwise
+
+    """
+    room_aliases = get_room_aliases()
+    for alias, rid in room_aliases.items():
+        if rid == room_id:
+            return alias
+    return None
+
+
+async def ensure_room_exists(  # noqa: C901
+    client: nio.AsyncClient,
+    room_key: str,
+    config: Config,
+    room_name: str | None = None,
+    power_users: list[str] | None = None,
+) -> str | None:
+    """Ensure a room exists, creating it if necessary.
+
+    Args:
+        client: Matrix client to use for room creation
+        room_key: The room key/alias (without domain)
+        config: Configuration with agent settings for topic generation
+        room_name: Display name for the room (defaults to room_key with underscores replaced)
+        power_users: List of user IDs to grant power levels to
+
+    Returns:
+        Room ID if room exists or was created, None on failure
+
+    """
+    existing_rooms = load_rooms()
+
+    # First, try to resolve the room alias on the server
+    # This handles cases where the room exists on server but not in our state
+    server_name = extract_server_name_from_homeserver(client.homeserver)
+    full_alias = f"#{room_key}:{server_name}"
+
+    response = await client.room_resolve_alias(full_alias)
+    if isinstance(response, nio.RoomResolveAliasResponse):
+        room_id = response.room_id
+        logger.debug(f"Room alias {full_alias} exists on server, room ID: {room_id}")
+
+        # Update our state if needed
+        if room_key not in existing_rooms or existing_rooms[room_key].room_id != room_id:
+            if room_name is None:
+                room_name = room_key_to_name(room_key)
+            add_room(room_key, room_id, full_alias, room_name)
+            logger.info(f"Updated state with existing room {room_key} (ID: {room_id})")
+
+        # Try to join the room
+        if await join_room(client, room_id):
+            # For existing rooms, ensure they have a topic set
+            if room_name is None:
+                room_name = room_key_to_name(room_key)
+            await ensure_room_has_topic(client, room_id, room_key, room_name, config)
+            return str(room_id)
+        # Room exists but we can't join - this means the room was created
+        # but this user isn't a member. Return the room ID anyway since
+        # the room does exist and invitations will be handled separately
+        logger.debug(f"Room {room_key} exists but user not a member, returning room ID for invitation handling")
+        return str(room_id)
+
+    # Room alias doesn't exist on server, so we can create it
+    if room_key in existing_rooms:
+        # Remove stale entry from state
+        logger.debug(f"Removing stale room {room_key} from state")
+        remove_room(room_key)
+
+    # Create the room
+    if room_name is None:
+        room_name = room_key_to_name(room_key)
+
+    # Generate a contextual topic for the room using AI
+    topic = await generate_room_topic_ai(room_key, room_name, config)
+    logger.info(f"Creating room {room_key} with topic: {topic}")
+
+    created_room_id = await create_room(
+        client=client,
+        name=room_name,
+        alias=room_key,
+        topic=topic,
+        power_users=power_users or [],
+    )
+
+    if created_room_id:
+        # Save room info
+        add_room(room_key, created_room_id, full_alias, room_name)
+        logger.info(f"Created room {room_key} with ID {created_room_id}")
+
+        # Set room avatar if available (for newly created rooms)
+        # Note: Avatars can also be updated later using scripts/generate_avatars.py
+        avatar_path = Path(__file__).parent.parent.parent.parent / "avatars" / "rooms" / f"{room_key}.png"
+        if avatar_path.exists():
+            if await check_and_set_avatar(client, avatar_path, room_id=created_room_id):
+                logger.info(f"Set avatar for newly created room {room_key}")
+            else:
+                logger.warning(f"Failed to set avatar for room {room_key}")
+
+        return created_room_id
+    logger.error(f"Failed to create room {room_key}")
+    return None
+
+
+async def ensure_all_rooms_exist(
+    client: nio.AsyncClient,
+    config: Config,
+) -> dict[str, str]:
+    """Ensure all configured rooms exist and invite user account.
+
+    Args:
+        client: Matrix client to use for room creation
+        config: Configuration with room settings
+
+    Returns:
+        Dict mapping room keys to room IDs
+
+    """
+    from mindroom.agents import get_agent_ids_for_room  # noqa: PLC0415
+
+    room_ids = {}
+
+    # Get all configured rooms
+    all_rooms = config.get_all_configured_rooms()
+
+    for room_key in all_rooms:
+        # Skip if this is a room ID (starts with !)
+        if room_key.startswith("!"):
+            # This is a room ID, not a room key/alias - skip it
+            continue
+
+        # Get power users for this room
+        power_users = get_agent_ids_for_room(room_key, config)
+
+        # Ensure room exists
+        room_id = await ensure_room_exists(
+            client=client,
+            room_key=room_key,
+            config=config,
+            power_users=power_users,
+        )
+
+        if room_id:
+            room_ids[room_key] = room_id
+
+    return room_ids
+
+
+async def ensure_user_in_rooms(homeserver: str, room_ids: dict[str, str]) -> None:
+    """Ensure the user account is a member of all specified rooms.
+
+    Args:
+        homeserver: Matrix homeserver URL
+        room_ids: Dict mapping room keys to room IDs
+
+    """
+    state = MatrixState.load()
+    # User account is stored as "agent_user" (treated as a special agent)
+    user_account = state.get_account("agent_user")
+    if not user_account:
+        logger.warning("No user account found, skipping user room membership")
+        return
+
+    server_name = extract_server_name_from_homeserver(homeserver)
+    user_id = MatrixID.from_username(user_account.username, server_name).full_id
+
+    # Create a client for the user to join rooms
+    async with matrix_client(homeserver, user_id) as user_client:
+        # Login as the user
+        login_response = await user_client.login(password=user_account.password)
+        if not isinstance(login_response, nio.LoginResponse):
+            logger.error(f"Failed to login as user {user_id}: {login_response}")
+            return
+
+        logger.info(f"User {user_id} logged in to join rooms")
+
+        for room_key, room_id in room_ids.items():
+            # Try to join the room (will work if invited or room is public)
+            join_success = await join_room(user_client, room_id)
+            if join_success:
+                logger.info(f"User {user_id} joined room {room_key}")
+            else:
+                logger.warning(f"User {user_id} failed to join room {room_key} - may need invitation")
+
+
+DM_ROOM_CACHE: dict[str, bool] = {}
+
+
+async def is_dm_room(client: nio.AsyncClient, room_id: str) -> bool:
+    """Check if a room is a Direct Message (DM) room.
+
+    DM rooms have the "is_direct" flag set to true in member state events.
+    This function checks the room state to determine if it's a DM.
+
+    Args:
+        client: The Matrix client
+        room_id: The room ID to check
+
+    Returns:
+        True if the room is a DM room, False otherwise
+
+    """
+    if room_id in DM_ROOM_CACHE:
+        return DM_ROOM_CACHE[room_id]
+    # Get the room state events, specifically member events
+    response = await client.room_get_state(room_id)
+
+    if isinstance(response, nio.RoomGetStateResponse):
+        # Check member events for the is_direct flag
+        for event in response.events:
+            if event.get("type") == "m.room.member":
+                content = event.get("content", {})
+                if content.get("is_direct") is True:
+                    # Cache the result for this room ID
+                    DM_ROOM_CACHE[room_id] = True
+                    return True
+
+    # If we can't find is_direct=true in any member event, it's not a DM
+    DM_ROOM_CACHE[room_id] = False
+    return False

mindroom/matrix/state.py

@@ -0,0 +1,77 @@
+"""Pydantic models for Matrix state."""
+
+from datetime import UTC, datetime
+from typing import Self
+
+import yaml
+from pydantic import BaseModel, Field, field_serializer
+
+from mindroom.constants import MATRIX_STATE_FILE
+
+
+class MatrixAccount(BaseModel):
+    """Represents a Matrix account (user or agent)."""
+
+    username: str
+    password: str
+
+
+class MatrixRoom(BaseModel):
+    """Represents a Matrix room state."""
+
+    room_id: str
+    alias: str
+    name: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+    @field_serializer("created_at")
+    def serialize_datetime(self, dt: datetime) -> str:
+        """Serialize datetime to ISO format string."""
+        return dt.isoformat()
+
+
+class MatrixState(BaseModel):
+    """Complete Matrix state including accounts and rooms."""
+
+    accounts: dict[str, MatrixAccount] = Field(default_factory=dict)
+    rooms: dict[str, MatrixRoom] = Field(default_factory=dict)
+
+    @classmethod
+    def load(cls) -> Self:
+        """Load state from file."""
+        if not MATRIX_STATE_FILE.exists():
+            return cls()
+
+        with MATRIX_STATE_FILE.open() as f:
+            data = yaml.safe_load(f) or {}
+
+        return cls.model_validate(data)
+
+    def save(self) -> None:
+        """Save state to file."""
+        # Use Pydantic's model_dump with custom serializer for datetime
+        data = self.model_dump(mode="json")
+
+        MATRIX_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with MATRIX_STATE_FILE.open("w") as f:
+            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+    def get_account(self, key: str) -> MatrixAccount | None:
+        """Get an account by key."""
+        return self.accounts.get(key)
+
+    def add_account(self, key: str, username: str, password: str) -> None:
+        """Add or update an account."""
+        self.accounts[key] = MatrixAccount(username=username, password=password)
+
+    def get_room(self, key: str) -> MatrixRoom | None:
+        """Get a room by key."""
+        return self.rooms.get(key)
+
+    def add_room(self, key: str, room_id: str, alias: str, name: str) -> None:
+        """Add or update a room."""
+        self.rooms[key] = MatrixRoom(room_id=room_id, alias=alias, name=name, created_at=datetime.now(tz=UTC))
+
+    def get_room_aliases(self) -> dict[str, str]:
+        """Get mapping of room aliases to room IDs."""
+        return {key: room.room_id for key, room in self.rooms.items()}

mindroom/matrix/typing.py

@@ -0,0 +1,91 @@
+"""Typing indicator management for Matrix agents."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager, suppress
+from typing import TYPE_CHECKING
+
+import nio
+
+from mindroom.logging_config import get_logger
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+logger = get_logger(__name__)
+
+
+async def set_typing(
+    client: nio.AsyncClient,
+    room_id: str,
+    typing: bool = True,
+    timeout_seconds: int = 30,
+) -> None:
+    """Set typing status for a user in a room.
+
+    Args:
+        client: Matrix client instance
+        room_id: Room to show typing indicator in
+        typing: Whether to show or hide typing indicator
+        timeout_seconds: How long the typing indicator should last (in seconds)
+
+    """
+    timeout_ms = timeout_seconds * 1000
+    response = await client.room_typing(room_id, typing, timeout_ms)
+    if isinstance(response, nio.RoomTypingError):
+        logger.warning(
+            "Failed to set typing status",
+            room_id=room_id,
+            typing=typing,
+            error=response.message,
+        )
+    else:
+        logger.debug("Set typing status", room_id=room_id, typing=typing)
+
+
+@asynccontextmanager
+async def typing_indicator(
+    client: nio.AsyncClient,
+    room_id: str,
+    timeout_seconds: int = 30,
+) -> AsyncGenerator[None, None]:
+    """Context manager for showing typing indicator while processing.
+
+    Usage:
+        async with typing_indicator(client, room_id):
+            # Do work here - typing indicator shown
+            response = await generate_response()
+        # Typing indicator automatically stopped
+
+    Args:
+        client: Matrix client instance
+        room_id: Room to show typing indicator in
+        timeout_seconds: How long each typing notification lasts
+
+    """
+    # Start typing
+    await set_typing(client, room_id, True, timeout_seconds)
+
+    # Create a task to periodically refresh the typing indicator
+    # Matrix typing indicators expire, so we need to refresh them
+    refresh_interval = min(timeout_seconds / 2, 15)  # Refresh at half timeout or 15s
+
+    async def refresh_typing() -> None:
+        """Refresh typing indicator periodically."""
+        while True:
+            await asyncio.sleep(refresh_interval)
+            await set_typing(client, room_id, True, timeout_seconds)
+
+    refresh_task = asyncio.create_task(refresh_typing())
+
+    try:
+        yield
+    finally:
+        # Cancel refresh task
+        refresh_task.cancel()
+        with suppress(asyncio.CancelledError):
+            await refresh_task
+
+        # Stop typing
+        await set_typing(client, room_id, False)

mindroom/matrix/users.py

@@ -0,0 +1,217 @@
+"""Matrix user account management for agents."""
+
+from dataclasses import dataclass
+from functools import cached_property
+
+import nio
+
+from mindroom.config import Config
+from mindroom.constants import ROUTER_AGENT_NAME
+from mindroom.logging_config import get_logger
+
+from .client import login, register_user
+from .identity import MatrixID, extract_server_name_from_homeserver
+from .state import MatrixState
+
+logger = get_logger(__name__)
+
+
+def extract_domain_from_user_id(user_id: str) -> str:
+    """Extract domain from a Matrix user ID like "@user:example.com"."""
+    if not user_id.startswith("@") or ":" not in user_id:
+        return "localhost"
+    return MatrixID.parse(user_id).domain
+
+
+@dataclass
+class AgentMatrixUser:
+    """Represents a Matrix user account for an agent."""
+
+    agent_name: str
+    user_id: str
+    display_name: str
+    password: str
+    access_token: str | None = None
+
+    @cached_property
+    def matrix_id(self) -> MatrixID:
+        """MatrixID object from user_id."""
+        return MatrixID.parse(self.user_id)
+
+
+def get_agent_credentials(agent_name: str) -> dict[str, str] | None:
+    """Get credentials for a specific agent from matrix_state.yaml.
+
+    Args:
+        agent_name: The agent name
+
+    Returns:
+        Dictionary with username and password, or None if not found
+
+    """
+    state = MatrixState.load()
+    agent_key = f"agent_{agent_name}"
+    account = state.get_account(agent_key)
+    if account:
+        return {"username": account.username, "password": account.password}
+    return None
+
+
+def save_agent_credentials(agent_name: str, username: str, password: str) -> None:
+    """Save credentials for a specific agent to matrix_state.yaml.
+
+    Args:
+        agent_name: The agent name
+        username: The Matrix username
+        password: The Matrix password
+
+    """
+    state = MatrixState.load()
+    agent_key = f"agent_{agent_name}"
+    state.add_account(agent_key, username, password)
+    state.save()
+    logger.info(f"Saved credentials for agent {agent_name}")
+
+
+async def create_agent_user(
+    homeserver: str,
+    agent_name: str,
+    agent_display_name: str,
+) -> AgentMatrixUser:
+    """Create or retrieve a Matrix user account for an agent.
+
+    Args:
+        homeserver: The Matrix homeserver URL
+        agent_name: The internal agent name (e.g., 'calculator')
+        agent_display_name: The display name for the agent (e.g., 'CalculatorAgent')
+
+    Returns:
+        AgentMatrixUser object with account details
+
+    """
+    # Check if credentials already exist in matrix_state.yaml
+    existing_creds = get_agent_credentials(agent_name)
+
+    if existing_creds:
+        username = existing_creds["username"]
+        password = existing_creds["password"]
+        logger.info(f"Using existing credentials for agent {agent_name} from matrix_state.yaml")
+        registration_needed = False
+    else:
+        # Generate new credentials
+        username = f"mindroom_{agent_name}"
+        password = f"{agent_name}_secure_password"  # _{os.urandom(8).hex()}"
+        logger.info(f"Generated new credentials for agent {agent_name}")
+        registration_needed = True
+
+    # Extract server name from homeserver URL
+    server_name = extract_server_name_from_homeserver(homeserver)
+    user_id = MatrixID.from_username(username, server_name).full_id
+
+    # Try to register/verify the user
+    try:
+        await register_user(
+            homeserver=homeserver,
+            username=username,
+            password=password,
+            display_name=agent_display_name,
+        )
+        # Only save credentials after successful registration
+        if registration_needed:
+            save_agent_credentials(agent_name, username, password)
+            logger.info(f"Saved credentials for agent {agent_name} after successful registration")
+    except ValueError as e:
+        # If user already exists, that's fine
+        error_msg = str(e) if e else ""
+        logger.debug(f"ValueError when registering {username}: {error_msg}")
+        if "already exists" not in error_msg and "RegisterErrorResponse" not in error_msg:
+            raise
+        # Save credentials if the user already exists (registration succeeded in the past)
+        if registration_needed and "already exists" in error_msg:
+            save_agent_credentials(agent_name, username, password)
+            logger.info(f"Saved credentials for agent {agent_name} (user already exists)")
+
+    return AgentMatrixUser(
+        agent_name=agent_name,
+        user_id=user_id,
+        display_name=agent_display_name,
+        password=password,
+    )
+
+
+async def login_agent_user(homeserver: str, agent_user: AgentMatrixUser) -> nio.AsyncClient:
+    """Login an agent user and return the authenticated client.
+
+    Args:
+        homeserver: The Matrix homeserver URL
+        agent_user: The agent user to login
+
+    Returns:
+        Authenticated AsyncClient instance
+
+    Raises:
+        ValueError: If login fails
+
+    """
+    client = await login(homeserver, agent_user.user_id, agent_user.password)
+    agent_user.access_token = client.access_token
+    return client
+
+
+# TODO: Check, this seems unused!
+async def ensure_all_agent_users(homeserver: str, config: Config) -> dict[str, AgentMatrixUser]:
+    """Ensure all configured agents and teams have Matrix user accounts.
+
+    This includes user-configured agents, teams, and the built-in router agent.
+
+    Args:
+        homeserver: The Matrix homeserver URL
+        config: Application configuration
+
+    Returns:
+        Dictionary mapping agent/team names to AgentMatrixUser objects
+
+    """
+    agent_users = {}
+
+    # First, create the built-in router agent
+    try:
+        router_user = await create_agent_user(
+            homeserver,
+            ROUTER_AGENT_NAME,
+            "RouterAgent",
+        )
+        agent_users[ROUTER_AGENT_NAME] = router_user
+        logger.info(f"Ensured Matrix user for built-in router agent: {router_user.user_id}")
+    except Exception:
+        logger.exception("Failed to create Matrix user for built-in router agent")
+
+    # Create user-configured agents
+    for agent_name, agent_config in config.agents.items():
+        try:
+            agent_user = await create_agent_user(
+                homeserver,
+                agent_name,
+                agent_config.display_name,
+            )
+            agent_users[agent_name] = agent_user
+            logger.info(f"Ensured Matrix user for agent: {agent_name} -> {agent_user.user_id}")
+        except Exception:
+            # Continue with other agents even if one fails
+            logger.exception("Failed to create Matrix user for agent", agent_name=agent_name)
+
+    # Create team users
+    for team_name, team_config in config.teams.items():
+        try:
+            team_user = await create_agent_user(
+                homeserver,
+                team_name,
+                team_config.display_name,
+            )
+            agent_users[team_name] = team_user
+            logger.info(f"Ensured Matrix user for team: {team_name} -> {team_user.user_id}")
+        except Exception:
+            # Continue with other teams even if one fails
+            logger.exception("Failed to create Matrix user for team", team_name=team_name)
+
+    return agent_users