wingman-ai 1.0.0__py3-none-any.whl

wingman/core/transports/imessage/transport.py

@@ -0,0 +1,140 @@
+"""iMessage transport implementation."""
+
+import asyncio
+import logging
+from pathlib import Path
+
+from ..base import BaseTransport, MessageEvent, Platform
+from .db_listener import IMessageData, IMessageDBListener
+from .sender import IMessageSender
+
+logger = logging.getLogger(__name__)
+
+
+class IMessageTransport(BaseTransport):
+    """
+    iMessage transport using chat.db polling and AppleScript sending.
+
+    Requirements:
+    - macOS only
+    - Full Disk Access permission for the Python process
+    - Messages.app configured with iMessage account
+    """
+
+    def __init__(
+        self,
+        db_path: Path | None = None,
+        poll_interval: float = 2.0,
+    ):
+        super().__init__()
+        self._listener = IMessageDBListener(
+            db_path=db_path,
+            poll_interval=poll_interval,
+        )
+        self._sender = IMessageSender()
+        self._listener_task: asyncio.Task | None = None
+
+    @property
+    def platform(self) -> Platform:
+        return Platform.IMESSAGE
+
+    async def start(self) -> None:
+        """Start the iMessage transport."""
+        logger.info("Starting iMessage transport...")
+        self._running = True
+
+        # Set up message callback
+        self._listener.set_message_callback(self._on_message)
+
+        # Start listener in background task
+        self._listener_task = asyncio.create_task(self._listener.start())
+
+        logger.info("iMessage transport started")
+
+    async def _on_message(self, msg: IMessageData) -> None:
+        """Handle incoming iMessage from the database listener."""
+        # Skip our own messages
+        if msg.is_from_me:
+            logger.debug(f"Skipping self message: {msg.text[:30]}...")
+            return
+
+        # Convert to MessageEvent
+        event = MessageEvent(
+            chat_id=msg.chat_id or f"imessage:{msg.handle_id}",
+            sender_id=f"imessage:{msg.handle_id}",
+            text=msg.text,
+            timestamp=msg.timestamp,
+            platform=Platform.IMESSAGE,
+            sender_name=msg.chat_name if msg.is_group else None,
+            is_group=msg.is_group,
+            is_self=msg.is_from_me,
+            raw_data={
+                "rowid": msg.rowid,
+                "handle_id": msg.handle_id,
+                "chat_id": msg.chat_id,
+                "chat_name": msg.chat_name,
+                "is_group": msg.is_group,
+            },
+        )
+
+        logger.info(
+            f"iMessage received: from={msg.handle_id}, "
+            f"group={msg.is_group}, text={msg.text[:50]}..."
+        )
+
+        await self._dispatch_message(event)
+
+    async def stop(self) -> None:
+        """Stop the iMessage transport."""
+        logger.info("Stopping iMessage transport...")
+        self._running = False
+
+        # Stop the listener
+        await self._listener.stop()
+
+        # Cancel listener task
+        if self._listener_task:
+            self._listener_task.cancel()
+            try:
+                await self._listener_task
+            except asyncio.CancelledError:
+                pass
+
+        logger.info("iMessage transport stopped")
+
+    async def send_message(self, chat_id: str, text: str) -> bool:
+        """Send an iMessage."""
+        # Parse chat_id to determine if group or individual
+        # Format: "imessage:+1234567890" or "chat123456789"
+
+        if chat_id.startswith("imessage:"):
+            # Direct message - extract phone/email
+            recipient = chat_id.replace("imessage:", "")
+            return await self._sender.send_message(
+                recipient=recipient,
+                text=text,
+                is_group=False,
+            )
+        else:
+            # Group chat - use chat_id directly
+            # Extract handle from raw_data if available
+            return await self._sender.send_message(
+                recipient=chat_id,
+                text=text,
+                is_group=True,
+                chat_id=chat_id,
+            )
+
+    async def check_availability(self) -> bool:
+        """Check if iMessage is available on this system."""
+        # Check if chat.db exists
+        if not self._listener._db_path.exists():
+            logger.warning("iMessage database not found")
+            return False
+
+        # Check if Messages.app is accessible
+        if not await self._sender.check_messages_app():
+            logger.warning("Messages.app not accessible")
+            return False
+
+        return True

