@agentunion/kite 1.0.7 → 1.2.0

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

@@ -0,0 +1,274 @@
+"""Telephony control via PipeWire / BlueZ HFP D-Bus interface.
+
+Provides call dialling, answering, hanging-up and call-state 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 enum import Enum
+from typing import Any, Callable
+
+logger = logging.getLogger("bluetooth.telephony")
+
+# ---------------------------------------------------------------------------
+# Conditional D-Bus imports
+# ---------------------------------------------------------------------------
+
+_DBUS_AVAILABLE = False
+
+try:
+    from dasbus.connection import SessionMessageBus
+    from dasbus.loop import EventLoop
+
+    _DBUS_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "dasbus not available — using mock TelephonyController for development"
+    )
+
+# D-Bus constants (placeholder interface — replace with actual BlueZ HFP
+# or oFono / ModemManager interface when integrating on real hardware).
+_TELEPHONY_SERVICE = "org.pipewire.Telephony"
+_TELEPHONY_PATH = "/org/pipewire/Telephony"
+_TELEPHONY_IFACE = "org.pipewire.Telephony"
+
+
+class CallState(str, Enum):
+    """Possible states for a phone call."""
+
+    IDLE = "idle"
+    DIALING = "dialing"
+    ALERTING = "alerting"
+    ACTIVE = "active"
+    HELD = "held"
+    INCOMING = "incoming"
+    DISCONNECTED = "disconnected"
+
+
+class TelephonyController:
+    """Control phone calls over Bluetooth HFP via D-Bus."""
+
+    def __init__(self) -> None:
+        self._bus: Any | None = None
+        self._proxy: Any | None = None
+
+        self._call_state: CallState = CallState.IDLE
+        self._current_number: str = ""
+        self._signal_task: asyncio.Task | None = None
+        self._running: bool = False
+
+        # Callbacks
+        self.on_call_state_changed: Callable[[CallState, str], Any] | None = None
+        self.on_incoming_call: Callable[[str], Any] | None = None
+
+    # -- Properties ----------------------------------------------------------
+
+    @property
+    def call_state(self) -> CallState:
+        return self._call_state
+
+    @property
+    def current_number(self) -> str:
+        return self._current_number
+
+    # -- Lifecycle -----------------------------------------------------------
+
+    async def start(self) -> None:
+        """Connect to the telephony D-Bus service and start listening for
+        call-state signals.
+        """
+        self._running = True
+
+        if _DBUS_AVAILABLE:
+            try:
+                self._bus = SessionMessageBus()
+                self._proxy = self._bus.get_proxy(
+                    _TELEPHONY_SERVICE, _TELEPHONY_PATH
+                )
+                logger.info("Telephony D-Bus proxy acquired")
+                self._signal_task = asyncio.create_task(
+                    self._listen_signals()
+                )
+            except Exception as exc:
+                logger.error(
+                    "Failed to connect to Telephony D-Bus service: %s", exc
+                )
+                self._bus = None
+                self._proxy = None
+        else:
+            logger.info("D-Bus not available — telephony running in mock mode")
+
+    async def stop(self) -> None:
+        """Stop listening and clean up."""
+        self._running = False
+        if self._signal_task and not self._signal_task.done():
+            self._signal_task.cancel()
+            try:
+                await self._signal_task
+            except asyncio.CancelledError:
+                pass
+        logger.info("TelephonyController stopped")
+
+    # -- Call control --------------------------------------------------------
+
+    async def dial(self, number: str) -> bool:
+        """Initiate an outgoing call to *number*.
+
+        Returns True if the call was successfully initiated.
+        """
+        logger.info("Dialling %s ...", number)
+        self._current_number = number
+
+        if not _DBUS_AVAILABLE or self._proxy is None:
+            return await self._mock_dial(number)
+
+        try:
+            self._proxy.Dial(number)
+            self._set_state(CallState.DIALING, number)
+            return True
+        except Exception as exc:
+            logger.error("Dial failed: %s", exc)
+            return False
+
+    async def answer(self) -> bool:
+        """Answer an incoming call.
+
+        Returns True on success.
+        """
+        logger.info("Answering incoming call ...")
+
+        if not _DBUS_AVAILABLE or self._proxy is None:
+            return await self._mock_answer()
+
+        try:
+            self._proxy.Answer()
+            self._set_state(CallState.ACTIVE, self._current_number)
+            return True
+        except Exception as exc:
+            logger.error("Answer failed: %s", exc)
+            return False
+
+    async def hangup(self) -> bool:
+        """Hang up the current or incoming call.
+
+        Returns True on success.
+        """
+        logger.info("Hanging up ...")
+
+        if not _DBUS_AVAILABLE or self._proxy is None:
+            return await self._mock_hangup()
+
+        try:
+            self._proxy.Hangup()
+            self._set_state(CallState.DISCONNECTED, self._current_number)
+            # Reset to idle after a short delay
+            await asyncio.sleep(0.5)
+            self._set_state(CallState.IDLE, "")
+            return True
+        except Exception as exc:
+            logger.error("Hangup failed: %s", exc)
+            return False
+
+    async def get_call_state(self) -> str:
+        """Return the current call state as a string."""
+        if _DBUS_AVAILABLE and self._proxy is not None:
+            try:
+                raw = self._proxy.GetCallState()
+                self._call_state = CallState(raw.lower())
+            except Exception:
+                pass  # use cached state
+        return self._call_state.value
+
+    # -- D-Bus signal listener -----------------------------------------------
+
+    async def _listen_signals(self) -> None:
+        """Poll D-Bus for call state changes.
+
+        A real implementation would subscribe to D-Bus signals instead of
+        polling.  This loop acts as a placeholder.
+        """
+        while self._running:
+            try:
+                if self._proxy is not None:
+                    raw = self._proxy.GetCallState()
+                    new_state = CallState(raw.lower())
+                    if new_state != self._call_state:
+                        old = self._call_state
+                        self._call_state = new_state
+
+                        # Try to read the number associated with the call
+                        try:
+                            self._current_number = str(
+                                self._proxy.GetCallNumber()
+                            )
+                        except Exception:
+                            pass
+
+                        logger.info(
+                            "Call state: %s -> %s (number=%s)",
+                            old.value,
+                            new_state.value,
+                            self._current_number,
+                        )
+
+                        if new_state == CallState.INCOMING and self.on_incoming_call:
+                            self.on_incoming_call(self._current_number)
+                        if self.on_call_state_changed:
+                            self.on_call_state_changed(
+                                new_state, self._current_number
+                            )
+            except Exception as exc:
+                logger.debug("Signal poll error: %s", exc)
+
+            await asyncio.sleep(1.0)
+
+    # -- Internal helpers ----------------------------------------------------
+
+    def _set_state(self, state: CallState, number: str) -> None:
+        old = self._call_state
+        self._call_state = state
+        self._current_number = number
+
+        if old != state:
+            logger.info(
+                "Call state: %s -> %s (number=%s)",
+                old.value, state.value, number,
+            )
+            if self.on_call_state_changed:
+                self.on_call_state_changed(state, number)
+
+    # -- Mock helpers (development) ------------------------------------------
+
+    async def _mock_dial(self, number: str) -> bool:
+        logger.info("[mock] Dialling %s", number)
+        self._set_state(CallState.DIALING, number)
+        # Simulate ringing then active
+        await asyncio.sleep(0.3)
+        self._set_state(CallState.ALERTING, number)
+        await asyncio.sleep(0.5)
+        self._set_state(CallState.ACTIVE, number)
+        return True
+
+    async def _mock_answer(self) -> bool:
+        logger.info("[mock] Answering call from %s", self._current_number)
+        self._set_state(CallState.ACTIVE, self._current_number)
+        return True
+
+    async def _mock_hangup(self) -> bool:
+        logger.info("[mock] Hanging up call with %s", self._current_number)
+        self._set_state(CallState.DISCONNECTED, self._current_number)
+        await asyncio.sleep(0.3)
+        self._set_state(CallState.IDLE, "")
+        return True
+
+    async def mock_incoming_call(self, number: str) -> None:
+        """Simulate an incoming call — useful for testing without hardware."""
+        logger.info("[mock] Simulating incoming call from %s", number)
+        self._current_number = number
+        self._set_state(CallState.INCOMING, number)
+        if self.on_incoming_call:
+            self.on_incoming_call(number)

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

@@ -0,0 +1,139 @@
+"""Configuration management — YAML file with runtime override support."""
+
+from __future__ import annotations
+
+import copy
+import os
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+_VENDOR_DIR = Path(__file__).resolve().parent
+_MODULE_DIR = _VENDOR_DIR.parent  # extensions/services/web/
+_ROOT = _MODULE_DIR
+_DEFAULT_CONFIG_PATH = _MODULE_DIR / "config.yaml"
+_RUNTIME_CONFIG_PATH: Path | None = None
+_load_error: str | None = None  # set when config loading fails
+
+_config: dict[str, Any] = {}
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Recursively merge *override* into *base* (mutates *base*)."""
+    for key, value in override.items():
+        if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+            _deep_merge(base[key], value)
+        else:
+            base[key] = value
+    return base
+
+
+def _resolve_project_root() -> Path:
+    """Resolve ai-phone-agent project root for relative path resolution."""
+    kite_project = os.environ.get("KITE_PROJECT")
+    if kite_project:
+        return Path(kite_project).parent  # Kite/ -> ai-phone-agent/
+    # Fallback: walk up from module dir
+    return _MODULE_DIR
+
+
+def load_config() -> dict[str, Any]:
+    """Load default config, then overlay runtime config if it exists.
+
+    Returns the loaded config dict.  If the default config file is missing,
+    sets ``_load_error`` with a human-readable message and returns an empty
+    dict so the caller can decide how to handle it (e.g. log and exit
+    gracefully instead of crashing).
+    """
+    global _config, _RUNTIME_CONFIG_PATH, _load_error
+
+    if not _DEFAULT_CONFIG_PATH.exists():
+        _load_error = (
+            f"默认配置文件不存在: {_DEFAULT_CONFIG_PATH}\n"
+            f"请将 config.yaml 放到 Web 模块目录: {_MODULE_DIR}"
+        )
+        _config = {}
+        return _config
+
+    try:
+        with open(_DEFAULT_CONFIG_PATH, "r", encoding="utf-8") as f:
+            _config = yaml.safe_load(f) or {}
+    except Exception as exc:
+        _load_error = f"配置文件加载失败: {_DEFAULT_CONFIG_PATH}\n原因: {exc}"
+        _config = {}
+        return _config
+
+    # Determine data dir — resolve relative paths against project root
+    project_root = _resolve_project_root()
+    data_dir = Path(_config.get("data", {}).get("base_dir", "./data"))
+    if not data_dir.is_absolute():
+        data_dir = project_root / data_dir
+    _config.setdefault("data", {})["base_dir"] = str(data_dir)
+
+    _RUNTIME_CONFIG_PATH = data_dir / "config" / "runtime.yaml"
+    if _RUNTIME_CONFIG_PATH.exists():
+        try:
+            with open(_RUNTIME_CONFIG_PATH, "r", encoding="utf-8") as f:
+                runtime = yaml.safe_load(f) or {}
+            _deep_merge(_config, runtime)
+        except Exception as exc:
+            print(f"[web] WARNING: 运行时配置加载失败 ({_RUNTIME_CONFIG_PATH}): {exc}")
+
+    _load_error = None
+    return _config
+
+
+def get_load_error() -> str | None:
+    """Return the error message from the last load_config() call, or None."""
+    return _load_error
+
+
+def get_config() -> dict[str, Any]:
+    if not _config:
+        load_config()
+    return _config
+
+
+def get(path: str, default: Any = None) -> Any:
+    """Get a nested config value using dot-notation, e.g. ``get('llm.active_provider')``."""
+    cfg = get_config()
+    keys = path.split(".")
+    for k in keys:
+        if isinstance(cfg, dict):
+            cfg = cfg.get(k)
+        else:
+            return default
+        if cfg is None:
+            return default
+    return cfg
+
+
+def update_config(updates: dict[str, Any]) -> dict[str, Any]:
+    """Merge *updates* into runtime config and persist to disk."""
+    global _config
+    _deep_merge(_config, updates)
+    _save_runtime(updates)
+    return _config
+
+
+def _save_runtime(updates: dict[str, Any]) -> None:
+    if _RUNTIME_CONFIG_PATH is None:
+        return
+    existing: dict[str, Any] = {}
+    if _RUNTIME_CONFIG_PATH.exists():
+        with open(_RUNTIME_CONFIG_PATH, "r", encoding="utf-8") as f:
+            existing = yaml.safe_load(f) or {}
+    _deep_merge(existing, updates)
+    _RUNTIME_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(_RUNTIME_CONFIG_PATH, "w", encoding="utf-8") as f:
+        yaml.dump(existing, f, allow_unicode=True, default_flow_style=False)
+
+
+def data_dir() -> Path:
+    return Path(get("data.base_dir", "./data"))
+
+
+def root_dir() -> Path:
+    """Return the project root directory."""
+    return _ROOT