wingman-ai 1.0.0__py3-none-any.whl

wingman/core/safety/triggers.py

@@ -0,0 +1,117 @@
+"""Trigger word and mention detection."""
+
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class TriggerDetector:
+    """
+    Detects trigger words, mentions, and other conditions that should
+    cause the bot to respond.
+    """
+
+    def __init__(self, bot_name: str = "Maximus", additional_triggers: list[str] | None = None):
+        self.bot_name = bot_name.lower()
+        self.triggers: set[str] = {self.bot_name}
+
+        # Add common variations
+        self.triggers.add(f"@{self.bot_name}")
+
+        # Add additional triggers
+        if additional_triggers:
+            for trigger in additional_triggers:
+                self.triggers.add(trigger.lower())
+
+        # Compile regex patterns for efficient matching
+        self._compile_patterns()
+
+    def _compile_patterns(self) -> None:
+        """Compile regex patterns for trigger matching."""
+        # Pattern for @mentions (handles WhatsApp mention format)
+        escaped_triggers = [re.escape(t) for t in self.triggers]
+        pattern = r"\b(" + "|".join(escaped_triggers) + r")\b"
+        self._trigger_pattern = re.compile(pattern, re.IGNORECASE)
+
+    def add_trigger(self, trigger: str) -> None:
+        """Add a new trigger word."""
+        self.triggers.add(trigger.lower())
+        self._compile_patterns()
+        logger.debug(f"Added trigger: {trigger}")
+
+    def remove_trigger(self, trigger: str) -> None:
+        """Remove a trigger word."""
+        self.triggers.discard(trigger.lower())
+        self._compile_patterns()
+        logger.debug(f"Removed trigger: {trigger}")
+
+    def has_trigger(self, text: str) -> bool:
+        """
+        Check if the text contains any trigger words.
+
+        Args:
+            text: Message text to check
+
+        Returns:
+            True if a trigger is found
+        """
+        if not text:
+            return False
+
+        match = self._trigger_pattern.search(text)
+        if match:
+            logger.debug(f"Trigger found: '{match.group()}'")
+            return True
+        return False
+
+    def is_direct_mention(self, text: str) -> bool:
+        """
+        Check if the message starts with a mention of the bot.
+        This indicates a direct address.
+        """
+        if not text:
+            return False
+
+        text_lower = text.lower().strip()
+
+        for trigger in self.triggers:
+            if text_lower.startswith(trigger):
+                return True
+            # Check for @mention at start
+            if text_lower.startswith(f"@{trigger}"):
+                return True
+
+        return False
+
+    def should_respond(
+        self, text: str, is_group: bool, is_dm: bool = False, is_reply_to_bot: bool = False
+    ) -> tuple[bool, str]:
+        """
+        Determine if the bot should respond to this message.
+
+        Args:
+            text: Message text
+            is_group: Whether this is a group chat
+            is_dm: Whether this is a direct message
+            is_reply_to_bot: Whether this is a reply to the bot's message
+
+        Returns:
+            Tuple of (should_respond, reason)
+        """
+        # Always respond to DMs
+        if is_dm:
+            return True, "direct_message"
+
+        # Always respond if replying to bot's message
+        if is_reply_to_bot:
+            return True, "reply_to_bot"
+
+        # In groups, only respond to triggers
+        if is_group:
+            if self.has_trigger(text):
+                return True, "trigger_word"
+            return False, "no_trigger"
+
+        # Default: don't respond
+        return False, "no_match"

wingman/core/transports/__init__.py

@@ -0,0 +1,14 @@
+"""Transport abstraction layer for multi-platform messaging."""
+
+from .base import BaseTransport, MessageEvent, MessageHandler, Platform
+from .imessage import IMessageTransport
+from .whatsapp import WhatsAppTransport
+
+__all__ = [
+    "Platform",
+    "MessageEvent",
+    "BaseTransport",
+    "MessageHandler",
+    "WhatsAppTransport",
+    "IMessageTransport",
+]