wingman/core/transports/whatsapp.py

@@ -0,0 +1,180 @@
+"""WhatsApp transport implementation wrapping Node.js IPC."""
+
+import logging
+import time
+from collections.abc import Callable, Coroutine
+from pathlib import Path
+
+from ..ipc_handler import IPCHandler
+from ..process_manager import NodeProcessManager
+from .base import BaseTransport, MessageEvent, Platform
+
+logger = logging.getLogger(__name__)
+
+
+class WhatsAppTransport(BaseTransport):
+    """
+    WhatsApp transport using Baileys via Node.js subprocess.
+    Wraps the existing Node.js IPC communication.
+    """
+
+    def __init__(self, node_dir: Path, auth_state_dir: Path | None = None):
+        super().__init__()
+        self._node_manager = NodeProcessManager(node_dir, auth_state_dir)
+        self._ipc: IPCHandler | None = None
+        self._self_id: str | None = None
+
+        # Callbacks for WhatsApp-specific events
+        self._on_connected: Callable[[str], Coroutine] | None = None
+        self._on_disconnected: Callable[[], Coroutine] | None = None
+        self._on_qr_code: Callable[[], Coroutine] | None = None
+
+    @property
+    def platform(self) -> Platform:
+        return Platform.WHATSAPP
+
+    @property
+    def self_id(self) -> str | None:
+        """Get the connected WhatsApp user ID."""
+        return self._self_id
+
+    def set_connected_handler(self, handler: Callable[[str], Coroutine]) -> None:
+        """Set callback for when WhatsApp connects."""
+        self._on_connected = handler
+
+    def set_disconnected_handler(self, handler: Callable[[], Coroutine]) -> None:
+        """Set callback for when WhatsApp disconnects."""
+        self._on_disconnected = handler
+
+    def set_qr_code_handler(self, handler: Callable[[], Coroutine]) -> None:
+        """Set callback for QR code events."""
+        self._on_qr_code = handler
+
+    async def start(self) -> None:
+        """Start the WhatsApp transport."""
+        logger.info("Starting WhatsApp transport...")
+        self._running = True
+
+        # Start Node.js subprocess
+        self._ipc = await self._node_manager.start()
+
+        # Register IPC handlers
+        self._register_ipc_handlers()
+
+        logger.info("WhatsApp transport started")
+
+        # Run the IPC loop (blocks until stopped)
+        try:
+            await self._ipc.start()
+        except Exception as e:
+            logger.error(f"WhatsApp IPC loop error: {e}")
+            self._running = False
+            raise
+
+    def _register_ipc_handlers(self) -> None:
+        """Register handlers for Node.js IPC events."""
+        if not self._ipc:
+            return
+
+        async def on_message(data: dict) -> None:
+            """Handle incoming WhatsApp message."""
+            event = self._convert_to_event(data)
+            await self._dispatch_message(event)
+
+        async def on_connected(data: dict) -> None:
+            """Handle WhatsApp connection."""
+            user = data.get("user", {})
+            user_id = user.get("id", "")
+            self._self_id = user_id
+            logger.info(f"WhatsApp connected: {user_id}")
+            if self._on_connected:
+                await self._on_connected(user_id)
+
+        async def on_disconnected(data: dict) -> None:
+            """Handle WhatsApp disconnection."""
+            logger.warning(f"WhatsApp disconnected: {data}")
+            if self._on_disconnected:
+                await self._on_disconnected()
+
+        async def on_qr_code(data: dict) -> None:
+            """Handle QR code event."""
+            logger.info("QR code received - check terminal")
+            if self._on_qr_code:
+                await self._on_qr_code()
+
+        async def on_error(data: dict) -> None:
+            """Handle Node.js error."""
+            logger.error(f"WhatsApp error: {data.get('message', 'Unknown error')}")
+
+        async def on_logged_out(data: dict) -> None:
+            """Handle logout event."""
+            logger.error("Logged out from WhatsApp")
+            if self._on_disconnected:
+                await self._on_disconnected()
+
+        async def on_send_result(data: dict) -> None:
+            """Handle send result."""
+            success = data.get("success", False)
+            jid = data.get("jid", "")
+            if success:
+                logger.debug(f"Message sent to {jid}")
+            else:
+                logger.error(f"Failed to send message to {jid}")
+
+        async def on_starting(data: dict) -> None:
+            logger.info("Node.js starting...")
+
+        async def on_pong(data: dict) -> None:
+            logger.debug("Pong received")
+
+        # Register all handlers
+        self._ipc.register_handler("message", on_message)
+        self._ipc.register_handler("connected", on_connected)
+        self._ipc.register_handler("disconnected", on_disconnected)
+        self._ipc.register_handler("qr_code", on_qr_code)
+        self._ipc.register_handler("error", on_error)
+        self._ipc.register_handler("logged_out", on_logged_out)
+        self._ipc.register_handler("send_result", on_send_result)
+        self._ipc.register_handler("starting", on_starting)
+        self._ipc.register_handler("pong", on_pong)
+
+    def _convert_to_event(self, data: dict) -> MessageEvent:
+        """Convert IPC message data to MessageEvent."""
+        return MessageEvent(
+            chat_id=data.get("chatId", ""),
+            sender_id=data.get("senderId", ""),
+            text=data.get("text", ""),
+            timestamp=data.get("timestamp", time.time()),
+            platform=Platform.WHATSAPP,
+            sender_name=data.get("senderName"),
+            is_group=data.get("isGroup", False),
+            is_self=data.get("isSelf", False),
+            raw_data=data,
+            quoted_message=data.get("quotedMessage"),
+        )
+
+    async def stop(self) -> None:
+        """Stop the WhatsApp transport."""
+        logger.info("Stopping WhatsApp transport...")
+        self._running = False
+
+        if self._ipc:
+            self._ipc.stop()
+
+        await self._node_manager.stop()
+        self._ipc = None
+
+        logger.info("WhatsApp transport stopped")
+
+    async def send_message(self, chat_id: str, text: str) -> bool:
+        """Send a WhatsApp message."""
+        if not self._ipc:
+            logger.error("Cannot send message: IPC not connected")
+            return False
+
+        try:
+            await self._ipc.send_message(chat_id, text)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send WhatsApp message: {e}")
+            return False

