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

mindroom/matrix/event_info.py

@@ -0,0 +1,173 @@
+"""Comprehensive event relation analysis for Matrix events.
+
+This module provides a unified API for analyzing all Matrix event relations
+including threads (MSC3440), edits, replies, reactions, and more.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class EventInfo:
+    """Comprehensive analysis of Matrix event relations."""
+
+    # Thread information (MSC3440)
+    is_thread: bool
+    """Whether this event is part of a thread."""
+
+    thread_id: str | None
+    """The thread root event ID if this is a thread message."""
+
+    can_be_thread_root: bool
+    """Whether this event can be used as a thread root per MSC3440."""
+
+    safe_thread_root: str | None
+    """Safe event ID to use as thread root (None means use this event)."""
+
+    # Edit information
+    is_edit: bool
+    """Whether this event is an edit (m.replace)."""
+
+    original_event_id: str | None
+    """The event ID being edited if this is an edit."""
+
+    # Reply information
+    is_reply: bool
+    """Whether this event is a reply to another event."""
+
+    reply_to_event_id: str | None
+    """The event ID being replied to if this is a reply."""
+
+    # Reaction information
+    is_reaction: bool
+    """Whether this event is a reaction (m.annotation)."""
+
+    reaction_key: str | None
+    """The reaction key/emoji if this is a reaction."""
+
+    reaction_target_event_id: str | None
+    """The event ID being reacted to if this is a reaction."""
+
+    # General relation information
+    has_relations: bool
+    """Whether this event has any relations."""
+
+    relation_type: str | None
+    """The relation type if any (m.replace, m.annotation, m.thread, etc)."""
+
+    relates_to_event_id: str | None
+    """The primary event ID this event relates to (if any)."""
+
+    @staticmethod
+    def from_event(event_source: dict | None) -> EventInfo:
+        """Create EventInfo from a raw event source dictionary."""
+        return _analyze_event_relations(event_source)
+
+
+def _analyze_event_relations(event_source: dict | None) -> EventInfo:
+    """Analyze complete relation information for a Matrix event.
+
+    This unified function provides all relation-related information in one place,
+    replacing manual extraction of m.relates_to throughout the codebase.
+
+    Per MSC3440:
+    - A thread can only be created from events that don't have any rel_type
+    - Thread messages use rel_type: m.thread
+    - Edits use rel_type: m.replace
+    - Reactions use rel_type: m.annotation
+    - Replies can be within threads or standalone
+
+    Args:
+        event_source: The event source dictionary (e.g., event.source for nio events)
+
+    Returns:
+        EventInfo object with complete relation analysis
+
+    """
+    if not event_source:
+        return EventInfo(
+            is_thread=False,
+            thread_id=None,
+            can_be_thread_root=True,
+            safe_thread_root=None,
+            is_edit=False,
+            original_event_id=None,
+            is_reply=False,
+            reply_to_event_id=None,
+            is_reaction=False,
+            reaction_key=None,
+            reaction_target_event_id=None,
+            has_relations=False,
+            relation_type=None,
+            relates_to_event_id=None,
+        )
+
+    content = event_source.get("content", {})
+    relates_to = content.get("m.relates_to", {})
+
+    # Extract basic relation information
+    relation_type = relates_to.get("rel_type")
+    has_relations = bool(relates_to)
+    relates_to_event_id = relates_to.get("event_id")
+
+    # Thread analysis
+    is_thread = relation_type == "m.thread"
+    thread_id = relates_to_event_id if is_thread else None
+
+    # Edit analysis
+    is_edit = relation_type == "m.replace"
+    original_event_id = relates_to_event_id if is_edit else None
+
+    # Reaction analysis
+    is_reaction = relation_type == "m.annotation"
+    reaction_key = relates_to.get("key") if is_reaction else None
+    reaction_target_event_id = relates_to_event_id if is_reaction else None
+
+    # Reply analysis
+    # Replies can exist within threads or as standalone
+    # They have m.in_reply_to field
+    in_reply_to = relates_to.get("m.in_reply_to", {})
+    is_reply = bool(in_reply_to and in_reply_to.get("event_id"))
+    reply_to_event_id = in_reply_to.get("event_id") if is_reply else None
+
+    # Determine if this event can be a thread root (per MSC3440)
+    # An event can only be a thread root if it has NO relations
+    can_be_thread_root = not has_relations
+
+    # Determine safe thread root for creating new threads
+    safe_thread_root = None
+    if not can_be_thread_root:
+        # This event has relations, so it cannot be a thread root
+        # Try to use the target of the relation as the thread root
+
+        if relation_type in ("m.replace", "m.annotation", "m.reference"):
+            # For edits, reactions, and references, use the target event
+            if relates_to_event_id:
+                safe_thread_root = str(relates_to_event_id)
+        elif is_reply and reply_to_event_id:
+            # For rich replies, use the event being replied to
+            safe_thread_root = str(reply_to_event_id)
+
+    return EventInfo(
+        # Thread info
+        is_thread=is_thread,
+        thread_id=thread_id,
+        can_be_thread_root=can_be_thread_root,
+        safe_thread_root=safe_thread_root,
+        # Edit info
+        is_edit=is_edit,
+        original_event_id=original_event_id,
+        # Reply info
+        is_reply=is_reply,
+        reply_to_event_id=reply_to_event_id,
+        # Reaction info
+        is_reaction=is_reaction,
+        reaction_key=reaction_key,
+        reaction_target_event_id=reaction_target_event_id,
+        # General info
+        has_relations=has_relations,
+        relation_type=relation_type,
+        relates_to_event_id=relates_to_event_id,
+    )

mindroom/matrix/identity.py

@@ -0,0 +1,149 @@
+"""Unified Matrix ID handling system."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import TYPE_CHECKING, ClassVar
+
+from mindroom.constants import MATRIX_SERVER_NAME, ROUTER_AGENT_NAME
+
+if TYPE_CHECKING:
+    from mindroom.config import Config
+
+
+@dataclass(frozen=True)
+class MatrixID:
+    """Immutable Matrix ID representation with parsing and validation."""
+
+    username: str
+    domain: str
+
+    AGENT_PREFIX: ClassVar[str] = "mindroom_"
+
+    @classmethod
+    def parse(cls, matrix_id: str) -> MatrixID:
+        """Parse a Matrix ID like @mindroom_calculator:localhost."""
+        return _parse_matrix_id(matrix_id)
+
+    @classmethod
+    def from_agent(cls, agent_name: str, domain: str) -> MatrixID:
+        """Create a MatrixID for an agent."""
+        return cls(username=f"{cls.AGENT_PREFIX}{agent_name}", domain=domain)
+
+    @classmethod
+    def from_username(cls, username: str, domain: str) -> MatrixID:
+        """Create a MatrixID from a username (without @ prefix)."""
+        return cls(username=username, domain=domain)
+
+    @property
+    def full_id(self) -> str:
+        """Get the full Matrix ID like @mindroom_calculator:localhost."""
+        return f"@{self.username}:{self.domain}"
+
+    def agent_name(self, config: Config) -> str | None:
+        """Extract agent name if this is a configured agent ID."""
+        if not self.username.startswith(self.AGENT_PREFIX):
+            return None
+
+        # Remove prefix
+        name = self.username[len(self.AGENT_PREFIX) :]
+
+        # Special check for the router agent:
+        # The router is a built-in agent that handles command routing and doesn't
+        # appear in config.agents. Without this check, extract_agent_name() would
+        # return None for router messages, causing other agents to incorrectly
+        # respond to router's error messages (e.g., when schedule parsing fails).
+        if name == ROUTER_AGENT_NAME:
+            return name
+
+        # Validate against both regular agents and teams
+        if name in config.agents:
+            return name
+        if name in config.teams:
+            return name
+        return None
+
+    def __str__(self) -> str:
+        """Return the full Matrix ID string representation."""
+        return self.full_id
+
+
+@dataclass(frozen=True)
+class ThreadStateKey:
+    """Represents a thread state key like 'thread_id:agent_name'."""
+
+    thread_id: str
+    agent_name: str
+
+    @classmethod
+    def parse(cls, state_key: str) -> ThreadStateKey:
+        """Parse a state key."""
+        parts = state_key.split(":", 1)
+        if len(parts) != 2:
+            msg = f"Invalid state key: {state_key}"
+            raise ValueError(msg)
+        return cls(thread_id=parts[0], agent_name=parts[1])
+
+    @property
+    def key(self) -> str:
+        """Get the full state key."""
+        return f"{self.thread_id}:{self.agent_name}"
+
+    def __str__(self) -> str:
+        """Return the state key string representation."""
+        return self.key
+
+
+@lru_cache(maxsize=512)
+def _parse_matrix_id(matrix_id: str) -> MatrixID:
+    """Cached wrapper around MatrixID.parse for performance."""
+    if not matrix_id.startswith("@"):
+        msg = f"Invalid Matrix ID: {matrix_id}"
+        raise ValueError(msg)
+    if ":" not in matrix_id:
+        msg = f"Invalid Matrix ID, missing domain: {matrix_id}"
+        raise ValueError(msg)
+    parts = matrix_id[1:].split(":", 1)
+    if len(parts) != 2:
+        msg = f"Invalid Matrix ID format: {matrix_id}"
+        raise ValueError(msg)
+
+    return MatrixID(username=parts[0], domain=parts[1])
+
+
+def is_agent_id(matrix_id: str, config: Config) -> bool:
+    """Quick check if a Matrix ID is an agent."""
+    return extract_agent_name(matrix_id, config) is not None
+
+
+def extract_agent_name(sender_id: str, config: Config) -> str | None:
+    """Extract agent name from Matrix user ID like @mindroom_calculator:localhost.
+
+    Returns agent name (e.g., 'calculator') or None if not an agent.
+    """
+    if not sender_id.startswith("@") or ":" not in sender_id:
+        return None
+    mid = MatrixID.parse(sender_id)
+    return mid.agent_name(config)
+
+
+def extract_server_name_from_homeserver(homeserver: str) -> str:
+    """Extract server name from a homeserver URL like "http://localhost:8008".
+
+    If MATRIX_SERVER_NAME environment variable is set, use that instead.
+    This is needed for federation setups where the internal hostname differs
+    from the actual Matrix server name.
+    """
+    # Check for explicit server name override (for federation/docker setups)
+    if MATRIX_SERVER_NAME:
+        return MATRIX_SERVER_NAME
+
+    # Otherwise extract from homeserver URL
+    # Remove protocol
+    server_part = homeserver.split("://", 1)[1] if "://" in homeserver else homeserver
+
+    # Remove port if present
+    if ":" in server_part:
+        return server_part.split(":", 1)[0]
+    return server_part