wingman/core/transports/base.py

@@ -0,0 +1,106 @@
+"""Base transport abstraction for multi-platform messaging."""
+
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class Platform(Enum):
+    """Supported messaging platforms."""
+
+    WHATSAPP = "whatsapp"
+    IMESSAGE = "imessage"
+
+
+@dataclass
+class MessageEvent:
+    """Unified message structure across all platforms."""
+
+    # Core message data
+    chat_id: str
+    sender_id: str
+    text: str
+    timestamp: float
+
+    # Platform info
+    platform: Platform
+
+    # Sender info
+    sender_name: str | None = None
+
+    # Message type flags
+    is_group: bool = False
+    is_self: bool = False
+
+    # Platform-specific data
+    raw_data: dict = field(default_factory=dict)
+
+    # Reply context (if replying to a message)
+    quoted_message: dict | None = None
+
+
+# Type alias for message handler callback
+MessageHandler = Callable[[MessageEvent], Coroutine[Any, Any, None]]
+
+
+class BaseTransport(ABC):
+    """Abstract base class for message transports."""
+
+    def __init__(self):
+        self._message_handler: MessageHandler | None = None
+        self._running = False
+
+    @property
+    @abstractmethod
+    def platform(self) -> Platform:
+        """Return the platform this transport handles."""
+        pass
+
+    def set_message_handler(self, handler: MessageHandler) -> None:
+        """Set the callback for incoming messages."""
+        self._message_handler = handler
+        logger.debug(f"{self.platform.value}: Message handler registered")
+
+    async def _dispatch_message(self, event: MessageEvent) -> None:
+        """Dispatch a message event to the registered handler."""
+        if self._message_handler:
+            try:
+                await self._message_handler(event)
+            except Exception as e:
+                logger.error(f"{self.platform.value}: Error in message handler: {e}")
+        else:
+            logger.warning(f"{self.platform.value}: No message handler registered")
+
+    @abstractmethod
+    async def start(self) -> None:
+        """Start the transport and begin listening for messages."""
+        pass
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop the transport gracefully."""
+        pass
+
+    @abstractmethod
+    async def send_message(self, chat_id: str, text: str) -> bool:
+        """
+        Send a message to the specified chat.
+
+        Args:
+            chat_id: The chat/conversation identifier
+            text: The message text to send
+
+        Returns:
+            True if send was successful, False otherwise
+        """
+        pass
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the transport is currently running."""
+        return self._running

wingman/core/transports/imessage/__init__.py

@@ -0,0 +1,5 @@
+"""iMessage transport implementation."""
+
+from .transport import IMessageTransport
+
+__all__ = ["IMessageTransport"]

wingman/core/transports/imessage/db_listener.py