wingman/daemon/__init__.py

@@ -0,0 +1,5 @@
+"""Daemon management module for Wingman."""
+
+from .manager import DaemonManager
+
+__all__ = ["DaemonManager"]

wingman/daemon/manager.py

@@ -0,0 +1,303 @@
+"""Daemon manager for Wingman."""
+
+import logging
+import os
+import signal
+import subprocess
+import sys
+import time
+
+from wingman.config.paths import WingmanPaths
+
+logger = logging.getLogger(__name__)
+
+
+class DaemonManager:
+    """
+    Manages Wingman as a background daemon.
+
+    On macOS, uses launchd for proper system integration.
+    Falls back to PID file management on other platforms.
+    """
+
+    LAUNCHD_LABEL = "com.wingman.agent"
+
+    def __init__(self, paths: WingmanPaths):
+        self.paths = paths
+        self._is_macos = sys.platform == "darwin"
+
+    def start(self) -> None:
+        """Start the daemon."""
+        if self._is_macos:
+            self._start_launchd()
+        else:
+            self._start_pidfile()
+
+    def stop(self) -> None:
+        """Stop the daemon."""
+        if self._is_macos:
+            self._stop_launchd()
+        else:
+            self._stop_pidfile()
+
+    def restart(self) -> None:
+        """Restart the daemon."""
+        self.stop()
+        time.sleep(1)
+        self.start()
+
+    def is_running(self) -> bool:
+        """Check if the daemon is running."""
+        if self._is_macos:
+            return self._is_launchd_running()
+        else:
+            return self._is_pidfile_running()
+
+    def get_pid(self) -> int | None:
+        """Get the PID of the running daemon."""
+        if self._is_macos:
+            return self._get_launchd_pid()
+        else:
+            return self._get_pidfile_pid()
+
+    def get_uptime(self) -> float | None:
+        """Get daemon uptime in seconds."""
+        pid = self.get_pid()
+        if pid is None:
+            return None
+
+        try:
+            # Use ps to get process start time
+            result = subprocess.run(
+                ["ps", "-o", "etime=", "-p", str(pid)], capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                etime = result.stdout.strip()
+                return self._parse_etime(etime)
+        except Exception:
+            pass
+
+        return None
+
+    def _parse_etime(self, etime: str) -> float:
+        """Parse ps etime format to seconds."""
+        # Format: [[DD-]HH:]MM:SS
+        parts = etime.replace("-", ":").split(":")
+        parts = [int(p) for p in parts]
+
+        if len(parts) == 2:
+            # MM:SS
+            return parts[0] * 60 + parts[1]
+        elif len(parts) == 3:
+            # HH:MM:SS
+            return parts[0] * 3600 + parts[1] * 60 + parts[2]
+        elif len(parts) == 4:
+            # DD:HH:MM:SS
+            return parts[0] * 86400 + parts[1] * 3600 + parts[2] * 60 + parts[3]
+
+        return 0
+
+    # ========== launchd implementation (macOS) ==========
+
+    def _get_plist_content(self) -> str:
+        """Generate launchd plist content."""
+        python_path = sys.executable
+        log_file = self.paths.log_dir / "agent.log"
+        error_file = self.paths.log_dir / "error.log"
+
+        return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>{self.LAUNCHD_LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>{python_path}</string>
+        <string>-m</string>
+        <string>wingman.core.agent</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <false/>
+
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>{log_file}</string>
+
+    <key>StandardErrorPath</key>
+    <string>{error_file}</string>
+
+    <key>WorkingDirectory</key>
+    <string>{self.paths.config_dir}</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+    </dict>
+</dict>
+</plist>
+"""
+
+    def _start_launchd(self) -> None:
+        """Start using launchd."""
+        plist_path = self.paths.launchd_plist
+
+        # Ensure log directory exists
+        self.paths.log_dir.mkdir(parents=True, exist_ok=True)
+
+        # Write plist file
+        plist_path.parent.mkdir(parents=True, exist_ok=True)
+        plist_path.write_text(self._get_plist_content())
+
+        # Load and start the agent
+        subprocess.run(["launchctl", "load", str(plist_path)], check=True)
+        subprocess.run(["launchctl", "start", self.LAUNCHD_LABEL], check=True)
+
+        logger.info(f"Daemon started via launchd: {self.LAUNCHD_LABEL}")
+
+    def _stop_launchd(self) -> None:
+        """Stop using launchd."""
+        plist_path = self.paths.launchd_plist
+
+        # Stop the agent
+        subprocess.run(["launchctl", "stop", self.LAUNCHD_LABEL], capture_output=True)
+
+        # Unload the plist
+        if plist_path.exists():
+            subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+
+        logger.info(f"Daemon stopped: {self.LAUNCHD_LABEL}")
+
+    def _is_launchd_running(self) -> bool:
+        """Check if launchd agent is running."""
+        result = subprocess.run(
+            ["launchctl", "list", self.LAUNCHD_LABEL], capture_output=True, text=True
+        )
+        return result.returncode == 0
+
+    def _get_launchd_pid(self) -> int | None:
+        """Get PID from launchd."""
+        result = subprocess.run(
+            ["launchctl", "list", self.LAUNCHD_LABEL], capture_output=True, text=True
+        )
+
+        if result.returncode != 0:
+            return None
+
+        # Parse output: PID\tStatus\tLabel
+        parts = result.stdout.strip().split("\t")
+        if len(parts) >= 1 and parts[0] != "-":
+            try:
+                return int(parts[0])
+            except ValueError:
+                pass
+
+        return None
+
+    # ========== PID file implementation (fallback) ==========
+
+    def _start_pidfile(self) -> None:
+        """Start using PID file (non-macOS fallback)."""
+        pid_file = self.paths.pid_file
+
+        # Check if already running
+        if self._is_pidfile_running():
+            raise RuntimeError("Daemon is already running")
+
+        # Fork and run in background
+        python_path = sys.executable
+
+        # Start as subprocess
+        process = subprocess.Popen(
+            [python_path, "-m", "wingman.core.agent"],
+            stdout=open(self.paths.log_dir / "agent.log", "a"),
+            stderr=open(self.paths.log_dir / "error.log", "a"),
+            cwd=str(self.paths.config_dir),
+            start_new_session=True,
+        )
+
+        # Write PID file
+        pid_file.parent.mkdir(parents=True, exist_ok=True)
+        pid_file.write_text(str(process.pid))
+
+        logger.info(f"Daemon started with PID: {process.pid}")
+
+    def _stop_pidfile(self) -> None:
+        """Stop using PID file."""
+        pid_file = self.paths.pid_file
+        pid = self._get_pidfile_pid()
+
+        if pid is None:
+            return
+
+        # Send SIGTERM
+        try:
+            os.kill(pid, signal.SIGTERM)
+
+            # Wait for process to exit
+            for _ in range(50):  # 5 seconds
+                time.sleep(0.1)
+                try:
+                    os.kill(pid, 0)  # Check if still running
+                except ProcessLookupError:
+                    break
+            else:
+                # Force kill if still running
+                os.kill(pid, signal.SIGKILL)
+
+        except ProcessLookupError:
+            pass  # Process already exited
+        except Exception as e:
+            logger.error(f"Error stopping daemon: {e}")
+
+        # Remove PID file
+        if pid_file.exists():
+            pid_file.unlink()
+
+        logger.info("Daemon stopped")
+
+    def _is_pidfile_running(self) -> bool:
+        """Check if daemon is running via PID file."""
+        pid = self._get_pidfile_pid()
+        if pid is None:
+            return False
+
+        try:
+            os.kill(pid, 0)  # Check if process exists
+            return True
+        except ProcessLookupError:
+            # Process doesn't exist, clean up stale PID file
+            self.paths.pid_file.unlink(missing_ok=True)
+            return False
+
+    def _get_pidfile_pid(self) -> int | None:
+        """Get PID from PID file."""
+        pid_file = self.paths.pid_file
+        if not pid_file.exists():
+            return None
+
+        try:
+            return int(pid_file.read_text().strip())
+        except (ValueError, FileNotFoundError):
+            return None
+
+    def uninstall(self) -> None:
+        """Fully uninstall the daemon."""
+        self.stop()
+
+        # Remove launchd plist
+        if self._is_macos and self.paths.launchd_plist.exists():
+            self.paths.launchd_plist.unlink()
+
+        # Remove PID file
+        self.paths.pid_file.unlink(missing_ok=True)
+
+        logger.info("Daemon uninstalled")

wingman/installer/__init__.py

@@ -0,0 +1,5 @@
+"""Installer module for Wingman."""
+
+from .node_installer import NodeInstaller
+
+__all__ = ["NodeInstaller"]