mindroom/matrix/large_messages.py

@@ -0,0 +1,267 @@
+"""Handle large Matrix messages that exceed the 64KB event limit.
+
+This module provides minimal intervention for messages that are too large,
+uploading the full text as an MXC attachment while maximizing the preview size.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+from typing import Any
+
+import nio
+from nio import crypto
+
+from mindroom.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+# Conservative limits accounting for Matrix overhead
+NORMAL_MESSAGE_LIMIT = 55000  # ~55KB for regular messages
+EDIT_MESSAGE_LIMIT = 27000  # ~27KB for edits (they roughly double in size)
+
+
+def _calculate_event_size(content: dict[str, Any]) -> int:
+    """Calculate the approximate size of a Matrix event.
+
+    Args:
+        content: The message content dictionary
+
+    Returns:
+        Approximate size in bytes including JSON overhead
+
+    """
+    # Convert to canonical JSON (sorted keys, no spaces)
+    canonical = json.dumps(content, sort_keys=True, separators=(",", ":"))
+    # Add ~2KB overhead for event metadata, signatures, etc.
+    return len(canonical.encode("utf-8")) + 2000
+
+
+def _is_edit_message(content: dict[str, Any]) -> bool:
+    """Check if this is an edit message."""
+    return "m.new_content" in content or (
+        "m.relates_to" in content and content.get("m.relates_to", {}).get("rel_type") == "m.replace"
+    )
+
+
+def _create_preview(text: str, max_bytes: int) -> str:
+    """Create a preview that fits within byte limit.
+
+    Args:
+        text: The full text to preview
+        max_bytes: Maximum size in bytes for the preview
+
+    Returns:
+        Preview text that fits within the byte limit
+
+    """
+    # Reserve space for continuation indicator
+    indicator = "\n\n[Message continues in attached file]"
+    indicator_bytes = len(indicator.encode("utf-8"))
+
+    # If text fits entirely, return as-is
+    if len(text.encode("utf-8")) <= max_bytes:
+        return text
+
+    # Binary search for the maximum valid UTF-8 substring
+    # Account for the indicator from the start
+    target_bytes = max_bytes - indicator_bytes
+
+    # Start with a reasonable estimate
+    left, right = 0, min(len(text), target_bytes)
+    best_pos = 0
+
+    while left <= right:
+        mid = (left + right) // 2
+        try:
+            # Check if this position creates valid UTF-8
+            test_bytes = text[:mid].encode("utf-8")
+            if len(test_bytes) <= target_bytes:
+                best_pos = mid
+                left = mid + 1
+            else:
+                right = mid - 1
+        except UnicodeEncodeError:
+            # Shouldn't happen with valid input
+            right = mid - 1
+
+    return text[:best_pos] + indicator
+
+
+async def _upload_text_as_mxc(
+    client: nio.AsyncClient,
+    text: str,
+    room_id: str | None = None,
+) -> tuple[str | None, dict[str, Any] | None]:
+    """Upload text content as an MXC file.
+
+    Args:
+        client: The Matrix client
+        text: The text content to upload
+        room_id: Optional room ID to check for encryption
+
+    Returns:
+        Tuple of (mxc_uri, file_info_dict) or (None, None) on failure
+
+    """
+    text_bytes = text.encode("utf-8")
+    file_info = {
+        "size": len(text_bytes),
+        "mimetype": "text/plain",
+    }
+
+    # Check if room is encrypted
+    room_encrypted = False
+    if room_id and room_id in client.rooms:
+        room = client.rooms[room_id]
+        room_encrypted = room.encrypted
+
+    if room_encrypted:
+        # Encrypt the content for E2EE room
+        try:
+            encrypted_data = crypto.attachments.encrypt_attachment(text_bytes)
+            upload_data = encrypted_data["data"]
+
+            # Store encryption info for the file
+            file_info = {
+                "url": "",  # Will be set after upload
+                "key": encrypted_data["key"],
+                "iv": encrypted_data["iv"],
+                "hashes": encrypted_data["hashes"],
+                "v": "v2",
+                "mimetype": "text/plain",
+                "size": len(text_bytes),
+            }
+        except Exception:
+            logger.exception("Failed to encrypt attachment")
+            return None, None
+    else:
+        upload_data = text_bytes
+
+    # Upload the file
+    def data_provider(_monitor: object, _data: object) -> io.BytesIO:
+        return io.BytesIO(upload_data)
+
+    try:
+        # nio.upload returns Tuple[Union[UploadResponse, UploadError], Optional[Dict[str, Any]]]
+        upload_result, encryption_dict = await client.upload(
+            data_provider=data_provider,
+            content_type="application/octet-stream" if room_encrypted else "text/plain",
+            filename="message.txt.enc" if room_encrypted else "message.txt",
+            filesize=len(upload_data),
+        )
+
+        # Check if upload was successful
+        if not isinstance(upload_result, nio.UploadResponse):
+            logger.error(f"Failed to upload text: {upload_result}")
+            return None, None
+
+        if not upload_result.content_uri:
+            logger.error("Upload response missing content_uri")
+            return None, None
+
+        mxc_uri = str(upload_result.content_uri)
+        file_info["url"] = mxc_uri
+
+    except Exception:
+        logger.exception("Failed to upload text")
+        return None, None
+    else:
+        return mxc_uri, file_info
+
+
+async def prepare_large_message(
+    client: nio.AsyncClient,
+    room_id: str,
+    content: dict[str, Any],
+) -> dict[str, Any]:
+    """Check if message is too large and prepare it if needed.
+
+    This function:
+    1. Checks the message size
+    2. If too large, uploads the full text as MXC
+    3. Replaces body with maximum-size preview
+    4. Adds metadata for reconstruction
+
+    Args:
+        client: The Matrix client
+        room_id: The room to send to
+        content: The message content dictionary
+
+    Returns:
+        Original content (if small) or modified content with preview and MXC reference
+
+    """
+    # Edit messages roughly double in size due to m.new_content structure
+    # which includes both the edit wrapper and the actual new content
+    is_edit = _is_edit_message(content)
+    size_limit = EDIT_MESSAGE_LIMIT if is_edit else NORMAL_MESSAGE_LIMIT
+
+    # Calculate current size
+    current_size = _calculate_event_size(content)
+
+    # If it fits, return unchanged
+    if current_size <= size_limit:
+        return content
+
+    # Extract the text to upload (handle both regular and edit messages)
+    full_text = content["m.new_content"]["body"] if is_edit and "m.new_content" in content else content["body"]
+
+    logger.info(f"Message too large ({current_size} bytes), uploading to MXC")
+
+    # Upload the full text
+    mxc_uri, file_info = await _upload_text_as_mxc(client, full_text, room_id)
+
+    # Calculate how much space we have for preview
+    # We'll be sending an m.file message, so account for the file attachment structure
+    # The structure adds: filename, url, info object, custom metadata
+    attachment_overhead = 5000  # Conservative estimate for attachment JSON structure
+    available_for_preview = size_limit - attachment_overhead
+
+    # Create maximum-size preview
+    preview = _create_preview(full_text, available_for_preview)
+
+    # Create a standard m.file message with preview body
+    modified_content = {
+        "msgtype": "m.file",
+        "body": preview,  # Preview text for immediate readability
+        "filename": "message.txt",
+        "info": file_info,
+    }
+
+    # Add the file URL (either encrypted or plain)
+    if room_id and room_id in client.rooms and client.rooms[room_id].encrypted:
+        # For encrypted rooms, use 'file' key
+        modified_content["file"] = file_info
+    else:
+        # For unencrypted rooms, use 'url' key
+        modified_content["url"] = mxc_uri
+
+    # Add custom metadata to signal this is a long text message
+    # Future custom clients can use this to render as inline text instead of attachment
+    modified_content["io.mindroom.long_text"] = {
+        "version": 1,
+        "original_size": len(full_text),
+        "preview_size": len(preview),
+        "is_complete_text": True,
+    }
+
+    # Preserve thread/reply relationships if they exist
+    if "m.relates_to" in content:
+        modified_content["m.relates_to"] = content["m.relates_to"]
+
+    # Handle edit messages specially
+    if is_edit and "m.new_content" in content:
+        # For edits, we need to wrap everything in the edit structure
+        edit_content = {
+            "msgtype": "m.text",  # Edit message type
+            "body": f"* {preview}",
+            "m.new_content": modified_content,
+            "m.relates_to": content.get("m.relates_to", {}),
+        }
+        modified_content = edit_content
+
+    logger.info(f"Large message prepared: {len(full_text)} bytes -> {len(preview)} preview + MXC attachment")
+
+    return modified_content