@@ -0,0 +1,280 @@
+"""iMessage database listener for detecting new messages."""
+
+import asyncio
+import logging
+import sqlite3
+import time
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Apple epoch: seconds between Unix epoch (1970) and Apple epoch (2001)
+APPLE_EPOCH_OFFSET = 978307200
+
+
+@dataclass
+class IMessageData:
+    """Raw iMessage data from chat.db."""
+
+    rowid: int
+    text: str
+    handle_id: str  # Phone number or email
+    chat_id: str  # Chat identifier
+    chat_name: str | None  # Group name if available
+    timestamp: float  # Unix timestamp
+    is_from_me: bool
+    is_group: bool
+
+
+class IMessageDBListener:
+    """
+    Polls the iMessage chat.db database for new messages.
+
+    Note: Requires Full Disk Access permission for the Python process.
+    """
+
+    # Default chat.db location
+    DEFAULT_DB_PATH = Path.home() / "Library" / "Messages" / "chat.db"
+
+    def __init__(
+        self,
+        db_path: Path | None = None,
+        poll_interval: float = 2.0,
+    ):
+        self._db_path = db_path or self.DEFAULT_DB_PATH
+        self._poll_interval = poll_interval
+        self._last_rowid = 0
+        self._running = False
+        self._message_callback: Callable[[IMessageData], Coroutine] | None = None
+
+    def set_message_callback(self, callback: Callable[[IMessageData], Coroutine]) -> None:
+        """Set the callback for new messages."""
+        self._message_callback = callback
+
+    async def start(self) -> None:
+        """Start polling for new messages."""
+        if not self._db_path.exists():
+            raise FileNotFoundError(
+                f"iMessage database not found: {self._db_path}\n"
+                "Ensure Messages.app has been used and Full Disk Access is granted."
+            )
+
+        # Get the current max ROWID to start from
+        self._last_rowid = self._get_max_rowid()
+        logger.info(f"iMessage listener starting from ROWID {self._last_rowid}")
+
+        self._running = True
+        await self._poll_loop()
+
+    async def stop(self) -> None:
+        """Stop polling."""
+        self._running = False
+        logger.info("iMessage listener stopped")
+
+    async def _poll_loop(self) -> None:
+        """Main polling loop."""
+        while self._running:
+            try:
+                messages = self._fetch_new_messages()
+                for msg in messages:
+                    if self._message_callback:
+                        await self._message_callback(msg)
+                    self._last_rowid = max(self._last_rowid, msg.rowid)
+            except sqlite3.OperationalError as e:
+                if "database is locked" in str(e):
+                    logger.debug("Database locked, will retry")
+                else:
+                    logger.error(f"Database error: {e}")
+            except Exception as e:
+                logger.error(f"Error polling iMessage database: {e}")
+
+            await asyncio.sleep(self._poll_interval)
+
+    def _get_connection(self) -> sqlite3.Connection:
+        """Get a read-only connection to chat.db."""
+        # Use URI for read-only access
+        conn = sqlite3.connect(f"file:{self._db_path}?mode=ro", uri=True, timeout=5.0)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _get_max_rowid(self) -> int:
+        """Get the current maximum ROWID in the messages table."""
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.execute("SELECT MAX(ROWID) FROM message")
+                result = cursor.fetchone()
+                return result[0] or 0
+        except Exception as e:
+            logger.error(f"Failed to get max ROWID: {e}")
+            return 0
+
+    def _fetch_new_messages(self) -> list[IMessageData]:
+        """Fetch messages newer than last_rowid."""
+        messages = []
+
+        query = """
+            SELECT
+                m.ROWID,
+                m.text,
+                m.attributedBody,
+                m.handle_id,
+                m.date,
+                m.is_from_me,
+                h.id as handle_identifier,
+                c.chat_identifier,
+                c.display_name as chat_name,
+                c.style as chat_style
+            FROM message m
+            LEFT JOIN handle h ON m.handle_id = h.ROWID
+            LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
+            LEFT JOIN chat c ON cmj.chat_id = c.ROWID
+            WHERE m.ROWID > ?
+            ORDER BY m.ROWID ASC
+            LIMIT 50
+        """
+
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.execute(query, (self._last_rowid,))
+                rows = cursor.fetchall()
+
+                for row in rows:
+                    # Extract text (handle Ventura+ attributedBody)
+                    text = self._extract_text(row)
+                    if not text:
+                        continue  # Skip messages without text
+
+                    # Convert Apple timestamp to Unix
+                    apple_date = row["date"]
+                    if apple_date:
+                        # Apple stores nanoseconds since 2001-01-01
+                        unix_timestamp = (apple_date / 1e9) + APPLE_EPOCH_OFFSET
+                    else:
+                        unix_timestamp = time.time()
+
+                    # Determine if group chat (style > 0 means group)
+                    is_group = (row["chat_style"] or 0) > 43
+
+                    msg = IMessageData(
+                        rowid=row["ROWID"],
+                        text=text,
+                        handle_id=row["handle_identifier"] or "",
+                        chat_id=row["chat_identifier"] or "",
+                        chat_name=row["chat_name"],
+                        timestamp=unix_timestamp,
+                        is_from_me=bool(row["is_from_me"]),
+                        is_group=is_group,
+                    )
+                    messages.append(msg)
+
+        except Exception as e:
+            logger.error(f"Failed to fetch new messages: {e}")
+
+        return messages
+
+    def _extract_text(self, row: sqlite3.Row) -> str | None:
+        """
+        Extract message text from a database row.
+
+        Handles both:
+        - Plain text in 'text' column (older macOS)
+        - attributedBody blob (Ventura+)
+        """
+        # Try plain text first
+        text = row["text"]
+        if text:
+            return text.strip()
+
+        # Try attributedBody (Ventura+ stores text as NSAttributedString blob)
+        attributed_body = row["attributedBody"]
+        if attributed_body:
+            try:
+                return self._parse_attributed_body(attributed_body)
+            except Exception as e:
+                logger.debug(f"Failed to parse attributedBody: {e}")
+
+        return None
+
+    def _parse_attributed_body(self, blob: bytes) -> str | None:
+        """
+        Parse NSAttributedString blob from attributedBody column.
+
+        The blob contains a serialized NSAttributedString. The actual text
+        is stored after a specific marker pattern.
+        """
+        try:
+            # Look for the text content within the blob
+            # The structure varies but text is typically after 'NSString' marker
+            decoded = blob.decode("utf-8", errors="ignore")
+
+            # Find the actual message text
+            # Look for pattern: text follows certain markers
+            markers = [
+                "NSString",
+                "NSMutableString",
+            ]
+
+            for marker in markers:
+                if marker in decoded:
+                    # Text typically follows the marker with some length info
+                    idx = decoded.find(marker)
+                    # Skip past marker and find readable text
+                    remaining = decoded[idx + len(marker) :]
+                    # Extract printable characters
+                    text = "".join(c for c in remaining if c.isprintable() or c.isspace())
+                    text = text.strip()
+                    if text and len(text) > 1:
+                        # Clean up any trailing garbage
+                        # Text usually ends at first control sequence
+                        for end_marker in ["\x00", "\x01", "\x02"]:
+                            if end_marker in text:
+                                text = text.split(end_marker)[0]
+                        return text.strip() if text.strip() else None
+
+            # Alternative: try to find text between known delimiters
+            # streamtyped data format
+            if b"streamtyped" in blob:
+                # Find text after the plist-like structure
+                try:
+                    # Look for readable text sequences
+                    text_parts = []
+                    current = []
+                    for byte in blob:
+                        if 32 <= byte <= 126:  # Printable ASCII
+                            current.append(chr(byte))
+                        else:
+                            if len(current) > 3:  # Minimum word length
+                                text_parts.append("".join(current))
+                            current = []
+                    if current and len(current) > 3:
+                        text_parts.append("".join(current))
+
+                    # Filter out known non-text strings
+                    filtered = [
+                        p
+                        for p in text_parts
+                        if p
+                        not in [
+                            "streamtyped",
+                            "NSMutableAttributedString",
+                            "NSAttributedString",
+                            "NSString",
+                            "NSDictionary",
+                        ]
+                    ]
+                    if filtered:
+                        return " ".join(filtered)
+                except Exception:
+                    pass
+
+        except Exception as e:
+            logger.debug(f"Error parsing attributed body: {e}")
+
+        return None
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the listener is running."""
+        return self._running

wingman/core/transports/imessage/sender.py

@@ -0,0 +1,162 @@
+"""iMessage sender using AppleScript."""
+
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class IMessageSender:
+    """
+    Sends iMessages using AppleScript via osascript.
+
+    Supports both direct messages and group chats.
+    """
+
+    def __init__(self):
+        self._last_send_time = 0.0
+
+    async def send_message(
+        self,
+        recipient: str,
+        text: str,
+        is_group: bool = False,
+        chat_id: str | None = None,
+    ) -> bool:
+        """
+        Send an iMessage.
+
+        Args:
+            recipient: Phone number, email, or chat identifier
+            text: Message text to send
+            is_group: Whether this is a group chat
+            chat_id: Chat identifier for group messages
+
+        Returns:
+            True if send was successful
+        """
+        try:
+            if is_group and chat_id:
+                return await self._send_to_group(chat_id, text)
+            else:
+                return await self._send_to_individual(recipient, text)
+        except Exception as e:
+            logger.error(f"Failed to send iMessage: {e}")
+            return False
+
+    async def _send_to_individual(self, recipient: str, text: str) -> bool:
+        """Send a direct message to an individual."""
+        # Escape special characters for AppleScript
+        escaped_text = self._escape_for_applescript(text)
+        escaped_recipient = self._escape_for_applescript(recipient)
+
+        script = f"""
+            tell application "Messages"
+                set targetService to 1st account whose service type = iMessage
+                set targetBuddy to participant "{escaped_recipient}" of targetService
+                send "{escaped_text}" to targetBuddy
+            end tell
+        """
+
+        return await self._run_applescript(script)
+
+    async def _send_to_group(self, chat_id: str, text: str) -> bool:
+        """Send a message to a group chat."""
+        escaped_text = self._escape_for_applescript(text)
+        escaped_chat_id = self._escape_for_applescript(chat_id)
+
+        # Try to find the chat by its identifier
+        script = f"""
+            tell application "Messages"
+                set targetChat to a reference to chat id "{escaped_chat_id}"
+                send "{escaped_text}" to targetChat
+            end tell
+        """
+
+        success = await self._run_applescript(script)
+
+        if not success:
+            # Fallback: try finding by chat name
+            logger.debug("Retrying with chat name lookup")
+            script_fallback = f"""
+                tell application "Messages"
+                    set allChats to every chat
+                    repeat with aChat in allChats
+                        if id of aChat contains "{escaped_chat_id}" then
+                            send "{escaped_text}" to aChat
+                            return
+                        end if
+                    end repeat
+                end tell
+            """
+            success = await self._run_applescript(script_fallback)
+
+        return success
+
+    async def _run_applescript(self, script: str) -> bool:
+        """Execute an AppleScript and return success status."""
+        try:
+            # Run osascript in a subprocess
+            process = await asyncio.create_subprocess_exec(
+                "osascript",
+                "-e",
+                script,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=10.0)
+
+            if process.returncode == 0:
+                logger.debug("AppleScript executed successfully")
+                return True
+            else:
+                error_msg = stderr.decode("utf-8").strip()
+                logger.error(f"AppleScript error: {error_msg}")
+                return False
+
+        except asyncio.TimeoutError:
+            logger.error("AppleScript timed out")
+            return False
+        except Exception as e:
+            logger.error(f"Failed to execute AppleScript: {e}")
+            return False
+
+    def _escape_for_applescript(self, text: str) -> str:
+        """
+        Escape special characters for use in AppleScript strings.
+
+        AppleScript uses backslash for escaping within double-quoted strings.
+        """
+        # Escape backslashes first, then quotes
+        text = text.replace("\\", "\\\\")
+        text = text.replace('"', '\\"')
+        text = text.replace("\n", "\\n")
+        text = text.replace("\r", "\\r")
+        text = text.replace("\t", "\\t")
+        return text
+
+    async def check_messages_app(self) -> bool:
+        """Check if Messages.app is available and accessible."""
+        script = """
+            tell application "System Events"
+                return exists application process "Messages"
+            end tell
+        """
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                "osascript",
+                "-e",
+                script,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, _ = await process.communicate()
+            result = stdout.decode("utf-8").strip().lower()
+            return result == "true"
+
+        except Exception as e:
+            logger.error(f"Failed to check Messages.app: {e}")
+            return False