conson-xp 1.51.0__py3-none-any.whl → 1.51.1__py3-none-any.whl

{conson_xp-1.51.0.dist-info → conson_xp-1.51.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.51.0
+Version: 1.51.1
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -450,6 +450,7 @@ xp telegram version
 
 
 xp term
+xp term homekit
 xp term protocol
 xp term state
 

{conson_xp-1.51.0.dist-info → conson_xp-1.51.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.51.0.dist-info/METADATA,sha256=8rmZ2V68vB3gZpx_sScMBXxKXqAei3GeqOOUHGe92mo,11432
-conson_xp-1.51.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.51.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.51.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=IbYggn-GNpmY-NkggNp_7SLbVaF6zPk0wENVaZeOIeE,182
+conson_xp-1.51.1.dist-info/METADATA,sha256=15wTMgVInRD7kUjYvZe3AtZPgmPGG_XcXsaGRB3Vjds,11448
+conson_xp-1.51.1.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.51.1.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.51.1.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=PTmuTUb4TXiPuSSkKX3UT63IhH_fx4EpMP33cMsA6Nc,182
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
 xp/cli/commands/__init__.py,sha256=G7A1KFRSV0CEeDTqr_khu-K9_sc01CTI2KSfkFcaBRM,4949
@@ -43,7 +43,7 @@ xp/cli/commands/telegram/telegram_parse_commands.py,sha256=xCDRRFgj41RtStvwROfi-
 xp/cli/commands/telegram/telegram_version_commands.py,sha256=hAMjSAa7zfMNfNFln63sKeNPcmW89bISkcVs6BgsqOg,1558
 xp/cli/commands/term/__init__.py,sha256=1NNST_8YJfj5LCujQISwQflK6LyEn7mDmZpMpvI9d-o,116
 xp/cli/commands/term/term.py,sha256=gjvsv2OE-F_KNWQrWi04fXQ5cGo0l8P-Ortbb5KTA-A,309
-xp/cli/commands/term/term_commands.py,sha256=ypJo9GL0eNwllgJJux2agJkcco6k9HMM-5f3aTbiQ2c,1216
+xp/cli/commands/term/term_commands.py,sha256=Z3pq_xzP0j5YfYFOwASaZUxXDkikSV_E4cFjMb69LUU,1796
 xp/cli/main.py,sha256=Wbtji5ddW3IEoAfecHrEPk8W_w1bGD20B-NqAWfI_F4,1968
 xp/cli/utils/__init__.py,sha256=gTGIj60Uai0iE7sr9_TtEpl04fD7krtTzbbigXUsUVU,46
 xp/cli/utils/click_tree.py,sha256=sr4l9RWTCnASkdvkJKnRRxWSQPlF1DbFdBNu9gL7Ekc,1693
@@ -84,7 +84,7 @@ xp/models/config/__init__.py,sha256=gEZnX9eE3DjFtLtF32riEjJQLypqQRbyPauBI4Cowbs,
 xp/models/config/conson_module_config.py,sha256=t1G0LnNNMnjs3ahhz4-Z_5SlEv2FCrcRq13OmvZ2pvA,3009
 xp/models/homekit/__init__.py,sha256=5HDSOClCu0ArK3IICn3_LDMMLBAzLjBxUUSF73bxSSk,34
 xp/models/homekit/homekit_accessory.py,sha256=ANjDWlFxeNTstl7lKdmf6vMOC0wc005vpiD6awRcptA,1052
-xp/models/homekit/homekit_config.py,sha256=OMq0eayAJ6NRr8PXANvQzgEYGW9RN_ycyEmnTlTlHrQ,2938
+xp/models/homekit/homekit_config.py,sha256=EqoiZ1E6l9bBjxKqK1nxVGRfFY5ZtRHH-jZhYtRH2gU,3048
 xp/models/log_entry.py,sha256=tAiNwouCP2d4jKiHJY9a-2iAi8LWTpG-TZsOPDIstlA,4423
 xp/models/protocol/__init__.py,sha256=TJ_CJKchA-xgQiv5vCo_ndBBZjrcaTmjT74bR0T-5Cw,38
 xp/models/protocol/conbus_protocol.py,sha256=hF78N5xvBzMiyWoKd8i_avA8kJ1As_9Pplkw1GMqKzk,9145
@@ -105,7 +105,8 @@ xp/models/telegram/system_telegram.py,sha256=064AlFi_WghoYlVDUtIIbvwtZyUEZj7_auK
 xp/models/telegram/telegram.py,sha256=-kNloBlwMJ5w1-FAMSLzBPnyOGUNEBG3SG2d0eTi2PY,847
 xp/models/telegram/telegram_type.py,sha256=IjGEosbs7IDqYT7ktn-FcKS-kAJ4eXW-KJGkkoAGysw,428
 xp/models/telegram/timeparam_type.py,sha256=z5EQ32SQjDi7zKshtkvDzqaMfPMUeXCWKEGI5VgvBvU,1142
-xp/models/term/__init__.py,sha256=aFvzGZHr_dI6USb8MJuYLSLMvxi_ZWMVtokHDt8428s,263
+xp/models/term/__init__.py,sha256=VVZsEyXBEr-TnBlrFFifZ6PjJHUl2kwnRUZx_kC2Ljg,343
+xp/models/term/accessory_state.py,sha256=GcMtCxOeHpc3IPDO1F9j2I6rdhaNV75iQ2md--XY6jo,1650
 xp/models/term/connection_state.py,sha256=oYcst01uH35kO541jGuXMqvJ2iduiHYryUsMK0d89pQ,1807
 xp/models/term/module_state.py,sha256=i7u8y_B5ScMRULQb_kMSD_wwKzbrLHlkECsTgNS46PQ,939
 xp/models/term/protocol_keys_config.py,sha256=tSlkxEwgQuVRYLTaUNd569osQsNCdb9ED4InNgX9rKo,1223
@@ -145,7 +146,7 @@ xp/services/conbus/write_config_service.py,sha256=BCfmLNPRDpwSwRMRYJvx2FXA8IZsdg
 xp/services/homekit/__init__.py,sha256=xAMKmln_AmEFdOOJGKWYi96seRlKDQpKx3-hm7XbdIo,36
 xp/services/homekit/homekit_cache_service.py,sha256=z1TB6icEqd1paoilVTewuFL0lXVCQbvrOJkJvvQECJY,11060
 xp/services/homekit/homekit_conbus_service.py,sha256=XPKv7Mit1rn7XLaQZcKmlMMUlyj-o0J2z8XBH3NaEIM,3390
-xp/services/homekit/homekit_config_validator.py,sha256=bLDOY8dbXvqvrDLtn4PijZA38qNmQWcQFWIY6hjLrl0,10875
+xp/services/homekit/homekit_config_validator.py,sha256=jf09jHIFbZg7YpDbGsGHT1p4a1vpUED2xR6iZN19cfM,10875
 xp/services/homekit/homekit_conson_validator.py,sha256=tmUxBzytX9FbUWTR1XdbAi_qb_whAdGPSaml98Czszg,3858
 xp/services/homekit/homekit_dimminglight.py,sha256=EzfGhy3zZkbFPfN72Dh_eSb5mJQOpxGi6ZwnyEOSHxU,5819
 xp/services/homekit/homekit_dimminglight_service.py,sha256=0Ve6cXtY7v7JCv7gibOBWjPfCU7KK4Lk6GjIu9_GhyE,5282
@@ -184,9 +185,12 @@ xp/services/telegram/telegram_output_service.py,sha256=9deqtcPndRqJ-3XQUWlJhXaVc
 xp/services/telegram/telegram_service.py,sha256=jPu0Xrh3IpvqPLyuQT5Vf8HHw00vBingONHdxf_9TkI,13315
 xp/services/telegram/telegram_version_service.py,sha256=oXnZ_K7OQ7xD-GEj3zDYp52KlkqVuHpO4bf7gMlC_w4,10574
 xp/services/term/__init__.py,sha256=BIeOK042bMR-0l6MA80wdW5VuHlpWOXtRER9IG5ilQA,245
+xp/services/term/homekit_service.py,sha256=3g6Twhg6wcRT2E01Daa2J41lzdyX6gVjfz5wgutOvgQ,19307
 xp/services/term/protocol_monitor_service.py,sha256=5YBI0Nu7B7gMhaTbUhL6k9LSRfnCIj6CwrCYHiMHavA,10067
-xp/services/term/state_monitor_service.py,sha256=4CmeHf5k9mf67AleOB7byM7_g5WwbAOnmgxl6I2vBwg,17116
+xp/services/term/state_monitor_service.py,sha256=EK9tNBfamAIV0z0EMsXDYWC-rXv6l6k_bHsC8xyEFSo,17116
 xp/term/__init__.py,sha256=Xg2DhBeI3xQJLfc7_BPWI1por-rUXemyer5OtOt9Cus,51
+xp/term/homekit.py,sha256=IYJEVhQUFUcmC_TubYxcvlU5IKF-2sL_giBNKO35fjU,3642
+xp/term/homekit.tcss,sha256=qeR_OV8D_9Mxb-aPNz-MH0ZJOsdCk-fJ-zv6CQV5ihw,1382
 xp/term/protocol.py,sha256=6MX3mduLei-AgLGaIe8lfOSu4Hi0y3KGePFFM2ssstc,3475
 xp/term/protocol.tcss,sha256=r_KfxrbpycGHLVXqZc6INBBcUJME0hLrAZkF1oqnab4,2126
 xp/term/state.py,sha256=FBpYV_bWYJh9o17qcMx6sHgUARQS-uNOtUt6G7Vs1n8,3274
@@ -195,13 +199,14 @@ xp/term/widgets/__init__.py,sha256=ftWmN_fmjxy2E8Qfm-YSRmzKfgL0KTBCTpgvYWCPbUY,2
 xp/term/widgets/help_menu.py,sha256=KLkdIXfhARLFNEs2lv1u0sYBz9LzOCcDLxbMGzc7e5Y,1812
 xp/term/widgets/modules_list.py,sha256=qAG-n0nK0YdNE9v4C3-sHgxLvF1i1FR7v_GArdaoUQw,7831
 xp/term/widgets/protocol_log.py,sha256=E68QmSMpOFrvrPTo_gOQVfyiDqY5c_y8fkNKnQw6Vwo,2650
-xp/term/widgets/status_footer.py,sha256=YYAT0431p6jmrzzpVgaPhu7yGkRroWGv4e99t2XlkHI,3297
+xp/term/widgets/room_list.py,sha256=3q3otusnQn4qFRbTY0-QbpMP3vPmywM0izYRA_KjXn0,7871
+xp/term/widgets/status_footer.py,sha256=biV3EzfVSgm1T7Ofi88LXsTFCkD5mI_6Cpe-RpuOSxA,3429
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=Px1S3dFGA-_plavBxrq3IqmprNlgtNDunE3whg6Otwg,1722
-xp/utils/dependencies.py,sha256=I8Z89_iTCeR-7adpae3GVQUGZ-1gY6wg0OGKmdJGg3w,24536
+xp/utils/dependencies.py,sha256=XHOAq5nIbXD8oq4FBp3wWvinDa4Ti7cUktJtUB0z51A,25339
 xp/utils/event_helper.py,sha256=zD0K3TPfGEThU9vUNlDtglTai3Cmm30727iwjDZy6Dk,1007
 xp/utils/logging.py,sha256=wJ1d-yg97NiZUrt2F8iDMcmnHVwC-PErcI-7dpyiRDc,3777
 xp/utils/serialization.py,sha256=TS1OwpTOemSvXsCGw3js4JkYYFEqkzrPe8V9QYQefdw,4684
 xp/utils/state_machine.py,sha256=W9AY4ntRZnFeHAa5d43hm37j53uJPlqkRvWTPiBhJ_0,2464
 xp/utils/time_utils.py,sha256=K17godWpL18VEypbTlvNOEDG6R3huYnf29yjkcnwRpU,3796
-conson_xp-1.51.0.dist-info/RECORD,,
+conson_xp-1.51.1.dist-info/RECORD,,

xp/__init__.py

@@ -4,7 +4,7 @@ XP CLI tool for remote console bus operations.
 conson-xp package.
 """
 
-__version__ = "1.51.0"
+__version__ = "1.51.1"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

xp/cli/commands/term/term_commands.py

@@ -48,3 +48,26 @@ def state_monitor(ctx: Context) -> None:
 
     # Resolve StateMonitorApp from container and run
     ctx.obj.get("container").get_container().resolve(StateMonitorApp).run()
+
+
+@term.command("homekit")
+@click.pass_context
+def homekit_monitor(ctx: Context) -> None:
+    r"""
+    Start TUI for HomeKit accessory monitoring.
+
+    Displays HomeKit rooms and accessories with real-time state updates
+    in an interactive terminal interface. Press action keys (a-z) to
+    toggle accessories.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp term homekit
+    """
+    from xp.term.homekit import HomekitApp
+
+    # Resolve HomekitApp from container and run
+    ctx.obj.get("container").get_container().resolve(HomekitApp).run()

xp/models/homekit/homekit_config.py

@@ -61,6 +61,7 @@ class HomekitAccessoryConfig(BaseModel):
         service: Service type for the accessory.
         on_action: on code for the accessory.
         off_action: off code for the accessory.
+        toggle_action: Optional toggle action code for the accessory.
         hap_accessory: Optional HAP accessory identifier.
     """
 
@@ -72,6 +73,7 @@ class HomekitAccessoryConfig(BaseModel):
     service: str
     on_action: str
     off_action: str
+    toggle_action: Optional[str] = None
     hap_accessory: Optional[int] = None
 
 

xp/models/term/__init__.py

@@ -1,5 +1,6 @@
 """Terminal UI models."""
 
+from xp.models.term.accessory_state import AccessoryState
 from xp.models.term.module_state import ModuleState
 from xp.models.term.protocol_keys_config import (
     ProtocolKeyConfig,
@@ -7,6 +8,7 @@ from xp.models.term.protocol_keys_config import (
 )
 
 __all__ = [
+    "AccessoryState",
     "ModuleState",
     "ProtocolKeyConfig",
     "ProtocolKeysConfig",

xp/models/term/accessory_state.py

@@ -0,0 +1,50 @@
+"""Accessory state data model for Homekit TUI."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class AccessoryState:
+    """
+    State of a HomeKit accessory for TUI display.
+
+    Attributes:
+        room_name: Room containing the accessory (e.g., "Salon").
+        accessory_name: Accessory display name (e.g., "Variateur salon").
+        action: Action key (a-z) for toggle control.
+        output_state: Output state ("ON", "OFF", "?").
+        dimming_state: Dimming percentage for dimmable modules, "-" if OFF, empty otherwise.
+        module_name: Module identifier (e.g., "A12").
+        serial_number: Module serial number.
+        module_type: Module type (e.g., "XP24", "XP33LED").
+        error_status: Status code ("OK" or error like "E10").
+        output: Module output number (1-based for display).
+        sort: Sort accessories according to homekit.yml configuration.
+        last_update: Last communication timestamp. None if never updated.
+        toggle_action: Raw toggle action telegram (e.g., "E02L12I02").
+    """
+
+    room_name: str
+    accessory_name: str
+    action: str
+    output_state: str
+    dimming_state: str
+    module_name: str
+    serial_number: str
+    module_type: str
+    error_status: str
+    output: int
+    sort: int
+    last_update: Optional[datetime] = None
+    toggle_action: Optional[str] = None
+
+    def is_dimmable(self) -> bool:
+        """
+        Check if accessory is dimmable.
+
+        Returns:
+            True if module type is XP33LR or XP33LED, False otherwise.
+        """
+        return self.module_type in ("XP33LR", "XP33LED")

xp/services/homekit/homekit_config_validator.py

@@ -221,7 +221,7 @@ class CrossReferenceValidator:
                 # Define output limits by module type
                 output_limits = {
                     "XP130": 0,  # Example limits
-                    "XP20": 0,
+                    "XP20": 8,
                     "XP24": 4,
                     "XP33": 3,
                     "XP33LR": 3,

xp/services/term/homekit_service.py

@@ -0,0 +1,512 @@
+"""HomeKit Service for terminal interface."""
+
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from psygnal import Signal
+
+from xp.models.config.conson_module_config import ConsonModuleListConfig
+from xp.models.homekit.homekit_config import HomekitAccessoryConfig, HomekitConfig
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.module_type_code import ModuleTypeCode
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.models.term.accessory_state import AccessoryState
+from xp.models.term.connection_state import ConnectionState
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.telegram.telegram_output_service import TelegramOutputService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class HomekitService:
+    """
+    Service for HomeKit accessory monitoring in terminal interface.
+
+    Wraps ConbusEventProtocol, HomekitConfig, and ConsonModuleListConfig to provide
+    high-level accessory state tracking for the TUI.
+
+    Attributes:
+        on_connection_state_changed: Signal emitted when connection state changes.
+        on_room_list_updated: Signal emitted when accessory list refreshed from config.
+        on_module_state_changed: Signal emitted when individual accessory state updates.
+        on_module_error: Signal emitted when module error occurs.
+        on_status_message: Signal emitted for status messages.
+        connection_state: Property returning current connection state.
+        server_info: Property returning server connection info (IP:port).
+        accessory_states: Property returning list of all accessory states.
+    """
+
+    on_connection_state_changed: Signal = Signal(ConnectionState)
+    on_room_list_updated: Signal = Signal(list)
+    on_module_state_changed: Signal = Signal(AccessoryState)
+    on_module_error: Signal = Signal(str, str)
+    on_status_message: Signal = Signal(str)
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        homekit_config: HomekitConfig,
+        conson_config: ConsonModuleListConfig,
+        telegram_service: TelegramService,
+    ) -> None:
+        """
+        Initialize the HomeKit service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+            homekit_config: HomekitConfig for accessory configuration.
+            conson_config: ConsonModuleListConfig for module configuration.
+            telegram_service: TelegramService for parsing telegrams.
+        """
+        self.logger = logging.getLogger(__name__)
+        self._conbus_protocol = conbus_protocol
+        self._homekit_config = homekit_config
+        self._conson_config = conson_config
+        self._telegram_service = telegram_service
+        self._connection_state = ConnectionState.DISCONNECTED
+        self._state_machine = ConnectionState.create_state_machine()
+
+        # Accessory states keyed by unique identifier (e.g., "A12_1")
+        self._accessory_states: Dict[str, AccessoryState] = {}
+
+        # Action key to accessory ID mapping
+        self._action_map: Dict[str, str] = {}
+
+        # Connect to protocol signals
+        self._connect_signals()
+
+        # Initialize accessory states from config
+        self._initialize_accessory_states()
+
+    def _initialize_accessory_states(self) -> None:
+        """Initialize accessory states from HomekitConfig and ConsonModuleListConfig."""
+        action_keys = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        action_index = 0
+        sort_order = 0
+
+        for room in self._homekit_config.bridge.rooms:
+            for accessory_name in room.accessories:
+                accessory_config = self._find_accessory_config(accessory_name)
+                if not accessory_config:
+                    self.logger.warning(
+                        f"Accessory config not found for {accessory_name}"
+                    )
+                    continue
+
+                module_config = self._conson_config.find_module(
+                    accessory_config.serial_number
+                )
+                if not module_config:
+                    self.logger.warning(
+                        f"Module config not found for {accessory_config.serial_number}"
+                    )
+                    continue
+
+                # Create unique identifier
+                accessory_id = (
+                    f"{module_config.name}_{accessory_config.output_number + 1}"
+                )
+
+                # Assign action key
+                action_key = (
+                    action_keys[action_index] if action_index < len(action_keys) else ""
+                )
+                action_index += 1
+                sort_order += 1
+
+                state = AccessoryState(
+                    room_name=room.name,
+                    accessory_name=accessory_config.description
+                    or accessory_config.name,
+                    action=action_key,
+                    output_state="?",
+                    dimming_state="",
+                    module_name=module_config.name,
+                    serial_number=accessory_config.serial_number,
+                    module_type=module_config.module_type,
+                    error_status="OK",
+                    output=accessory_config.output_number + 1,  # 1-based
+                    sort=sort_order,
+                    last_update=None,
+                    toggle_action=accessory_config.toggle_action,
+                )
+
+                self._accessory_states[accessory_id] = state
+                if action_key:
+                    self._action_map[action_key] = accessory_id
+
+    def _find_accessory_config(self, name: str) -> Optional[HomekitAccessoryConfig]:
+        """
+        Find accessory config by name.
+
+        Args:
+            name: Accessory name to find.
+
+        Returns:
+            HomekitAccessoryConfig if found, None otherwise.
+        """
+        for accessory in self._homekit_config.accessories:
+            if accessory.name == name:
+                return accessory
+        return None
+
+    def _connect_signals(self) -> None:
+        """Connect to protocol signals."""
+        self._conbus_protocol.on_connection_made.connect(self._on_connection_made)
+        self._conbus_protocol.on_connection_failed.connect(self._on_connection_failed)
+        self._conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
+        self._conbus_protocol.on_timeout.connect(self._on_timeout)
+        self._conbus_protocol.on_failed.connect(self._on_failed)
+
+    def _disconnect_signals(self) -> None:
+        """Disconnect from protocol signals."""
+        self._conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
+        self._conbus_protocol.on_connection_failed.disconnect(
+            self._on_connection_failed
+        )
+        self._conbus_protocol.on_telegram_received.disconnect(
+            self._on_telegram_received
+        )
+        self._conbus_protocol.on_timeout.disconnect(self._on_timeout)
+        self._conbus_protocol.on_failed.disconnect(self._on_failed)
+
+    @property
+    def connection_state(self) -> ConnectionState:
+        """
+        Get current connection state.
+
+        Returns:
+            Current connection state.
+        """
+        return self._connection_state
+
+    @property
+    def server_info(self) -> str:
+        """
+        Get server connection info (IP:port).
+
+        Returns:
+            Server address in format "IP:port".
+        """
+        return f"{self._conbus_protocol.cli_config.ip}:{self._conbus_protocol.cli_config.port}"
+
+    @property
+    def accessory_states(self) -> List[AccessoryState]:
+        """
+        Get all accessory states.
+
+        Returns:
+            List of all accessory states.
+        """
+        accessories = list(self._accessory_states.values())
+        # Sort modules by link_number
+        accessories.sort(key=lambda a: a.sort)
+        return accessories
+
+    def connect(self) -> None:
+        """Initiate connection to server."""
+        if not self._state_machine.can_transition("connect"):
+            self.logger.warning(
+                f"Cannot connect: current state is {self._connection_state.value}"
+            )
+            return
+
+        if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
+            self._connection_state = ConnectionState.CONNECTING
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connecting to {self.server_info}...")
+
+        self._conbus_protocol.connect()
+
+    def disconnect(self) -> None:
+        """Disconnect from server."""
+        if not self._state_machine.can_transition("disconnect"):
+            self.logger.warning(
+                f"Cannot disconnect: current state is {self._connection_state.value}"
+            )
+            return
+
+        if self._state_machine.transition(
+            "disconnecting", ConnectionState.DISCONNECTING
+        ):
+            self._connection_state = ConnectionState.DISCONNECTING
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit("Disconnecting...")
+
+        self._conbus_protocol.disconnect()
+
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self._connection_state = ConnectionState.DISCONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit("Disconnected")
+
+    def toggle_connection(self) -> None:
+        """
+        Toggle connection state between connected and disconnected.
+
+        Disconnects if currently connected or connecting. Connects if currently
+        disconnected or failed.
+        """
+        if self._connection_state in (
+            ConnectionState.CONNECTED,
+            ConnectionState.CONNECTING,
+        ):
+            self.disconnect()
+        else:
+            self.connect()
+
+    def toggle_accessory(self, action_key: str) -> bool:
+        """
+        Toggle accessory by action key.
+
+        Sends the toggle_action telegram for the accessory mapped to the given key.
+
+        Args:
+            action_key: Action key (a-z).
+
+        Returns:
+            True if toggle was sent, False otherwise.
+        """
+        accessory_id = self._action_map.get(action_key)
+        if not accessory_id:
+            return False
+
+        state = self._accessory_states.get(accessory_id)
+        if not state or not state.toggle_action:
+            self.logger.warning(f"No toggle_action for accessory {accessory_id}")
+            return False
+
+        self._conbus_protocol.send_raw_telegram(state.toggle_action)
+        self.on_status_message.emit(f"Toggling {state.accessory_name}")
+        return True
+
+    def refresh_all(self) -> None:
+        """
+        Refresh all module states.
+
+        Queries module_output_state datapoint for eligible modules (XP24, XP33LR,
+        XP33LED). Updates outputs column and last_update timestamp for each queried
+        module.
+        """
+        self.on_status_message.emit("Refreshing module states...")
+
+        # Eligible module types that support output state queries
+        eligible_types = {"XP24", "XP33LR", "XP33LED"}
+
+        # Track already queried serial numbers to avoid duplicates
+        queried_serials: set[str] = set()
+
+        for state in self._accessory_states.values():
+            if (
+                state.module_type in eligible_types
+                and state.serial_number not in queried_serials
+            ):
+                self._query_module_output_state(state.serial_number)
+                queried_serials.add(state.serial_number)
+                self.logger.debug(
+                    f"Querying output state for {state.module_name} ({state.module_type})"
+                )
+
+    def _query_module_output_state(self, serial_number: str) -> None:
+        """
+        Query module output state datapoint.
+
+        Args:
+            serial_number: Module serial number to query.
+        """
+        self._conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=str(DataPointType.MODULE_OUTPUT_STATE.value),
+        )
+
+    def _on_connection_made(self) -> None:
+        """Handle connection made event."""
+        if self._state_machine.transition("connected", ConnectionState.CONNECTED):
+            self._connection_state = ConnectionState.CONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connected to {self.server_info}")
+
+            # Emit initial accessory list
+            self.on_room_list_updated.emit(self.accessory_states)
+
+    def _on_connection_failed(self, failure: Exception) -> None:
+        """
+        Handle connection failed event.
+
+        Args:
+            failure: Exception that caused the failure.
+        """
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self._connection_state = ConnectionState.FAILED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connection failed: {failure}")
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """
+        Handle telegram received event.
+
+        Routes telegrams to appropriate handlers based on type.
+
+        Args:
+            event: Telegram received event.
+        """
+        if event.telegram_type == TelegramType.REPLY:
+            self._handle_reply_telegram(event)
+        elif event.telegram_type == TelegramType.EVENT:
+            self._handle_event_telegram(event)
+
+    def _handle_reply_telegram(self, event: TelegramReceivedEvent) -> None:
+        """
+        Handle reply telegram for datapoint queries.
+
+        Args:
+            event: Telegram received event.
+        """
+        serial_number = event.serial_number
+        if not serial_number:
+            return
+
+        # Parse the reply telegram
+        reply_telegram = self._telegram_service.parse_reply_telegram(event.frame)
+        if not reply_telegram:
+            return
+
+        # Check if this is a module output state response
+        if (
+            reply_telegram.system_function == SystemFunction.READ_DATAPOINT
+            and reply_telegram.datapoint_type == DataPointType.MODULE_OUTPUT_STATE
+        ):
+            self._update_outputs_from_reply(serial_number, reply_telegram.data_value)
+
+    def _update_outputs_from_reply(self, serial_number: str, data_value: str) -> None:
+        """
+        Update accessory outputs from module output state reply.
+
+        Args:
+            serial_number: Module serial number.
+            data_value: Output state data value from reply.
+        """
+        # Parse output state bits using TelegramOutputService
+        outputs = TelegramOutputService.format_output_state(data_value)
+        output_list = outputs.split() if outputs else []
+
+        # Update all accessories for this serial_number
+        for state in self._accessory_states.values():
+            if state.serial_number == serial_number:
+                output_index = state.output - 1  # Convert to 0-based
+
+                if output_index < len(output_list):
+                    is_on = output_list[output_index] == "1"
+                    state.output_state = "ON" if is_on else "OFF"
+
+                    # Update dimming state for dimmable modules
+                    if state.is_dimmable():
+                        state.dimming_state = "-" if not is_on else ""
+                else:
+                    state.output_state = "?"
+
+                state.last_update = datetime.now()
+                self.on_module_state_changed.emit(state)
+
+    def _handle_event_telegram(self, event: TelegramReceivedEvent) -> None:
+        """
+        Handle event telegram for output state changes.
+
+        Args:
+            event: Telegram received event.
+        """
+        event_telegram = self._telegram_service.parse_event_telegram(event.frame)
+        if not event_telegram:
+            return
+
+        # Determine output number based on module type
+        output_number = None
+
+        if event_telegram.module_type == ModuleTypeCode.XP24.value:
+            if 80 <= event_telegram.input_number <= 83:
+                output_number = event_telegram.input_number - 80
+            else:
+                return
+
+        elif event_telegram.module_type in (
+            ModuleTypeCode.XP33.value,
+            ModuleTypeCode.XP33LR.value,
+            ModuleTypeCode.XP33LED.value,
+        ):
+            if 80 <= event_telegram.input_number <= 82:
+                output_number = event_telegram.input_number - 80
+            else:
+                return
+        else:
+            return
+
+        # Find accessories matching link number and output
+        output_1_based = output_number + 1
+        for state in self._accessory_states.values():
+            module_config = self._conson_config.find_module(state.serial_number)
+            if not module_config:
+                continue
+
+            if (
+                module_config.link_number == event_telegram.link_number
+                and state.output == output_1_based
+            ):
+                # Update output state (M=ON, B=OFF)
+                is_on = event_telegram.is_button_press
+                state.output_state = "ON" if is_on else "OFF"
+
+                # Update dimming state for dimmable modules
+                if state.is_dimmable():
+                    state.dimming_state = "-" if not is_on else ""
+
+                state.last_update = datetime.now()
+                self.on_module_state_changed.emit(state)
+
+                self.logger.debug(
+                    f"Updated {state.accessory_name} to {'ON' if is_on else 'OFF'}"
+                )
+
+    def _on_timeout(self) -> None:
+        """Handle timeout event."""
+        self.on_status_message.emit("Waiting for action")
+
+    def _on_failed(self, failure: Exception) -> None:
+        """
+        Handle protocol failure event.
+
+        Args:
+            failure: Exception that caused the failure.
+        """
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self._connection_state = ConnectionState.FAILED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Protocol error: {failure}")
+
+    def cleanup(self) -> None:
+        """Clean up service resources."""
+        self._disconnect_signals()
+        self.logger.debug("HomekitService cleaned up")
+
+    def __enter__(self) -> "HomekitService":
+        """
+        Context manager entry.
+
+        Returns:
+            Self for context manager.
+        """
+        return self
+
+    def __exit__(self, _exc_type: object, _exc_val: object, _exc_tb: object) -> None:
+        """
+        Context manager exit.
+
+        Args:
+            _exc_type: Exception type.
+            _exc_val: Exception value.
+            _exc_tb: Exception traceback.
+        """
+        self.cleanup()

xp/services/term/state_monitor_service.py

@@ -299,7 +299,7 @@ class StateMonitorService:
 
     def _on_timeout(self) -> None:
         """Handle timeout event."""
-        self.on_status_message.emit("Connection timeout")
+        self.on_status_message.emit("Waiting for action")
 
     def _on_failed(self, failure: Exception) -> None:
         """

xp/term/homekit.py

@@ -0,0 +1,116 @@
+"""HomeKit TUI Application."""
+
+from pathlib import Path
+from typing import Any, Optional
+
+from textual.app import App, ComposeResult
+
+from xp.services.term.homekit_service import HomekitService
+from xp.term.widgets.room_list import RoomListWidget
+from xp.term.widgets.status_footer import StatusFooterWidget
+
+
+class HomekitApp(App[None]):
+    """
+    Textual app for HomeKit accessory monitoring.
+
+    Displays rooms and accessories with real-time state updates
+    and toggle control via action keys.
+
+    Attributes:
+        homekit_service: HomekitService for accessory state operations.
+        CSS_PATH: Path to CSS stylesheet file.
+        BINDINGS: Keyboard bindings for app actions.
+        TITLE: Application title displayed in header.
+        ENABLE_COMMAND_PALETTE: Disable Textual's command palette feature.
+    """
+
+    CSS_PATH = Path(__file__).parent / "homekit.tcss"
+    TITLE = "HomeKit"
+    ENABLE_COMMAND_PALETTE = False
+
+    BINDINGS = [
+        ("Q", "quit", "Quit"),
+        ("C", "toggle_connection", "Connect"),
+        ("r", "refresh_all", "Refresh"),
+    ]
+
+    def __init__(self, homekit_service: HomekitService) -> None:
+        """
+        Initialize the HomeKit app.
+
+        Args:
+            homekit_service: HomekitService for accessory state operations.
+        """
+        super().__init__()
+        self.homekit_service: HomekitService = homekit_service
+        self.room_list_widget: Optional[RoomListWidget] = None
+        self.footer_widget: Optional[StatusFooterWidget] = None
+
+    def compose(self) -> ComposeResult:
+        """
+        Compose the app layout with widgets.
+
+        Yields:
+            RoomListWidget and StatusFooterWidget.
+        """
+        self.room_list_widget = RoomListWidget(
+            service=self.homekit_service, id="room-list"
+        )
+        yield self.room_list_widget
+
+        self.footer_widget = StatusFooterWidget(
+            service=self.homekit_service, id="footer-container"
+        )
+        yield self.footer_widget
+
+    async def on_mount(self) -> None:
+        """
+        Initialize app after UI is mounted.
+
+        Delays connection by 0.5s to let UI render first. Sets up automatic screen
+        refresh every second to update elapsed times.
+        """
+        import asyncio
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        self.homekit_service.connect()
+
+        # Set up periodic refresh to update elapsed times
+        self.set_interval(1.0, self._refresh_last_update_column)
+
+    def _refresh_last_update_column(self) -> None:
+        """Refresh only the last_update column to show elapsed time."""
+        if self.room_list_widget:
+            self.room_list_widget.refresh_last_update_times()
+
+    def on_key(self, event: Any) -> None:
+        """
+        Handle key press events for action keys.
+
+        Intercepts a-z keys to toggle accessories.
+
+        Args:
+            event: Key press event.
+        """
+        key = event.key.lower()
+        if len(key) == 1 and "a" <= key <= "z":
+            if self.homekit_service.toggle_accessory(key):
+                event.prevent_default()
+
+    def action_toggle_connection(self) -> None:
+        """
+        Toggle connection on 'c' key press.
+
+        Connects if disconnected/failed, disconnects if connected/connecting.
+        """
+        self.homekit_service.toggle_connection()
+
+    def action_refresh_all(self) -> None:
+        """Refresh all module data on 'r' key press."""
+        self.homekit_service.refresh_all()
+
+    def on_unmount(self) -> None:
+        """Clean up service when app unmounts."""
+        self.homekit_service.cleanup()

xp/term/homekit.tcss

@@ -0,0 +1,86 @@
+/* HomeKit TUI Styling */
+
+/* Color overrides */
+$success: #00ff00;
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Room List Widget */
+RoomListWidget {
+    border: solid $success;
+    border-title-align: left;
+    width: 1fr;
+    height: 1fr;
+    background: $background;
+    padding: 1;
+}
+
+RoomListWidget:focus {
+    background: $background;
+    background-tint: transparent;
+}
+
+#rooms-table {
+    background: $background !important;
+    width: 100%;
+    height: 1fr;
+}
+
+#rooms-table:focus {
+    background: $background !important;
+    background-tint: transparent;
+}
+
+DataTable {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--header {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+DataTable:focus > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+/* Footer styling */
+#footer-container {
+    dock: bottom;
+    height: 1;
+    background: $background;
+}
+
+Footer {
+    width: auto;
+    background: $background;
+    color: $text;
+}
+
+#status-text {
+    dock: right;
+    width: auto;
+    padding: 0 3;
+    background: $background;
+    color: $text;
+    text-align: right;
+}
+
+#status-line {
+    dock: right;
+    width: auto;
+    padding: 0 1;
+    background: $background;
+    color: $text;
+    text-align: right;
+}

xp/term/widgets/room_list.py

@@ -0,0 +1,232 @@
+"""Room List Widget for displaying HomeKit accessories table."""
+
+from datetime import datetime
+from typing import Any, List, Optional
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+
+from xp.models.term.accessory_state import AccessoryState
+from xp.services.term.homekit_service import HomekitService
+
+
+class RoomListWidget(Static):
+    """
+    Widget displaying HomeKit accessories in a data table.
+
+    Shows room/accessory hierarchy with real-time state updates from HomekitService.
+    Table displays: room/accessory, action, state, dim, module, serial, type, status, output, updated.
+
+    Attributes:
+        service: HomekitService for accessory state updates.
+        table: DataTable widget displaying accessory information.
+    """
+
+    def __init__(
+        self,
+        service: Optional[HomekitService] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize the Room List widget.
+
+        Args:
+            service: Optional HomekitService for signal subscriptions.
+            args: Additional positional arguments for Static.
+            kwargs: Additional keyword arguments for Static.
+        """
+        super().__init__(*args, **kwargs)
+        self.service = service
+        self.table: Optional[DataTable] = None
+        self._row_keys: dict[str, Any] = {}  # Map accessory_id to row key
+        self._current_room: str = ""
+
+    def compose(self) -> ComposeResult:
+        """
+        Compose the widget layout.
+
+        Yields:
+            DataTable widget.
+        """
+        self.table = DataTable(id="rooms-table", cursor_type="row")
+        yield self.table
+
+    def on_mount(self) -> None:
+        """Initialize table and subscribe to service signals when widget mounts."""
+        self.border_title = "Rooms"
+
+        if self.table:
+            self.table.add_column("room / accessory", key="name", width=35)
+            self.table.add_column("action", key="action", width=8)
+            self.table.add_column("state", key="state", width=7)
+            self.table.add_column("dim", key="dim", width=6)
+            self.table.add_column("module", key="module", width=8)
+            self.table.add_column("serial", key="serial", width=12)
+            self.table.add_column("type", key="type", width=10)
+            self.table.add_column("status", key="status", width=8)
+            self.table.add_column("output", key="output", width=7)
+            self.table.add_column("updated", key="updated", width=10)
+
+        if self.service:
+            self.service.on_room_list_updated.connect(self.update_accessory_list)
+            self.service.on_module_state_changed.connect(self.update_accessory_state)
+
+    def on_unmount(self) -> None:
+        """Unsubscribe from service signals when widget unmounts."""
+        if self.service:
+            self.service.on_room_list_updated.disconnect(self.update_accessory_list)
+            self.service.on_module_state_changed.disconnect(self.update_accessory_state)
+
+    def update_accessory_list(self, accessory_states: List[AccessoryState]) -> None:
+        """
+        Update entire accessory list from service.
+
+        Clears existing table and repopulates with all accessories grouped by room.
+
+        Args:
+            accessory_states: List of all accessory states.
+        """
+        if not self.table:
+            return
+
+        self.table.clear()
+        self._row_keys.clear()
+        self._current_room = ""
+
+        for state in accessory_states:
+            # Add room header row if new room
+            if state.room_name != self._current_room:
+                self._current_room = state.room_name
+                self.table.add_row()
+                self.table.add_row(Text(state.room_name, style="bold"))
+                self.table.add_row()
+
+            self._add_accessory_row(state)
+
+    def update_accessory_state(self, state: AccessoryState) -> None:
+        """
+        Update individual accessory state in table.
+
+        Updates existing row if accessory exists, otherwise adds new row.
+
+        Args:
+            state: Updated accessory state.
+        """
+        if not self.table:
+            return
+
+        accessory_id = f"{state.module_name}_{state.output}"
+
+        if accessory_id in self._row_keys:
+            row_key = self._row_keys[accessory_id]
+            self.table.update_cell(
+                row_key, "state", Text(state.output_state, justify="center")
+            )
+            self.table.update_cell(
+                row_key, "dim", Text(self._format_dim(state), justify="center")
+            )
+            self.table.update_cell(row_key, "status", state.error_status)
+            self.table.update_cell(
+                row_key,
+                "updated",
+                Text(self._format_last_update(state.last_update), justify="center"),
+            )
+        else:
+            self._add_accessory_row(state)
+
+    def _add_accessory_row(self, state: AccessoryState) -> None:
+        """
+        Add an accessory row to the table.
+
+        Args:
+            state: Accessory state to add.
+        """
+        if not self.table:
+            return
+
+        accessory_id = f"{state.module_name}_{state.output}"
+        row_key = self.table.add_row(
+            f"  - {state.accessory_name}",
+            Text(state.action, justify="center"),
+            Text(state.output_state, justify="center"),
+            Text(self._format_dim(state), justify="center"),
+            state.module_name,
+            state.serial_number,
+            state.module_type,
+            state.error_status,
+            Text(str(state.output), justify="right"),
+            Text(self._format_last_update(state.last_update), justify="center"),
+        )
+        self._row_keys[accessory_id] = row_key
+
+    def _format_dim(self, state: AccessoryState) -> str:
+        """
+        Format dimming state for display.
+
+        Shows percentage if dimmable and ON, "-" if dimmable and OFF, empty otherwise.
+
+        Args:
+            state: Accessory state.
+
+        Returns:
+            Formatted dimming string.
+        """
+        if not state.is_dimmable():
+            return ""
+        if state.output_state == "OFF":
+            return "-"
+        return state.dimming_state or ""
+
+    def _format_last_update(self, last_update: Optional[datetime]) -> str:
+        """
+        Format last update timestamp for display.
+
+        Shows elapsed time in HH:MM:SS format or "--:--:--" if never updated.
+
+        Args:
+            last_update: Last update timestamp or None.
+
+        Returns:
+            Formatted time string.
+        """
+        if last_update is None:
+            return "--:--:--"
+
+        elapsed = datetime.now() - last_update
+        total_seconds = int(elapsed.total_seconds())
+
+        hours = total_seconds // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
+
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def refresh_last_update_times(self) -> None:
+        """
+        Refresh only the last_update column for all accessories.
+
+        Updates the elapsed time display without querying the service.
+        """
+        if not self.table or not self.service:
+            return
+
+        for accessory_id, row_key in self._row_keys.items():
+            state = next(
+                (
+                    s
+                    for s in self.service.accessory_states
+                    if f"{s.module_name}_{s.output}" == accessory_id
+                ),
+                None,
+            )
+            if state:
+                self.table.update_cell(
+                    row_key,
+                    "updated",
+                    Text(
+                        self._format_last_update(state.last_update),
+                        justify="center",
+                    ),
+                )

xp/term/widgets/status_footer.py

@@ -7,6 +7,7 @@ from textual.containers import Horizontal
 from textual.widgets import Footer, Static
 
 from xp.models.term.connection_state import ConnectionState
+from xp.services.term.homekit_service import HomekitService
 from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 from xp.services.term.state_monitor_service import StateMonitorService
 
@@ -19,14 +20,16 @@ class StatusFooterWidget(Horizontal):
     the current connection state. Subscribes directly to service signals.
 
     Attributes:
-        service: ProtocolMonitorService or StateMonitorService for connection state and status updates.
+        service: ProtocolMonitorService, StateMonitorService, or HomekitService for connection state and status updates.
         status_widget: Static widget displaying colored status dot.
         status_text_widget: Static widget displaying status messages.
     """
 
     def __init__(
         self,
-        service: Optional[Union[ProtocolMonitorService, StateMonitorService]] = None,
+        service: Optional[
+            Union[ProtocolMonitorService, StateMonitorService, HomekitService]
+        ] = None,
         *args: Any,
         **kwargs: Any,
     ) -> None:
@@ -34,7 +37,7 @@ class StatusFooterWidget(Horizontal):
         Initialize the Status Footer widget.
 
         Args:
-            service: Optional ProtocolMonitorService or StateMonitorService for signal subscriptions.
+            service: Optional ProtocolMonitorService, StateMonitorService, or HomekitService for signal subscriptions.
             args: Additional positional arguments for Horizontal.
             kwargs: Additional keyword arguments for Horizontal.
         """

xp/utils/dependencies.py

@@ -77,8 +77,10 @@ from xp.services.telegram.telegram_discover_service import TelegramDiscoverServi
 from xp.services.telegram.telegram_link_number_service import LinkNumberService
 from xp.services.telegram.telegram_output_service import TelegramOutputService
 from xp.services.telegram.telegram_service import TelegramService
+from xp.services.term.homekit_service import HomekitService
 from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 from xp.services.term.state_monitor_service import StateMonitorService
+from xp.term.homekit import HomekitApp
 from xp.term.protocol import ProtocolMonitorApp
 from xp.term.state import StateMonitorApp
 from xp.utils.logging import LoggerService
@@ -265,6 +267,25 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            HomekitService,
+            factory=lambda: HomekitService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
+                homekit_config=self.container.resolve(HomekitConfig),
+                conson_config=self.container.resolve(ConsonModuleListConfig),
+                telegram_service=self.container.resolve(TelegramService),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            HomekitApp,
+            factory=lambda: HomekitApp(
+                homekit_service=self.container.resolve(HomekitService)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusEventRawService,
             factory=lambda: ConbusEventRawService(