@agentunion/kite 1.0.6 → 1.2.0

package/extensions/services/web/vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendored dependencies from AI Phone Agent project."""

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

@@ -0,0 +1,348 @@
+"""Audio I/O pipeline over Bluetooth HFP via PulseAudio / PipeWire.
+
+Uses ``pasimple`` (PulseAudio simple API binding) for low-latency capture
+and playback on the HFP audio source / sink.
+Falls back to a mock implementation when pasimple is not available.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import struct
+import time
+import wave
+from pathlib import Path
+from typing import Any, Callable
+
+from .. import config as cfg
+
+logger = logging.getLogger("bluetooth.audio")
+
+# ---------------------------------------------------------------------------
+# Audio format constants (must match config.yaml defaults)
+# ---------------------------------------------------------------------------
+SAMPLE_RATE = 16_000
+CHANNELS = 1
+SAMPLE_WIDTH = 2  # S16LE = 2 bytes per sample
+CHUNK_DURATION_MS = 20  # 20 ms chunks
+CHUNK_SAMPLES = SAMPLE_RATE * CHUNK_DURATION_MS // 1000  # 320 samples
+CHUNK_BYTES = CHUNK_SAMPLES * CHANNELS * SAMPLE_WIDTH  # 640 bytes
+
+# ---------------------------------------------------------------------------
+# Conditional pasimple import
+# ---------------------------------------------------------------------------
+
+_PASIMPLE_AVAILABLE = False
+
+try:
+    import pasimple
+
+    _PASIMPLE_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "pasimple not available — using mock AudioPipeline for development"
+    )
+
+# PulseAudio format constants (mirror pa_sample_format)
+_PA_SAMPLE_S16LE = 3  # pasimple.PA_SAMPLE_S16LE when available
+
+
+class AudioPipeline:
+    """Capture and play audio over Bluetooth HFP sink/source."""
+
+    def __init__(self) -> None:
+        self._recording: bool = False
+        self._playing: bool = False
+        self._record_task: asyncio.Task | None = None
+        self._play_task: asyncio.Task | None = None
+
+        # PulseAudio simple streams
+        self._pa_record: Any | None = None
+        self._pa_play: Any | None = None
+
+        # WAV recording
+        self._wav_writer: wave.Wave_write | None = None
+        self._wav_path: Path | None = None
+
+    # -- Properties ----------------------------------------------------------
+
+    @property
+    def is_playing(self) -> bool:
+        return self._playing
+
+    @property
+    def is_recording(self) -> bool:
+        return self._recording
+
+    # -- Recording (capture from HFP source) ---------------------------------
+
+    async def start_recording(
+        self, callback: Callable[[bytes], Any]
+    ) -> None:
+        """Start capturing audio from the Bluetooth HFP source.
+
+        *callback* is called with each chunk of raw PCM bytes (S16LE, 16 kHz,
+        mono).  The callback may be a regular function or a coroutine.
+        """
+        if self._recording:
+            logger.warning("Recording already in progress")
+            return
+
+        self._recording = True
+
+        if _PASIMPLE_AVAILABLE:
+            self._record_task = asyncio.create_task(
+                self._pa_record_loop(callback)
+            )
+        else:
+            self._record_task = asyncio.create_task(
+                self._mock_record_loop(callback)
+            )
+
+        logger.info("Audio recording started")
+
+    async def stop_recording(self) -> None:
+        """Stop the current audio capture."""
+        if not self._recording:
+            return
+
+        self._recording = False
+        if self._record_task and not self._record_task.done():
+            self._record_task.cancel()
+            try:
+                await self._record_task
+            except asyncio.CancelledError:
+                pass
+
+        # Close PulseAudio record stream
+        if self._pa_record is not None:
+            try:
+                self._pa_record.close()
+            except Exception:
+                pass
+            self._pa_record = None
+
+        # Close any open WAV file
+        self.stop_wav_recording()
+
+        logger.info("Audio recording stopped")
+
+    # -- Playback (play to HFP sink) ----------------------------------------
+
+    async def play_audio(self, pcm_data: bytes) -> None:
+        """Play raw PCM data (S16LE, 16 kHz, mono) to the Bluetooth HFP sink.
+
+        Blocks (asynchronously) until all data is written.
+        """
+        if self._playing:
+            logger.warning("Playback already in progress — stopping first")
+            await self.stop_playback()
+
+        self._playing = True
+
+        if _PASIMPLE_AVAILABLE:
+            self._play_task = asyncio.create_task(
+                self._pa_play_data(pcm_data)
+            )
+        else:
+            self._play_task = asyncio.create_task(
+                self._mock_play_data(pcm_data)
+            )
+
+        await self._play_task
+        self._playing = False
+
+    async def stop_playback(self) -> None:
+        """Stop any in-progress playback."""
+        if not self._playing:
+            return
+
+        self._playing = False
+        if self._play_task and not self._play_task.done():
+            self._play_task.cancel()
+            try:
+                await self._play_task
+            except asyncio.CancelledError:
+                pass
+
+        # Close PulseAudio play stream
+        if self._pa_play is not None:
+            try:
+                self._pa_play.close()
+            except Exception:
+                pass
+            self._pa_play = None
+
+        logger.info("Audio playback stopped")
+
+    # -- WAV recording -------------------------------------------------------
+
+    def start_wav_recording(self, filepath: str | Path) -> None:
+        """Begin writing captured audio to a WAV file.
+
+        Must be called while recording is active — the captured audio chunks
+        will be written to the WAV alongside being sent to the callback.
+        """
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+
+        self._wav_path = filepath
+        self._wav_writer = wave.open(str(filepath), "wb")
+        self._wav_writer.setnchannels(CHANNELS)
+        self._wav_writer.setsampwidth(SAMPLE_WIDTH)
+        self._wav_writer.setframerate(SAMPLE_RATE)
+        logger.info("WAV recording started: %s", filepath)
+
+    def stop_wav_recording(self) -> Path | None:
+        """Close the WAV file and return the path.
+
+        Returns None if no WAV recording was in progress.
+        """
+        if self._wav_writer is None:
+            return None
+
+        try:
+            self._wav_writer.close()
+        except Exception as exc:
+            logger.error("Error closing WAV file: %s", exc)
+
+        path = self._wav_path
+        self._wav_writer = None
+        self._wav_path = None
+        logger.info("WAV recording stopped: %s", path)
+        return path
+
+    def _write_wav_chunk(self, data: bytes) -> None:
+        """Write a PCM chunk to the WAV file if recording is active."""
+        if self._wav_writer is not None:
+            try:
+                self._wav_writer.writeframes(data)
+            except Exception as exc:
+                logger.error("WAV write error: %s", exc)
+
+    # -- PulseAudio record loop ----------------------------------------------
+
+    async def _pa_record_loop(
+        self, callback: Callable[[bytes], Any]
+    ) -> None:
+        """Capture audio from PulseAudio/PipeWire HFP source."""
+        loop = asyncio.get_running_loop()
+
+        try:
+            self._pa_record = pasimple.PaSimple(
+                pasimple.PA_STREAM_RECORD,
+                _PA_SAMPLE_S16LE,
+                CHANNELS,
+                SAMPLE_RATE,
+                app_name="ai-phone-agent",
+                stream_name="hfp-capture",
+            )
+        except Exception as exc:
+            logger.error("Failed to open PulseAudio record stream: %s", exc)
+            self._recording = False
+            return
+
+        try:
+            while self._recording:
+                # Read is blocking — run in thread pool
+                data: bytes = await loop.run_in_executor(
+                    None, self._pa_record.read, CHUNK_BYTES
+                )
+                if not data:
+                    continue
+
+                self._write_wav_chunk(data)
+
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(data)
+                else:
+                    callback(data)
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:
+            logger.error("Record loop error: %s", exc)
+        finally:
+            self._recording = False
+
+    # -- PulseAudio playback -------------------------------------------------
+
+    async def _pa_play_data(self, pcm_data: bytes) -> None:
+        """Play PCM data via PulseAudio/PipeWire HFP sink."""
+        loop = asyncio.get_running_loop()
+
+        try:
+            self._pa_play = pasimple.PaSimple(
+                pasimple.PA_STREAM_PLAYBACK,
+                _PA_SAMPLE_S16LE,
+                CHANNELS,
+                SAMPLE_RATE,
+                app_name="ai-phone-agent",
+                stream_name="hfp-playback",
+            )
+        except Exception as exc:
+            logger.error("Failed to open PulseAudio playback stream: %s", exc)
+            return
+
+        try:
+            offset = 0
+            while offset < len(pcm_data) and self._playing:
+                chunk = pcm_data[offset : offset + CHUNK_BYTES]
+                await loop.run_in_executor(None, self._pa_play.write, chunk)
+                offset += CHUNK_BYTES
+
+            # Drain remaining buffered audio
+            if self._playing:
+                await loop.run_in_executor(None, self._pa_play.drain)
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:
+            logger.error("Playback error: %s", exc)
+        finally:
+            if self._pa_play is not None:
+                try:
+                    self._pa_play.close()
+                except Exception:
+                    pass
+                self._pa_play = None
+
+    # -- Mock helpers (development) ------------------------------------------
+
+    async def _mock_record_loop(
+        self, callback: Callable[[bytes], Any]
+    ) -> None:
+        """Generate silent audio chunks as a stand-in for real capture."""
+        logger.info("[mock] Recording — generating silence at %d Hz", SAMPLE_RATE)
+        silence = b"\x00" * CHUNK_BYTES
+
+        try:
+            while self._recording:
+                self._write_wav_chunk(silence)
+
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(silence)
+                else:
+                    callback(silence)
+
+                # Pace to real-time
+                await asyncio.sleep(CHUNK_DURATION_MS / 1000.0)
+        except asyncio.CancelledError:
+            pass
+
+    async def _mock_play_data(self, pcm_data: bytes) -> None:
+        """Simulate playback timing based on data length."""
+        duration = len(pcm_data) / (SAMPLE_RATE * CHANNELS * SAMPLE_WIDTH)
+        logger.info(
+            "[mock] Playing %.2f seconds of audio (%d bytes)",
+            duration, len(pcm_data),
+        )
+        try:
+            # Simulate real-time playback
+            remaining = duration
+            while remaining > 0 and self._playing:
+                step = min(remaining, 0.05)
+                await asyncio.sleep(step)
+                remaining -= step
+        except asyncio.CancelledError:
+            pass
+        logger.info("[mock] Playback finished")

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

