@agentunion/kite 1.0.6 → 1.2.0

package/extensions/services/web/vendor/bluetooth/manager.py

@@ -0,0 +1,395 @@
+"""Bluetooth device management via BlueZ 5 D-Bus interface.
+
+Provides auto-connect, device discovery, pairing, and status monitoring.
+Falls back to a mock implementation when D-Bus (dasbus) is not available
+(e.g. development on Windows / macOS).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Callable
+
+from .. import config as cfg
+
+logger = logging.getLogger("bluetooth.manager")
+
+# ---------------------------------------------------------------------------
+# Conditional D-Bus imports — mock when unavailable
+# ---------------------------------------------------------------------------
+
+_DBUS_AVAILABLE = False
+
+try:
+    from dasbus.connection import SystemMessageBus
+    from dasbus.identifier import DBusServiceIdentifier
+    from dasbus.loop import EventLoop
+    from dasbus.typing import get_variant, Str
+
+    _DBUS_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "dasbus not available — using mock BluetoothManager for development"
+    )
+
+# BlueZ D-Bus constants
+_BLUEZ_SERVICE = "org.bluez"
+_ADAPTER_IFACE = "org.bluez.Adapter1"
+_DEVICE_IFACE = "org.bluez.Device1"
+_BATTERY_IFACE = "org.bluez.Battery1"
+_OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
+_PROPERTIES_IFACE = "org.freedesktop.DBus.Properties"
+
+
+class BluetoothManager:
+    """Manage a Bluetooth connection to a phone via BlueZ 5 D-Bus."""
+
+    def __init__(self) -> None:
+        # Connection state
+        self._connected: bool = False
+        self._device_name: str = ""
+        self._device_address: str = ""
+        self._battery_level: int = -1
+        self._signal_strength: int = 0
+        self._operator_name: str = ""
+        self._in_call: bool = False
+
+        # Internal
+        self._bus: Any | None = None
+        self._adapter_proxy: Any | None = None
+        self._device_proxy: Any | None = None
+        self._auto_reconnect_task: asyncio.Task | None = None
+        self._running: bool = False
+
+        # Callbacks
+        self.on_connected: Callable[[], Any] | None = None
+        self.on_disconnected: Callable[[], Any] | None = None
+
+    # -- Properties ----------------------------------------------------------
+
+    @property
+    def connected(self) -> bool:
+        return self._connected
+
+    @property
+    def device_name(self) -> str:
+        return self._device_name
+
+    @property
+    def device_address(self) -> str:
+        return self._device_address
+
+    @property
+    def battery_level(self) -> int:
+        return self._battery_level
+
+    @property
+    def signal_strength(self) -> int:
+        return self._signal_strength
+
+    @property
+    def operator_name(self) -> str:
+        return self._operator_name
+
+    @property
+    def in_call(self) -> bool:
+        return self._in_call
+
+    @in_call.setter
+    def in_call(self, value: bool) -> None:
+        self._in_call = value
+
+    # -- Lifecycle -----------------------------------------------------------
+
+    async def start(self) -> None:
+        """Initialise D-Bus connection and start auto-connect if configured."""
+        self._running = True
+
+        if _DBUS_AVAILABLE:
+            try:
+                self._bus = SystemMessageBus()
+                self._adapter_proxy = self._bus.get_proxy(
+                    _BLUEZ_SERVICE, "/org/bluez/hci0"
+                )
+                logger.info("BlueZ adapter proxy acquired on /org/bluez/hci0")
+            except Exception as exc:
+                logger.error("Failed to connect to BlueZ D-Bus: %s", exc)
+                self._bus = None
+        else:
+            logger.info("D-Bus not available — running in mock mode")
+
+        # Auto-connect to a configured device
+        address = cfg.get("bluetooth.device_address", "")
+        if address and cfg.get("bluetooth.auto_connect", True):
+            self._device_address = address
+            self._auto_reconnect_task = asyncio.create_task(
+                self._auto_reconnect_loop()
+            )
+
+    async def stop(self) -> None:
+        """Disconnect and clean up resources."""
+        self._running = False
+        if self._auto_reconnect_task and not self._auto_reconnect_task.done():
+            self._auto_reconnect_task.cancel()
+            try:
+                await self._auto_reconnect_task
+            except asyncio.CancelledError:
+                pass
+        await self.disconnect()
+        logger.info("BluetoothManager stopped")
+
+    # -- Connection ----------------------------------------------------------
+
+    async def connect(self, address: str) -> bool:
+        """Connect to a Bluetooth device by MAC address.
+
+        Returns True on success, False otherwise.
+        """
+        self._device_address = address
+        logger.info("Connecting to %s ...", address)
+
+        if not _DBUS_AVAILABLE or self._bus is None:
+            return await self._mock_connect(address)
+
+        try:
+            device_path = self._address_to_path(address)
+            self._device_proxy = self._bus.get_proxy(_BLUEZ_SERVICE, device_path)
+            self._device_proxy.Connect()
+            await asyncio.sleep(1)  # allow D-Bus signals to settle
+
+            self._connected = True
+            self._device_name = self._safe_get_property(
+                self._device_proxy, "Name", address
+            )
+            self._read_battery()
+            logger.info(
+                "Connected to %s (%s)", self._device_name, address
+            )
+            if self.on_connected:
+                self.on_connected()
+            return True
+
+        except Exception as exc:
+            logger.error("Connection to %s failed: %s", address, exc)
+            self._connected = False
+            return False
+
+    async def disconnect(self) -> bool:
+        """Disconnect the currently connected device."""
+        if not self._connected:
+            return True
+
+        if not _DBUS_AVAILABLE or self._device_proxy is None:
+            return await self._mock_disconnect()
+
+        try:
+            self._device_proxy.Disconnect()
+            self._connected = False
+            self._device_name = ""
+            self._battery_level = -1
+            self._signal_strength = 0
+            self._operator_name = ""
+            logger.info("Disconnected from %s", self._device_address)
+            if self.on_disconnected:
+                self.on_disconnected()
+            return True
+        except Exception as exc:
+            logger.error("Disconnect failed: %s", exc)
+            return False
+
+    # -- Discovery -----------------------------------------------------------
+
+    async def scan_devices(self, duration: float = 8.0) -> list[dict[str, Any]]:
+        """Scan for nearby Bluetooth devices.
+
+        Returns a list of dicts with keys: address, name, paired, connected, rssi.
+        """
+        if not _DBUS_AVAILABLE or self._bus is None:
+            return self._mock_scan_devices()
+
+        try:
+            self._adapter_proxy.StartDiscovery()
+            logger.info("Discovery started, scanning for %.1fs ...", duration)
+            await asyncio.sleep(duration)
+            self._adapter_proxy.StopDiscovery()
+        except Exception as exc:
+            logger.error("Discovery error: %s", exc)
+            return []
+
+        return self._collect_discovered_devices()
+
+    def _collect_discovered_devices(self) -> list[dict[str, Any]]:
+        """Read discovered devices from BlueZ ObjectManager."""
+        devices: list[dict[str, Any]] = []
+        try:
+            obj_manager = self._bus.get_proxy(
+                _BLUEZ_SERVICE, "/"
+            )
+            managed = obj_manager.GetManagedObjects()
+            for path, ifaces in managed.items():
+                if _DEVICE_IFACE not in ifaces:
+                    continue
+                props = ifaces[_DEVICE_IFACE]
+                devices.append({
+                    "address": str(props.get("Address", "")),
+                    "name": str(props.get("Name", props.get("Alias", "Unknown"))),
+                    "paired": bool(props.get("Paired", False)),
+                    "connected": bool(props.get("Connected", False)),
+                    "rssi": int(props.get("RSSI", 0)),
+                })
+        except Exception as exc:
+            logger.error("Failed to collect devices: %s", exc)
+        return devices
+
+    # -- Pairing -------------------------------------------------------------
+
+    async def pair_device(self, address: str) -> bool:
+        """Pair with a device at the given address.
+
+        Returns True on success.
+        """
+        logger.info("Pairing with %s ...", address)
+
+        if not _DBUS_AVAILABLE or self._bus is None:
+            logger.info("[mock] Paired with %s", address)
+            return True
+
+        try:
+            device_path = self._address_to_path(address)
+            device = self._bus.get_proxy(_BLUEZ_SERVICE, device_path)
+            device.Pair()
+            device.Trusted = True
+            logger.info("Paired and trusted: %s", address)
+            return True
+        except Exception as exc:
+            logger.error("Pairing with %s failed: %s", address, exc)
+            return False
+
+    # -- Auto-reconnect ------------------------------------------------------
+
+    async def _auto_reconnect_loop(self) -> None:
+        """Background loop: reconnect with exponential backoff."""
+        base_interval = cfg.get("bluetooth.reconnect_interval", 5)
+        max_interval = cfg.get("bluetooth.reconnect_max_interval", 60)
+        interval = base_interval
+
+        while self._running:
+            if not self._connected and self._device_address:
+                logger.info(
+                    "Auto-reconnect attempt to %s (interval=%ds) ...",
+                    self._device_address, interval,
+                )
+                ok = await self.connect(self._device_address)
+                if ok:
+                    interval = base_interval  # reset backoff
+                else:
+                    interval = min(interval * 2, max_interval)
+
+            await asyncio.sleep(interval)
+
+    # -- Status --------------------------------------------------------------
+
+    def get_status(self) -> dict[str, Any]:
+        """Return a snapshot of all phone / bluetooth status fields."""
+        return {
+            "connected": self._connected,
+            "device_name": self._device_name,
+            "device_address": self._device_address,
+            "battery_level": self._battery_level,
+            "signal_strength": self._signal_strength,
+            "operator_name": self._operator_name,
+            "in_call": self._in_call,
+        }
+
+    # -- Internal helpers ----------------------------------------------------
+
+    @staticmethod
+    def _address_to_path(address: str) -> str:
+        """Convert a MAC address like ``AA:BB:CC:DD:EE:FF`` to a BlueZ object
+        path like ``/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF``.
+        """
+        return "/org/bluez/hci0/dev_" + address.replace(":", "_")
+
+    def _safe_get_property(self, proxy: Any, name: str, default: Any = "") -> Any:
+        """Read a D-Bus property, returning *default* on failure."""
+        try:
+            return getattr(proxy, name, default)
+        except Exception:
+            return default
+
+    def _read_battery(self) -> None:
+        """Try to read battery level from org.bluez.Battery1."""
+        if not _DBUS_AVAILABLE or self._bus is None or not self._device_address:
+            return
+        try:
+            device_path = self._address_to_path(self._device_address)
+            battery_proxy = self._bus.get_proxy(_BLUEZ_SERVICE, device_path)
+            self._battery_level = int(battery_proxy.Percentage)
+        except Exception:
+            self._battery_level = -1
+
+    # -- Delegated helpers (SMS / Contacts) ----------------------------------
+
+    async def send_sms(self, phone_number: str, content: str) -> bool:
+        """Send an SMS via the MAP client."""
+        from bluetooth.sms import MAPClient
+        client = MAPClient()
+        return await client.send_sms(phone_number, content)
+
+    async def sync_contacts(self) -> list[dict[str, Any]]:
+        """Sync contacts from the phone via PBAP."""
+        from bluetooth.contacts import PBAPClient
+        client = PBAPClient()
+        return await client.sync_contacts(self._device_address)
+
+    # -- Mock helpers (development on Windows / macOS) -----------------------
+
+    async def _mock_connect(self, address: str) -> bool:
+        logger.info("[mock] Connected to device %s", address)
+        self._connected = True
+        self._device_name = f"Mock Phone ({address[-5:]})"
+        self._battery_level = 85
+        self._signal_strength = -55
+        self._operator_name = "Mock Carrier"
+        if self.on_connected:
+            self.on_connected()
+        return True
+
+    async def _mock_disconnect(self) -> bool:
+        logger.info("[mock] Disconnected")
+        self._connected = False
+        self._device_name = ""
+        self._battery_level = -1
+        self._signal_strength = 0
+        self._operator_name = ""
+        if self.on_disconnected:
+            self.on_disconnected()
+        return True
+
+    @staticmethod
+    def _mock_scan_devices() -> list[dict[str, Any]]:
+        logger.info("[mock] Returning fake discovered devices")
+        return [
+            {
+                "address": "AA:BB:CC:DD:EE:01",
+                "name": "Mock iPhone 15",
+                "paired": False,
+                "connected": False,
+                "rssi": -45,
+            },
+            {
+                "address": "AA:BB:CC:DD:EE:02",
+                "name": "Mock Pixel 8",
+                "paired": True,
+                "connected": False,
+                "rssi": -62,
+            },
+            {
+                "address": "AA:BB:CC:DD:EE:03",
+                "name": "Mock Galaxy S24",
+                "paired": False,
+                "connected": False,
+                "rssi": -78,
+            },
+        ]

package/extensions/services/web/vendor/bluetooth/sms.py

@@ -0,0 +1,290 @@
+"""Message Access Profile (MAP) client via BlueZ / obexd D-Bus.
+
+Provides SMS send / receive / listing through a connected Bluetooth phone.
+Falls back to a mock implementation when D-Bus is not available.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import datetime, timezone
+from typing import Any
+
+logger = logging.getLogger("bluetooth.sms")
+
+# ---------------------------------------------------------------------------
+# Conditional D-Bus imports
+# ---------------------------------------------------------------------------
+
+_DBUS_AVAILABLE = False
+
+try:
+    from dasbus.connection import SessionMessageBus
+
+    _DBUS_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "dasbus not available — using mock MAPClient for development"
+    )
+
+# obexd MAP D-Bus constants
+_OBEX_SERVICE = "org.bluez.obex"
+_OBEX_CLIENT_PATH = "/org/bluez/obex"
+_OBEX_CLIENT_IFACE = "org.bluez.obex.Client1"
+_OBEX_MAP_IFACE = "org.bluez.obex.MessageAccess1"
+_OBEX_MESSAGE_IFACE = "org.bluez.obex.Message1"
+_OBEX_TRANSFER_IFACE = "org.bluez.obex.Transfer1"
+
+# MAP folder names
+_FOLDER_INBOX = "inbox"
+_FOLDER_SENT = "sent"
+_FOLDER_OUTBOX = "outbox"
+
+
+class MAPClient:
+    """Send and receive SMS through Bluetooth MAP profile."""
+
+    def __init__(self) -> None:
+        self._bus: Any | None = None
+        self._session_path: str | None = None
+
+    # -- Public API ----------------------------------------------------------
+
+    async def send_sms(self, number: str, text: str) -> bool:
+        """Send an SMS to *number* with body *text*.
+
+        Returns True on success, False otherwise.
+        """
+        logger.info("Sending SMS to %s (%d chars)", number, len(text))
+
+        if not _DBUS_AVAILABLE:
+            return self._mock_send_sms(number, text)
+
+        return await self._map_send_message(number, text)
+
+    async def get_messages(
+        self, folder: str = _FOLDER_INBOX
+    ) -> list[dict[str, Any]]:
+        """Retrieve messages from the specified folder.
+
+        Each message is a dict with keys: id, sender, recipient, text,
+        timestamp, read, folder.
+        """
+        logger.info("Fetching messages from folder '%s'", folder)
+
+        if not _DBUS_AVAILABLE:
+            return self._mock_get_messages(folder)
+
+        return await self._map_get_messages(folder)
+
+    async def get_unread_count(self) -> int:
+        """Return the number of unread messages in the inbox."""
+        messages = await self.get_messages(_FOLDER_INBOX)
+        return sum(1 for m in messages if not m.get("read", True))
+
+    # -- obexd MAP D-Bus interaction -----------------------------------------
+
+    async def _map_create_session(self, device_address: str = "") -> bool:
+        """Create a MAP session with the phone via obexd."""
+        try:
+            if self._bus is None:
+                self._bus = SessionMessageBus()
+
+            client = self._bus.get_proxy(_OBEX_SERVICE, _OBEX_CLIENT_PATH)
+            session_path = client.CreateSession(
+                device_address,
+                {"Target": "MAP"},
+            )
+            self._session_path = str(session_path)
+            logger.info("MAP session created: %s", self._session_path)
+            return True
+        except Exception as exc:
+            logger.error("Failed to create MAP session: %s", exc)
+            return False
+
+    async def _map_close_session(self) -> None:
+        """Close the current MAP session."""
+        if self._session_path is None:
+            return
+        try:
+            client = self._bus.get_proxy(_OBEX_SERVICE, _OBEX_CLIENT_PATH)
+            client.RemoveSession(self._session_path)
+        except Exception:
+            pass
+        self._session_path = None
+
+    async def _map_send_message(self, number: str, text: str) -> bool:
+        """Send a message via the MAP profile."""
+        try:
+            if self._session_path is None:
+                if not await self._map_create_session():
+                    return False
+
+            map_proxy = self._bus.get_proxy(
+                _OBEX_SERVICE, self._session_path
+            )
+
+            # Navigate to outbox
+            map_proxy.SetFolder("telecom/msg/outbox")
+
+            # Push message
+            # The MAP PushMessage method takes a filename with the message
+            # content and a destination folder.  We build a basic bMessage.
+            bmsg = self._build_bmessage(number, text)
+
+            transfer_path, properties = map_proxy.PushMessage(
+                bmsg,
+                "outbox",
+                {"Transparent": False},
+            )
+
+            # Wait for transfer to complete
+            transfer = self._bus.get_proxy(
+                _OBEX_SERVICE, str(transfer_path)
+            )
+            for _ in range(30):
+                status = str(transfer.Status)
+                if status == "complete":
+                    logger.info("SMS sent to %s", number)
+                    return True
+                if status == "error":
+                    logger.error("SMS send transfer failed")
+                    return False
+                await asyncio.sleep(0.5)
+
+            logger.error("SMS send transfer timed out")
+            return False
+
+        except Exception as exc:
+            logger.error("MAP send failed: %s", exc)
+            return False
+
+        finally:
+            await self._map_close_session()
+
+    async def _map_get_messages(
+        self, folder: str
+    ) -> list[dict[str, Any]]:
+        """Retrieve messages from a MAP folder."""
+        messages: list[dict[str, Any]] = []
+
+        try:
+            if self._session_path is None:
+                if not await self._map_create_session():
+                    return messages
+
+            map_proxy = self._bus.get_proxy(
+                _OBEX_SERVICE, self._session_path
+            )
+
+            # Navigate to the requested folder
+            map_proxy.SetFolder(f"telecom/msg/{folder}")
+
+            # Get message listing
+            listing = map_proxy.ListMessages(
+                folder,
+                {"MaxListCount": 50},
+            )
+
+            for msg_path, props in listing.items():
+                messages.append({
+                    "id": str(msg_path).split("/")[-1],
+                    "sender": str(props.get("Sender", "")),
+                    "recipient": str(props.get("Recipient", "")),
+                    "text": str(props.get("Subject", "")),
+                    "timestamp": str(props.get("Timestamp", "")),
+                    "read": bool(props.get("Read", False)),
+                    "folder": folder,
+                })
+
+        except Exception as exc:
+            logger.error("MAP get messages failed: %s", exc)
+
+        finally:
+            await self._map_close_session()
+
+        return messages
+
+    # -- bMessage construction -----------------------------------------------
+
+    @staticmethod
+    def _build_bmessage(number: str, text: str) -> str:
+        """Build a minimal bMessage 1.0 envelope for an SMS."""
+        return (
+            "BEGIN:BMSG\r\n"
+            "VERSION:1.0\r\n"
+            "STATUS:UNREAD\r\n"
+            "TYPE:SMS_GSM\r\n"
+            "FOLDER:telecom/msg/outbox\r\n"
+            "BEGIN:VCARD\r\n"
+            f"TEL:{number}\r\n"
+            "END:VCARD\r\n"
+            "BEGIN:BENV\r\n"
+            "BEGIN:BBODY\r\n"
+            "CHARSET:UTF-8\r\n"
+            f"LENGTH:{len(text.encode('utf-8'))}\r\n"
+            "BEGIN:MSG\r\n"
+            f"{text}\r\n"
+            "END:MSG\r\n"
+            "END:BBODY\r\n"
+            "END:BENV\r\n"
+            "END:BMSG\r\n"
+        )
+
+    # -- Mock helpers (development) ------------------------------------------
+
+    @staticmethod
+    def _mock_send_sms(number: str, text: str) -> bool:
+        logger.info("[mock] SMS sent to %s: %s", number, text[:50])
+        return True
+
+    @staticmethod
+    def _mock_get_messages(folder: str) -> list[dict[str, Any]]:
+        logger.info("[mock] Returning fake messages for folder '%s'", folder)
+
+        now = datetime.now(timezone.utc).isoformat()
+
+        if folder == _FOLDER_INBOX:
+            return [
+                {
+                    "id": "mock-msg-001",
+                    "sender": "+8613800000001",
+                    "recipient": "",
+                    "text": "Hello, are you available for a meeting tomorrow?",
+                    "timestamp": now,
+                    "read": False,
+                    "folder": folder,
+                },
+                {
+                    "id": "mock-msg-002",
+                    "sender": "+8613900000002",
+                    "recipient": "",
+                    "text": "Your package has been delivered.",
+                    "timestamp": now,
+                    "read": True,
+                    "folder": folder,
+                },
+                {
+                    "id": "mock-msg-003",
+                    "sender": "+8613700000003",
+                    "recipient": "",
+                    "text": "Reminder: appointment at 3pm today.",
+                    "timestamp": now,
+                    "read": False,
+                    "folder": folder,
+                },
+            ]
+        elif folder == _FOLDER_SENT:
+            return [
+                {
+                    "id": "mock-msg-101",
+                    "sender": "",
+                    "recipient": "+8613800000001",
+                    "text": "Sure, let me check my schedule.",
+                    "timestamp": now,
+                    "read": True,
+                    "folder": folder,
+                },
+            ]
+        return []