@@ -0,0 +1,251 @@
+"""Phone Book Access Profile (PBAP) client via BlueZ / obexd D-Bus.
+
+Synchronises contacts from a connected phone.  Falls back to a mock
+implementation when D-Bus is not available.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from typing import Any
+
+logger = logging.getLogger("bluetooth.contacts")
+
+# ---------------------------------------------------------------------------
+# 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 PBAPClient for development"
+    )
+
+# obexd PBAP D-Bus constants
+_OBEX_SERVICE = "org.bluez.obex"
+_OBEX_CLIENT_PATH = "/org/bluez/obex"
+_OBEX_CLIENT_IFACE = "org.bluez.obex.Client1"
+_OBEX_PBAP_IFACE = "org.bluez.obex.PhonebookAccess1"
+_OBEX_TRANSFER_IFACE = "org.bluez.obex.Transfer1"
+
+
+def _parse_vcard(vcard_text: str) -> list[dict[str, Any]]:
+    """Parse raw vCard text (v2.1 / v3.0) into a list of contact dicts.
+
+    Each dict contains: name, first_name, last_name, phone (list), email
+    (list), company, title.
+    """
+    contacts: list[dict[str, Any]] = []
+    current: dict[str, Any] | None = None
+
+    for line in vcard_text.splitlines():
+        line = line.strip()
+
+        if line.upper() == "BEGIN:VCARD":
+            current = {
+                "name": "",
+                "first_name": "",
+                "last_name": "",
+                "phone": [],
+                "email": [],
+                "company": "",
+                "title": "",
+            }
+            continue
+
+        if line.upper() == "END:VCARD":
+            if current is not None:
+                # Build display name if not explicitly set
+                if not current["name"]:
+                    parts = [current["last_name"], current["first_name"]]
+                    current["name"] = " ".join(p for p in parts if p).strip()
+                contacts.append(current)
+            current = None
+            continue
+
+        if current is None:
+            continue
+
+        # Split property name from value (handle parameters like ;TYPE=CELL)
+        if ":" not in line:
+            continue
+
+        prop_part, _, value = line.partition(":")
+        prop_name = prop_part.split(";")[0].upper()
+
+        if prop_name == "FN":
+            current["name"] = value.strip()
+
+        elif prop_name == "N":
+            # N:LastName;FirstName;MiddleName;Prefix;Suffix
+            parts = value.split(";")
+            current["last_name"] = parts[0].strip() if len(parts) > 0 else ""
+            current["first_name"] = parts[1].strip() if len(parts) > 1 else ""
+
+        elif prop_name == "TEL":
+            phone = _normalise_phone(value.strip())
+            if phone and phone not in current["phone"]:
+                current["phone"].append(phone)
+
+        elif prop_name == "EMAIL":
+            email = value.strip()
+            if email and email not in current["email"]:
+                current["email"].append(email)
+
+        elif prop_name == "ORG":
+            current["company"] = value.split(";")[0].strip()
+
+        elif prop_name == "TITLE":
+            current["title"] = value.strip()
+
+    return contacts
+
+
+def _normalise_phone(raw: str) -> str:
+    """Strip common formatting from phone numbers, keep digits and leading +."""
+    cleaned = re.sub(r"[^\d+]", "", raw)
+    return cleaned
+
+
+class PBAPClient:
+    """Synchronise the phone book from a connected Bluetooth device."""
+
+    def __init__(self) -> None:
+        self._bus: Any | None = None
+        self._session_path: str | None = None
+
+    # -- Public API ----------------------------------------------------------
+
+    async def sync_contacts(self, device_address: str = "") -> list[dict[str, Any]]:
+        """Download contacts from the phone and return parsed list.
+
+        Each contact is a dict with: name, first_name, last_name, phone,
+        email, company, title.
+        """
+        vcard_data = await self.get_phonebook(device_address)
+        if not vcard_data:
+            return []
+
+        contacts = _parse_vcard(vcard_data)
+        logger.info("Synced %d contacts from phone", len(contacts))
+        return contacts
+
+    async def get_phonebook(self, device_address: str = "") -> str:
+        """Retrieve the raw vCard data for the entire phonebook.
+
+        Returns the vCard text, or an empty string on failure.
+        """
+        if not _DBUS_AVAILABLE:
+            return self._mock_get_phonebook()
+
+        return await self._obex_pull_phonebook(device_address)
+
+    # -- obexd D-Bus interaction ---------------------------------------------
+
+    async def _obex_pull_phonebook(self, device_address: str) -> str:
+        """Pull phonebook via obexd PBAP over D-Bus."""
+        loop = asyncio.get_running_loop()
+
+        try:
+            if self._bus is None:
+                self._bus = SessionMessageBus()
+
+            client = self._bus.get_proxy(_OBEX_SERVICE, _OBEX_CLIENT_PATH)
+
+            # Create PBAP session
+            session_path = client.CreateSession(
+                device_address,
+                {"Target": "PBAP"},
+            )
+            self._session_path = str(session_path)
+            logger.info("PBAP session created: %s", self._session_path)
+
+            pbap = self._bus.get_proxy(_OBEX_SERVICE, self._session_path)
+
+            # Select internal phonebook
+            pbap.Select("int", "pb")
+
+            # Pull all contacts
+            transfer_path, properties = pbap.PullAll(
+                "",
+                {"Format": "vcard30"},
+            )
+
+            # Wait for transfer to complete
+            transfer = self._bus.get_proxy(_OBEX_SERVICE, str(transfer_path))
+            filename = str(properties.get("Filename", ""))
+
+            # Poll transfer status
+            for _ in range(60):  # up to ~30 seconds
+                status = str(transfer.Status)
+                if status == "complete":
+                    break
+                if status == "error":
+                    logger.error("PBAP transfer failed")
+                    return ""
+                await asyncio.sleep(0.5)
+
+            # Read the downloaded vCard file
+            if filename:
+                with open(filename, "r", encoding="utf-8") as f:
+                    return f.read()
+            return ""
+
+        except Exception as exc:
+            logger.error("PBAP phonebook pull failed: %s", exc)
+            return ""
+
+        finally:
+            # Clean up session
+            if self._session_path:
+                try:
+                    client = self._bus.get_proxy(
+                        _OBEX_SERVICE, _OBEX_CLIENT_PATH
+                    )
+                    client.RemoveSession(self._session_path)
+                except Exception:
+                    pass
+                self._session_path = None
+
+    # -- Mock helpers --------------------------------------------------------
+
+    @staticmethod
+    def _mock_get_phonebook() -> str:
+        logger.info("[mock] Returning fake phonebook vCard data")
+        return (
+            "BEGIN:VCARD\r\n"
+            "VERSION:3.0\r\n"
+            "FN:Zhang San\r\n"
+            "N:Zhang;San;;;\r\n"
+            "TEL;TYPE=CELL:+86 138 0000 0001\r\n"
+            "EMAIL:zhangsan@example.com\r\n"
+            "ORG:Example Corp\r\n"
+            "TITLE:Engineer\r\n"
+            "END:VCARD\r\n"
+            "\r\n"
+            "BEGIN:VCARD\r\n"
+            "VERSION:3.0\r\n"
+            "FN:Li Si\r\n"
+            "N:Li;Si;;;\r\n"
+            "TEL;TYPE=CELL:+86 139 0000 0002\r\n"
+            "TEL;TYPE=WORK:+86 10 8888 0002\r\n"
+            "EMAIL:lisi@example.com\r\n"
+            "ORG:Another Inc\r\n"
+            "TITLE:Manager\r\n"
+            "END:VCARD\r\n"
+            "\r\n"
+            "BEGIN:VCARD\r\n"
+            "VERSION:3.0\r\n"
+            "FN:Wang Wu\r\n"
+            "N:Wang;Wu;;;\r\n"
+            "TEL;TYPE=CELL:+86 137 0000 0003\r\n"
+            "ORG:Tech Ltd\r\n"
+            "END:VCARD\r\n"
+        )