conson-xp 1.19.0__py3-none-any.whl → 1.20.0__py3-none-any.whl

{conson_xp-1.19.0.dist-info → conson_xp-1.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.19.0
+Version: 1.20.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -48,6 +48,7 @@ Requires-Dist: punq>=0.7.0
 Requires-Dist: twisted>=25.5.0
 Requires-Dist: bubus>=1.5.6
 Requires-Dist: psygnal>=0.15.0
+Requires-Dist: textual>=1.0.0
 Description-Content-Type: text/markdown
 
 # 🔌 XP Protocol Communication Tool
@@ -398,6 +399,10 @@ xp telegram parse
 xp telegram validate
 xp telegram version
 
+
+xp term
+xp term protocol
+
 <!-- END CLI HELP -->
 ```
 </details>

{conson_xp-1.19.0.dist-info → conson_xp-1.20.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-conson_xp-1.19.0.dist-info/METADATA,sha256=-VtLm8xePli914-pZt50momoSfpi6BARWkhyla_IiYA,9527
-conson_xp-1.19.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-conson_xp-1.19.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.19.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=xqDwwDvx5lt_aNSuHKANp3WXQCP4x1a9OzyP8CniQnE,181
+conson_xp-1.20.0.dist-info/METADATA,sha256=vAvQzvNII8d7oxEEbo1rSLyswX3lROWxh7cERQ-y3_Y,9584
+conson_xp-1.20.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.20.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.20.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=T304nC2FLiJmOCyBS3xq0x0Bb4Nv_XAMMRN4xZtqUec,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
-xp/cli/commands/__init__.py,sha256=wvo9Z5viwpjvO2432E7YP5HWjLLiW1IFpyXLc5puuGY,4766
+xp/cli/commands/__init__.py,sha256=noh8fdZAWq-ihJEboP8WugbIgq4LJ3jUWMRA7720xWE,4909
 xp/cli/commands/conbus/__init__.py,sha256=gE3K5OEoXkkZX8UOc2v3nreQQzwkOQi7n0VZ-Z2juXA,495
 xp/cli/commands/conbus/conbus.py,sha256=eqdY8ArapvD08Z4p7Xk7eh4z0dESHuMSw7PKtwTJRYU,3021
 xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=cdjLV9cnm7teEOlu5Jf1MS_aL7lNy8KiDIyjCQa5Nzw,7138
@@ -22,7 +22,7 @@ xp/cli/commands/conbus/conbus_modulenumber_commands.py,sha256=L7-6y3rDllOjQ9g6Bk
 xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=fb9MQ4O04H0Dinpt7vSF5GtfntTZHelQ5TuUmSBbCTg,2899
 xp/cli/commands/conbus/conbus_output_commands.py,sha256=zdRVbHzVhMbZpG2x5WXtujc3wKTsoQUV4IgkVIbJbCc,5019
 xp/cli/commands/conbus/conbus_raw_commands.py,sha256=8BKUarwvHgz-sxML7n99YVsb8B1HJNExjQpRsuY_tQw,1829
-xp/cli/commands/conbus/conbus_receive_commands.py,sha256=WdH7fYcbjweIGxD2uxrTRD8lJzViMSVdsaHTvSDJNCQ,1757
+xp/cli/commands/conbus/conbus_receive_commands.py,sha256=2lZP0a3dte3Q_Vp28xYkqLAoxnvArS9SsQdeedOHcQw,1788
 xp/cli/commands/conbus/conbus_scan_commands.py,sha256=JfXucOwOadvLEKT_fW9fwvqWKHaEODOojLjnO8JV_00,1730
 xp/cli/commands/file_commands.py,sha256=GV102X7FRZDUNKLlzvSsIGcoXAaofOzmjCp3HUpE9lw,5532
 xp/cli/commands/homekit/__init__.py,sha256=qqwY8ulxTx1S74Mzpb6EKjBLT6fWTNdf9PQ3HKuERKY,50
@@ -40,7 +40,10 @@ xp/cli/commands/telegram/telegram_discover_commands.py,sha256=0UArJinw1eWFbee5EG
 xp/cli/commands/telegram/telegram_linknumber_commands.py,sha256=7j0-E5Moqqga4NrKDch82C6glaFDFMQn5_3hMwie7BQ,2511
 xp/cli/commands/telegram/telegram_parse_commands.py,sha256=_OYOso1hS4f_ox96qlkYL2SuFnmimpAvqqdYlLzX9yo,2232
 xp/cli/commands/telegram/telegram_version_commands.py,sha256=WQyx1-B9yJ8V9WrFyBpOvULJ-jq12GoZZDDoRbM7eyw,1553
-xp/cli/main.py,sha256=3TY4wZoKMK8kQBgOn0WshTsag4J4ofoGoGPgg12wueM,2810
+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=3qwiGlEEgMIz5AG7fq5U_9SZSWSDfrKwYggHbiv5kRk,738
+xp/cli/main.py,sha256=ap5jU0DrSnrCKDKqGXcz9N-sngZodyyN-5ReWE8Fh1s,1817
 xp/cli/utils/__init__.py,sha256=gTGIj60Uai0iE7sr9_TtEpl04fD7krtTzbbigXUsUVU,46
 xp/cli/utils/click_tree.py,sha256=ilmM2IMa_c-TqUMsv2alrZXuS0BNhvVlrBlSfyN8lzM,1670
 xp/cli/utils/datapoint_type_choice.py,sha256=HcydhlqxZ7YyorEeTjFGkypF2JnYNPvOzkl1rhZ93Fc,1666
@@ -63,7 +66,7 @@ xp/models/conbus/__init__.py,sha256=VIusMWQdBtlwDgj7oSj06wQkklihTp4oWFShvP_JUgA,
 xp/models/conbus/conbus.py,sha256=mZQzKPfrdttT-qUnYUSyrEYyc_eHs8z301E5ejeiyvk,2689
 xp/models/conbus/conbus_autoreport.py,sha256=lKotDfxRBb7h2Z1d4qI3KhhLJhFDwKqLbSdG5Makm8Y,2289
 xp/models/conbus/conbus_blink.py,sha256=XEAPtA-O76ulX6Zh1oYzsWF6L4css6xJBuUTwNcDQKc,2911
-xp/models/conbus/conbus_client_config.py,sha256=fWPmHM-OVUzSASKq667JzP7e9_Qp9ZUyYcTaijWkVlY,1484
+xp/models/conbus/conbus_client_config.py,sha256=MliIffoP0Ku1FxpNznMJPBrpdz9OVKZcs9IJ4g1Z3dE,1485
 xp/models/conbus/conbus_connection_status.py,sha256=iGbmtBaAMwV6UD7XG3H3tnB0fl2MR8rJhpjrLH2KjsE,1097
 xp/models/conbus/conbus_custom.py,sha256=8H2sPR6_LIlksuOvL7-8bPkzAJLR0rpYiiwfYYFVjEo,1965
 xp/models/conbus/conbus_datapoint.py,sha256=4ncR-vB2lRzRBAA30rYn8eguyTxsZoOKrrXtjGmPpWg,3396
@@ -72,6 +75,7 @@ xp/models/conbus/conbus_event_list.py,sha256=M8aHRHVB5VDIjqMzjO86xlERt7AMdfjIjt1
 xp/models/conbus/conbus_event_raw.py,sha256=i5gc7z-0yeunWOZ4rw3AiBt4MANezmhBQKjOOQk3oDc,1567
 xp/models/conbus/conbus_lightlevel.py,sha256=GQGhzrCBEJROosNHInXIzBy6MD2AskEIMoFEGgZ60-0,1695
 xp/models/conbus/conbus_linknumber.py,sha256=uFzKzfB06oIzZEKCb5X2JEI80JjMPFuYglsT1W1k8j4,1815
+xp/models/conbus/conbus_logger_config.py,sha256=cFWjWn8tc_hPPI2kQAib_Akddar8O-3zkoj6wLBsdUo,3328
 xp/models/conbus/conbus_output.py,sha256=q7QKsD_CWT7YOk-V3otKWD1VM7qThrSLIUOunntMrMc,1953
 xp/models/conbus/conbus_raw.py,sha256=xqvYao6IE1SXum7JBgZpSuWXm9x_QZquS9N_3_r0Hjs,1460
 xp/models/conbus/conbus_receive.py,sha256=-1u1qK-texfKCNZV-GYf_9KyLtJdIrx7HuZsKzu26Ow,1322
@@ -125,7 +129,7 @@ xp/services/conbus/conbus_event_list_service.py,sha256=0xyXXNU44epN5bFkU6oiZMyhx
 xp/services/conbus/conbus_event_raw_service.py,sha256=FZFu-LNLInrTKTpiGLyootozvyIF5Si5FMrxNk2ALD0,7000
 xp/services/conbus/conbus_output_service.py,sha256=mHFOAPx2zo0TStZ3pokp6v94AQjIamcwZDeg5YH_-eo,7240
 xp/services/conbus/conbus_raw_service.py,sha256=4yZLLTIAOxpgByUTWZXw1ihGa6Xtl98ckj9T7VfprDI,4335
-xp/services/conbus/conbus_receive_service.py,sha256=frXrS0OyKKvYYQTWdma21Kd0BKw5aSuHn3ZXTTqOaj0,3953
+xp/services/conbus/conbus_receive_service.py,sha256=38lAZ0tc2AjBfcqI7qje-ES_QHiHZ3Ayybrp1ZC8ceM,5412
 xp/services/conbus/conbus_scan_service.py,sha256=tHJ5qaxcNXxAZb2D2F1v6IrzydfxjJOYllM6Txt1eBE,5176
 xp/services/conbus/write_config_service.py,sha256=6feNdixI_Nli4MRLe15nea-7gTEXMUwZIvTqv_1OqHI,7157
 xp/services/homekit/__init__.py,sha256=xAMKmln_AmEFdOOJGKWYi96seRlKDQpKx3-hm7XbdIo,36
@@ -145,7 +149,7 @@ xp/services/homekit/homekit_service.py,sha256=0lW-hg40ETco3gDBEYkR_sX-UIYsLSKCD4
 xp/services/log_file_service.py,sha256=fvPcZQj8XOKUA-4ep5R8n0PelvwvRlTLlVxvIWM5KR4,10506
 xp/services/module_type_service.py,sha256=xWhr1EAZMykL5uNWHWdpa5T8yNruGKH43XRTOS8GwZg,7477
 xp/services/protocol/__init__.py,sha256=qRufBmqRKGzpuzZ5bxBbmwf510TT00Ke8s5HcWGnqRY,818
-xp/services/protocol/conbus_event_protocol.py,sha256=6ihDsWj5k08Hb3OpYd3xBZCS-yPa16FfWtFSxJknIwo,12852
+xp/services/protocol/conbus_event_protocol.py,sha256=48KCTkJLDHV1ijVXHf0TraY663Nk3_dEV3lkZpvduDo,13671
 xp/services/protocol/conbus_protocol.py,sha256=JO7yLkD_ohPT0ETjnAIx4CGpZyobf4LdbuozM_43btE,10276
 xp/services/protocol/protocol_factory.py,sha256=PmjN9AtW9sxNo3voqUiNgQA-pTvX1RW4XXFlHKfFr5Q,2470
 xp/services/protocol/telegram_protocol.py,sha256=Ki5DrXsKxiaqLcdP9WWUuhUI7cPu2DfwyZkh-Gv9Lb8,9496
@@ -169,10 +173,16 @@ xp/services/telegram/telegram_link_number_service.py,sha256=1_c-_QCRPTHYn3BmMElr
 xp/services/telegram/telegram_output_service.py,sha256=UaUv_14fR8o5K2PxQBXrCzx-Hohnk-gzbev_oLw_Clc,10799
 xp/services/telegram/telegram_service.py,sha256=XrP1CPi0ckxoKBaNwLA6lo-TogWxXgmXDOsU4Xl8BlY,13237
 xp/services/telegram/telegram_version_service.py,sha256=M5HdOTsLdcwo122FP-jW6R740ktLrtKf2TiMDVz23h8,10528
+xp/tui/__init__.py,sha256=Xg2DhBeI3xQJLfc7_BPWI1por-rUXemyer5OtOt9Cus,51
+xp/tui/app.py,sha256=NBCdFCgftckey5TgxDFn-SeOLSFggapshIwKDcLM5QY,2227
+xp/tui/protocol.tcss,sha256=njMgFgz4oD4Qjw3dyoX1SfCuvlfGg6QrrkZ2COFZ0yM,768
+xp/tui/widgets/__init__.py,sha256=Ewiza9u6k5K50zZRIMD7jjOHY1IvGhoX1ViwlqhdGms,27
+xp/tui/widgets/protocol_log.py,sha256=0twJHiOTNcOOw3eQtYkjb1x37adecypPPPT1fuWb2q4,11541
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=PYe-RvmfGBRXWnLKX62nXGMDFN7PQW3deoGCkIVEG4s,21274
+xp/utils/dependencies.py,sha256=ECS6p0eXzocM5INLwJeckHXn_Dim18uOjXTJ29qQvkQ,22001
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
+xp/utils/logging.py,sha256=5ol2JrnFtjs9QtBYW4KeKYzcFzCxbCn8BsIq3aIF4H4,3395
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.19.0.dist-info/RECORD,,
+conson_xp-1.20.0.dist-info/RECORD,,

{conson_xp-1.19.0.dist-info → conson_xp-1.20.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.5)
+Generator: pdm-backend (2.4.6)
 Root-Is-Purelib: true
 Tag: py3-none-any

xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.19.0"
+__version__ = "1.20.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

xp/cli/commands/__init__.py

@@ -86,6 +86,8 @@ from xp.cli.commands.telegram.telegram_parse_commands import (
     validate_telegram,
 )
 from xp.cli.commands.telegram.telegram_version_commands import generate_version_request
+from xp.cli.commands.term.term import term
+from xp.cli.commands.term.term_commands import protocol_monitor
 
 __all__ = [
     # Main command groups (conbus excluded to avoid module shadowing)
@@ -109,7 +111,9 @@ __all__ = [
     "checksum",
     "homekit",
     "homekit_start",
+    "term",
     # Individual command functions
+    "protocol_monitor",
     "conbus_download_msactiontable",
     "conbus_download_actiontable",
     "send_blink_on_telegram",

xp/cli/commands/conbus/conbus_receive_commands.py

@@ -56,4 +56,5 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
         ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
     )
     with service:
-        service.start(progress, on_finish, timeout)
+        service.init(progress, on_finish, timeout)
+        service.start_reactor()

xp/cli/commands/term/__init__.py

@@ -0,0 +1,5 @@
+"""Term CLI commands package for TUI interfaces."""
+
+from xp.cli.commands.term.term import term
+
+__all__ = ["term"]

xp/cli/commands/term/term.py

@@ -0,0 +1,12 @@
+"""Term CLI group definition for TUI commands."""
+
+import click
+from click_help_colors import HelpColorsGroup
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def term() -> None:
+    """Terminal UI commands for interactive monitoring and control."""
+    pass

xp/cli/commands/term/term_commands.py

@@ -0,0 +1,31 @@
+"""Term protocol CLI command for TUI monitoring."""
+
+import click
+from click import Context
+
+from xp.cli.commands.term.term import term
+
+
+@term.command("protocol")
+@click.pass_context
+def protocol_monitor(ctx: Context) -> None:
+    r"""Start TUI for real-time protocol monitoring.
+
+    Displays live RX/TX telegram stream from Conbus server
+    in an interactive terminal interface.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp term protocol
+    """
+    from xp.tui.app import ProtocolMonitorApp
+
+    # Resolve ServiceContainer from context
+    container = ctx.obj.get("container").get_container()
+
+    # Initialize and run Textual app
+    app = ProtocolMonitorApp(container=container)
+    app.run()

xp/cli/main.py

@@ -1,7 +1,5 @@
 """XP CLI tool entry point with modular command structure."""
 
-import logging
-
 import click
 from click_help_colors import HelpColorsGroup
 
@@ -16,8 +14,10 @@ from xp.cli.commands.server.server_commands import server
 
 # Import command groups from modular structure
 from xp.cli.commands.telegram.telegram_parse_commands import telegram
+from xp.cli.commands.term.term import term
 from xp.cli.utils.click_tree import add_tree_command
 from xp.utils.dependencies import ServiceContainer
+from xp.utils.logging import LoggerService
 
 
 @click.group(
@@ -31,44 +31,15 @@ def cli(ctx: click.Context) -> None:
     Args:
         ctx: Click context object for passing state between commands.
     """
-    # Configure logging with thread information
-    log_format = "%(asctime)s - [%(threadName)s-%(thread)d] - %(levelname)s - %(name)s - %(message)s"
-    date_format = "%H:%M:%S"
-
-    # Force format on root logger and all handlers
-    formatter = logging.Formatter(log_format, datefmt=date_format)
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
-
-    # Update all existing handlers or create new one
-    if root_logger.handlers:
-        for handler in root_logger.handlers:
-            handler.setFormatter(formatter)
-    else:
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        root_logger.addHandler(handler)
-
-    # Suppress pyhap.hap_protocol logs
-
-    # bubus
-    logging.getLogger("bubus").setLevel(logging.WARNING)
-
-    # xp
-    logging.getLogger("xp").setLevel(logging.DEBUG)
-    logging.getLogger("xp.services.homekit").setLevel(logging.DEBUG)
-
-    # pyhap
-    logging.getLogger("pyhap").setLevel(logging.WARNING)
-    logging.getLogger("pyhap.hap_handler").setLevel(logging.WARNING)
-    logging.getLogger("pyhap.hap_protocol").setLevel(logging.WARNING)
-    # logging.getLogger('pyhap.accessory_driver').setLevel(logging.WARNING)
+    container = ServiceContainer()
+    logger_config = container.get_container().resolve(LoggerService)
+    logger_config.setup()
 
     # Initialize the service container and store it in the context
     ctx.ensure_object(dict)
     # Only create a new container if one wasn't provided (e.g., for testing)
     if "container" not in ctx.obj:
-        ctx.obj["container"] = ServiceContainer()
+        ctx.obj["container"] = container
 
 
 # Register all command groups
@@ -79,6 +50,7 @@ cli.add_command(module)
 cli.add_command(file)
 cli.add_command(server)
 cli.add_command(reverse_proxy)
+cli.add_command(term)
 
 # Add the tree command
 add_tree_command(cli)

xp/models/conbus/conbus_client_config.py

@@ -49,6 +49,7 @@ class ConbusClientConfig(BaseModel):
         except FileNotFoundError:
             logger.error(f"File {file_path} does not exist, loading default")
             return cls()
+
         except yaml.YAMLError:
             logger.error(f"File {file_path} is not valid")
             # Return default config if YAML parsing fails

xp/models/conbus/conbus_logger_config.py

@@ -0,0 +1,107 @@
+"""Logger configuration models for XP application."""
+
+import logging
+from pathlib import Path
+from typing import Dict, Union
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+
+class LoggingConfig(BaseModel):
+    """Logging configuration.
+
+    Attributes:
+        path: log folder.
+        default_level: DEBUG, WARNING, INFO, ERROR, CRITICAL.
+        levels: Per-module log level overrides.
+        max_bytes: Maximum size in bytes before rotating (default: 1MB).
+        backup_count: Number of backup files to keep (default: 365).
+        log_format: Log message format string.
+        date_format: Date format string for timestamps.
+    """
+
+    path: str = "log"
+    default_level: str = "DEBUG"
+    levels: Dict[str, int] = {
+        "xp": logging.DEBUG,
+        "xp.services.homekit": logging.WARNING,
+        "xp.services.server": logging.WARNING,
+    }
+    max_bytes: int = 1024 * 1024  # 1MB
+    backup_count: int = 365
+    log_format: str = (
+        "%(asctime)s - [%(threadName)s-%(thread)d] - %(levelname)s - %(name)s - %(message)s"
+    )
+    date_format: str = "%H:%M:%S"
+
+    @field_validator("levels", mode="before")
+    @classmethod
+    def convert_level_names(cls, v: Dict[str, Union[str, int]]) -> Dict[str, int]:
+        """Convert string level names to numeric values.
+
+        Args:
+            v: Dictionary with string or int log levels.
+
+        Returns:
+            Dictionary with numeric log levels.
+
+        Raises:
+            ValueError: If an invalid log level name is provided.
+        """
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL,
+        }
+
+        result = {}
+        for module, level in v.items():
+            if isinstance(level, str):
+                level_upper = level.upper()
+                if level_upper not in level_map:
+                    raise ValueError(
+                        f"Invalid log level '{level}' for module '{module}'. "
+                        f"Must be one of: {', '.join(level_map.keys())}"
+                    )
+                result[module] = level_map[level_upper]
+            else:
+                result[module] = level
+        return result
+
+
+class ConbusLoggerConfig(BaseModel):
+    """Logging configuration.
+
+    Attributes:
+        log: LoggingConfig instance for logging settings.
+    """
+
+    log: LoggingConfig = Field(default_factory=LoggingConfig)
+
+    @classmethod
+    def from_yaml(cls, file_path: str) -> "ConbusLoggerConfig":
+        """Load configuration from YAML file.
+
+        Args:
+            file_path: Path to the YAML configuration file.
+
+        Returns:
+            ConbusClientConfig instance loaded from file or default config.
+        """
+        logger = logging.getLogger(__name__)
+        try:
+            with Path(file_path).open("r") as file:
+                data = yaml.safe_load(file)
+                return cls(**data)
+
+        except FileNotFoundError:
+            logger.error(f"File {file_path} does not exist, loading default")
+            return cls()
+
+        except yaml.YAMLError:
+            logger.error(f"File {file_path} is not valid")
+            # Return default config if YAML parsing fails
+            return cls()

xp/services/conbus/conbus_receive_service.py

@@ -1,51 +1,55 @@
 """Conbus Receive Service for receiving telegrams from Conbus servers.
 
-This service uses ConbusProtocol to provide receive-only functionality,
+This service uses ConbusEventProtocol to provide receive-only functionality,
 allowing clients to receive waiting event telegrams using empty telegram sends.
 """
 
+import asyncio
 import logging
-from typing import Callable, Optional
+from typing import Any, Callable, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_receive import ConbusReceiveResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 
 
-class ConbusReceiveService(ConbusProtocol):
+class ConbusReceiveService:
     """
     Service for receiving telegrams from Conbus servers.
 
-    Uses ConbusProtocol to provide receive-only functionality
+    Uses ConbusEventProtocol to provide receive-only functionality
     for collecting waiting event telegrams from the server.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
     """
 
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus receive service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusEventProtocol instance.
         """
-        super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[Callable[[ConbusReceiveResponse], None]] = None
         self.receive_response: ConbusReceiveResponse = ConbusReceiveResponse(
             success=True
         )
 
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        """Handle connection established event."""
+    def connection_made(self) -> None:
+        """Handle connection made event."""
         self.logger.debug("Connection established, waiting for telegrams.")
 
     def telegram_sent(self, telegram_sent: str) -> None:
@@ -70,17 +74,13 @@ class ConbusReceiveService(ConbusProtocol):
             self.receive_response.received_telegrams = []
         self.receive_response.received_telegrams.append(telegram_received.frame)
 
-    def timeout(self) -> bool:
-        """Handle timeout event to stop receiving.
-
-        Returns:
-            False to stop the reactor.
-        """
-        self.logger.info("Receive stopped after: %ss", self.timeout_seconds)
+    def timeout(self) -> None:
+        """Handle timeout event to stop receiving."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info("Receive stopped after: %ss", timeout)
         self.receive_response.success = True
         if self.finish_callback:
             self.finish_callback(self.receive_response)
-        return False
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -94,22 +94,50 @@ class ConbusReceiveService(ConbusProtocol):
         if self.finish_callback:
             self.finish_callback(self.receive_response)
 
-    def start(
+    def init(
         self,
         progress_callback: Callable[[str], None],
         finish_callback: Callable[[ConbusReceiveResponse], None],
         timeout_seconds: Optional[float] = None,
+        event_loop: Optional[asyncio.AbstractEventLoop] = None,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Setup callbacks and timeout for receiving telegrams.
 
         Args:
             progress_callback: Callback for each received telegram.
             finish_callback: Callback when receiving completes.
             timeout_seconds: Optional timeout in seconds.
+            event_loop: Optional event loop to use for async operations.
         """
         self.logger.info("Starting receive")
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback
         self.finish_callback = finish_callback
-        self.start_reactor()
+
+        if event_loop:
+            self.conbus_protocol.set_event_loop(event_loop)
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def __enter__(self) -> "ConbusReceiveService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.receive_response = ConbusReceiveResponse(success=True)
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)

xp/services/protocol/conbus_event_protocol.py

@@ -3,6 +3,7 @@
 This module implements the Twisted protocol for Conbus communication.
 """
 
+import asyncio
 import logging
 from queue import SimpleQueue
 from random import randint
@@ -302,14 +303,21 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self.logger.info("Stopping reactor")
             self._reactor.stop()
 
-    def start_reactor(self) -> None:
-        """Start the reactor if it's running."""
-        # Connect to TCP server
+    def connect(self) -> None:
+        """Connect to TCP server."""
         self.logger.info(
             f"Connecting to TCP server {self.cli_config.ip}:{self.cli_config.port}"
         )
         self._reactor.connectTCP(self.cli_config.ip, self.cli_config.port, self)
 
+    def disconnect(self) -> None:
+        """Disconnect from TCP server."""
+        self.logger.info("Disconnecting TCP server")
+        self._reactor.disconnectAll()
+
+    def start_reactor(self) -> None:
+        """Start the reactor if it's running."""
+        self.connect()
         # Run the reactor (which now uses asyncio underneath)
         self.logger.info("Starting reactor event loop.")
         self._reactor.run()
@@ -340,6 +348,23 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         later = randint(10, 80) / 100
         self.call_later(later, self.process_telegram_queue)
 
+    def set_event_loop(self, event_loop: asyncio.AbstractEventLoop) -> None:
+        """Change the event loop.
+
+        Args:
+            event_loop: the event loop instance.
+        """
+        reactor = self._reactor
+        if hasattr(reactor, "_asyncioEventloop"):
+            reactor._asyncioEventloop = event_loop
+
+        # Set reactor to running state
+        if not reactor.running:
+            reactor.running = True
+            if hasattr(reactor, "startRunning"):
+                reactor.startRunning()
+            self.logger.info("Set reactor to running state")
+
     def __enter__(self) -> "ConbusEventProtocol":
         """Enter context manager.
 

xp/tui/__init__.py

@@ -0,0 +1 @@
+"""TUI (Terminal User Interface) module for XP."""

xp/tui/app.py

@@ -0,0 +1,72 @@
+"""Protocol Monitor TUI Application."""
+
+from pathlib import Path
+from typing import Any, Optional
+
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header
+
+from xp.tui.widgets.protocol_log import ProtocolLogWidget
+
+
+class ProtocolMonitorApp(App[None]):
+    """Textual app for real-time protocol monitoring.
+
+    Displays live RX/TX telegram stream from Conbus server in an interactive
+    terminal interface with keyboard shortcuts for control.
+
+    Attributes:
+        container: ServiceContainer for dependency injection.
+        CSS_PATH: Path to CSS stylesheet file.
+        BINDINGS: Keyboard bindings for app actions.
+        TITLE: Application title displayed in header.
+    """
+
+    CSS_PATH = Path(__file__).parent / "protocol.tcss"
+    TITLE = "Protocol Monitor"
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("c", "connect", "Connect"),
+        ("d", "disconnect", "Disconnect"),
+        ("1", "discover", "Discover"),
+    ]
+
+    def __init__(self, container: Any) -> None:
+        """Initialize the Protocol Monitor app.
+
+        Args:
+            container: ServiceContainer for resolving services.
+        """
+        super().__init__()
+        self.container = container
+        self.protocol_widget: Optional[ProtocolLogWidget] = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout with widgets.
+
+        Yields:
+            Header, ProtocolLogWidget, and Footer widgets.
+        """
+        yield Header()
+        self.protocol_widget = ProtocolLogWidget(container=self.container)
+        yield self.protocol_widget
+        yield Footer()
+
+    def action_discover(self) -> None:
+        """Send discover telegram on 'D' key press.
+
+        Sends predefined discover telegram <S0000000000F01D00FA> to the bus.
+        """
+        if self.protocol_widget:
+            self.protocol_widget.send_discover()
+
+    def action_connect(self) -> None:
+        """Connect protocol on 'c' key press."""
+        if self.protocol_widget:
+            self.protocol_widget.connect()
+
+    def action_disconnect(self) -> None:
+        """Disconnect protocol on 'd' key press."""
+        if self.protocol_widget:
+            self.protocol_widget.disconnect()

xp/tui/protocol.tcss

@@ -0,0 +1,50 @@
+/* Protocol Monitor TUI Styling */
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Protocol Log Widget */
+ProtocolLogWidget {
+    border: solid $primary;
+    height: 1fr;
+    background: $surface;
+}
+
+ProtocolLogWidget > .connection-status {
+    color: $text;
+    text-align: center;
+    padding: 1;
+}
+
+ProtocolLogWidget > .connection-status.connecting {
+    color: $warning;
+}
+
+ProtocolLogWidget > .connection-status.connected {
+    color: $success;
+}
+
+ProtocolLogWidget > .connection-status.failed {
+    color: $error;
+}
+
+/* Message display styling */
+.message-tx {
+    color: $success;
+}
+
+.message-rx {
+    color: $success;
+}
+
+.message-frame {
+    color: $text-muted;
+}
+
+/* Footer styling */
+Footer {
+    background: $panel;
+    color: $text;
+}

xp/tui/widgets/__init__.py

@@ -0,0 +1 @@
+"""TUI widgets package."""

xp/tui/widgets/protocol_log.py

@@ -0,0 +1,312 @@
+"""Protocol Log Widget for displaying telegram stream."""
+
+import asyncio
+import logging
+from enum import Enum
+from typing import Any, Optional
+
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import RichLog
+
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.conbus.conbus_receive_service import ConbusReceiveService
+from xp.services.protocol import ConbusEventProtocol
+
+
+class ConnectionState(str, Enum):
+    """Connection state enumeration.
+
+    Attributes:
+        DISCONNECTED: Not connected to server.
+        CONNECTING: Connection in progress.
+        CONNECTED: Successfully connected.
+        FAILED: Connection failed.
+    """
+
+    DISCONNECTED = "DISCONNECTED"
+    CONNECTING = "CONNECTING"
+    CONNECTED = "CONNECTED"
+    FAILED = "FAILED"
+
+
+class ProtocolLogWidget(Widget):
+    """Widget for displaying protocol telegram stream.
+
+    Connects to Conbus server via ConbusReceiveService and displays
+    live RX/TX telegram stream with color-coded direction markers.
+
+    Attributes:
+        container: ServiceContainer for dependency injection.
+        connection_state: Current connection state (reactive).
+        protocol: Reference to ConbusEventProtocol (prevents duplicate connections).
+        service: ConbusReceiveService instance.
+        logger: Logger instance for this widget.
+        log_widget: RichLog widget for displaying messages.
+    """
+
+    connection_state = reactive(ConnectionState.DISCONNECTED)
+
+    def __init__(self, container: Any) -> None:
+        """Initialize the Protocol Log widget.
+
+        Args:
+            container: ServiceContainer for resolving services.
+        """
+        super().__init__()
+        self.container = container
+        self.protocol: Optional[ConbusEventProtocol] = None
+        self.service: Optional[ConbusReceiveService] = None
+        self.logger = logging.getLogger(__name__)
+        self.log_widget: Optional[RichLog] = None
+
+    def compose(self) -> Any:
+        """Compose the widget layout.
+
+        Yields:
+            RichLog widget for message display.
+        """
+        self.log_widget = RichLog(highlight=True, markup=True)
+        yield self.log_widget
+
+    async def on_mount(self) -> None:
+        """Initialize connection when widget mounts.
+
+        Delays connection by 0.5s to let UI render first.
+        Resolves ConbusReceiveService and connects signals.
+        """
+        # Resolve service from container (singleton)
+        self.service = self.container.resolve(ConbusReceiveService)
+        self.protocol = self.service.conbus_protocol
+
+        # Connect psygnal signals
+        self.protocol.on_connection_made.connect(self._on_connection_made)
+        self.protocol.on_telegram_received.connect(self._on_telegram_received)
+        self.protocol.on_telegram_sent.connect(self._on_telegram_sent)
+        self.protocol.on_timeout.connect(self._on_timeout)
+        self.protocol.on_failed.connect(self._on_failed)
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        await self._start_connection_async()
+
+    async def _start_connection_async(self) -> None:
+        """Start TCP connection to Conbus server (async).
+
+        Guards against duplicate connections and sets up protocol signals.
+        Integrates Twisted reactor with Textual's asyncio loop cleanly.
+        """
+        # Guard against duplicate connections (race condition)
+        if self.service is None:
+            self.logger.error("Service not initialized")
+            return
+
+        if self.protocol is None:
+            self.logger.error("Protocol not initialized")
+            return
+
+        try:
+            # Set state to connecting
+            self.connection_state = ConnectionState.CONNECTING
+            if self.log_widget:
+                self.log_widget.write("[yellow]Connecting to Conbus server...[/yellow]")
+
+            # Store protocol reference
+            self.logger.info(f"Protocol object: {self.protocol}")
+            self.logger.info(f"Reactor object: {self.protocol._reactor}")
+            self.logger.info(f"Reactor running: {self.protocol._reactor.running}")
+
+            # Setup service callbacks
+            def progress_callback(telegram: str) -> None:
+                """Handle progress updates for telegram reception.
+
+                Args:
+                    telegram: Received telegram string.
+                """
+                pass
+
+            def finish_callback(response: Any) -> None:
+                """Handle completion of telegram reception.
+
+                Args:
+                    response: Response object from telegram reception.
+                """
+                pass
+
+            # Get the currently running asyncio event loop (Textual's loop)
+            event_loop = asyncio.get_running_loop()
+            self.logger.info(f"Current running loop: {event_loop}")
+            self.logger.info(f"Loop is running: {event_loop.is_running()}")
+
+            self.service.init(
+                progress_callback=progress_callback,
+                finish_callback=finish_callback,
+                timeout_seconds=None,  # Continuous monitoring
+                event_loop=event_loop,
+            )
+
+            reactor = self.service.conbus_protocol._reactor
+            # Schedule the connection on the running asyncio loop
+            # This ensures connectTCP is called in the context of the running loop
+
+            def do_connect() -> None:
+                """Execute TCP connection in event loop context."""
+                self.logger.info("Executing connectTCP in event loop callback")
+                if self.protocol is not None:
+                    reactor.connectTCP(
+                        self.protocol.cli_config.ip,
+                        self.protocol.cli_config.port,
+                        self.protocol,
+                    )
+
+            event_loop.call_soon(do_connect)
+            self.logger.info("Scheduled connectTCP on running loop")
+
+            if self.log_widget:
+                self.log_widget.write(
+                    f"[dim]→ {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}[/dim]"
+                )
+
+            # Wait for connection to establish
+            await asyncio.sleep(1.0)
+            self.logger.info(f"After 1s - transport: {self.protocol.transport}")
+
+        except Exception as e:
+            self.logger.error(f"Connection failed: {e}")
+            self.connection_state = ConnectionState.FAILED
+            if self.log_widget:
+                self.log_widget.write(f"[red]Connection error: {e}[/red]")
+            # Exit app after brief delay
+            self.set_timer(2.0, self.app.exit)
+
+    def _start_connection(self) -> None:
+        """Start connection (sync wrapper for async method)."""
+        # Use run_worker to run async method from sync context
+        self.run_worker(self._start_connection_async(), exclusive=True)
+
+    def _on_connection_made(self) -> None:
+        """Handle connection established signal.
+
+        Sets state to CONNECTED and displays success message.
+        """
+        self.connection_state = ConnectionState.CONNECTED
+        if self.log_widget:
+            self.log_widget.write("[green]Connected to Conbus server[/green]")
+            self.log_widget.write("[dim]---[/dim]")
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received signal.
+
+        Args:
+            event: Telegram received event with frame data.
+        """
+        if self.log_widget:
+            # Display [RX] in green, frame in gray
+            self.log_widget.write(f"[green]\\[RX][/green] [dim]{event.frame}[/dim]")
+
+    def _on_telegram_sent(self, telegram: str) -> None:
+        """Handle telegram sent signal.
+
+        Args:
+            telegram: Sent telegram string.
+        """
+        if self.log_widget:
+            # Display [TX] in green, frame in gray
+            self.log_widget.write(f"[green]\\[TX][/green] [dim]{telegram}[/dim]")
+
+    def _on_timeout(self) -> None:
+        """Handle timeout signal.
+
+        Logs timeout but continues monitoring (no action needed).
+        """
+        self.logger.debug("Timeout occurred (continuous monitoring)")
+
+    def _on_failed(self, error: str) -> None:
+        """Handle connection failed signal.
+
+        Args:
+            error: Error message describing the failure.
+        """
+        self.connection_state = ConnectionState.FAILED
+        self.logger.error(f"Connection failed: {error}")
+
+        if self.log_widget:
+            self.log_widget.write(f"[red]Connection failed: {error}[/red]")
+
+        # Exit app after brief delay to show error
+        self.set_timer(2.0, self.app.exit)
+
+    def connect(self) -> None:
+        """Connect to Conbus server."""
+        self._start_connection()
+
+    def disconnect(self) -> None:
+        """Disconnect from Conbus server."""
+        if self.protocol:
+            self.protocol.disconnect()
+
+    def send_discover(self) -> None:
+        """Send discover telegram.
+
+        Sends predefined discover telegram <S0000000000F01D00FA> to the bus.
+        Called when user presses 'd' key.
+        """
+        if self.protocol is None:
+            self.logger.warning("Cannot send discover: not connected")
+            if self.log_widget:
+                self.log_widget.write(
+                    "[yellow]Not connected, cannot send discover[/yellow]"
+                )
+            return
+
+        try:
+            # Send discover telegram
+            # Note: The telegram includes framing <>, but protocol may add it
+            # Check if protocol expects with or without brackets
+            from xp.models.telegram.system_function import SystemFunction
+            from xp.models.telegram.telegram_type import TelegramType
+
+            # Send discover: S 0000000000 F01 D00
+            self.protocol.send_telegram(
+                telegram_type=TelegramType.SYSTEM,
+                serial_number="0000000000",
+                system_function=SystemFunction.DISCOVERY,
+                data_value="00",
+            )
+
+            if self.log_widget:
+                self.log_widget.write("[yellow]Discover telegram sent[/yellow]")
+
+        except Exception as e:
+            self.logger.error(f"Failed to send discover: {e}")
+            if self.log_widget:
+                self.log_widget.write(f"[red]Failed to send discover: {e}[/red]")
+
+    def on_unmount(self) -> None:
+        """Clean up when widget unmounts.
+
+        Disconnects signals and closes transport connection.
+        """
+        if self.protocol is not None:
+            try:
+                # Disconnect all signals
+                self.protocol.on_connection_made.disconnect(self._on_connection_made)
+                self.protocol.on_telegram_received.disconnect(
+                    self._on_telegram_received
+                )
+                self.protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
+                self.protocol.on_timeout.disconnect(self._on_timeout)
+                self.protocol.on_failed.disconnect(self._on_failed)
+
+                # Close transport if connected
+                if self.protocol.transport:
+                    self.protocol.disconnect()
+
+                # Reset protocol reference
+                self.protocol = None
+
+                # Set state to disconnected
+                self.connection_state = ConnectionState.DISCONNECTED
+
+            except Exception as e:
+                self.logger.error(f"Error during cleanup: {e}")

xp/utils/dependencies.py

@@ -7,6 +7,7 @@ from twisted.internet.interfaces import IConnector
 from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_logger_config import ConbusLoggerConfig
 from xp.models.homekit.homekit_config import HomekitConfig
 from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
 from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
@@ -72,6 +73,7 @@ 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.utils.logging import LoggerService
 
 asyncioreactor.install()
 from twisted.internet import reactor  # noqa: E402
@@ -87,7 +89,8 @@ class ServiceContainer:
 
     def __init__(
         self,
-        config_path: str = "cli.yml",
+        client_config_path: str = "cli.yml",
+        logger_config_path: str = "logger.yml",
         homekit_config_path: str = "homekit.yml",
         conson_config_path: str = "conson.yml",
         server_port: int = 10001,
@@ -97,14 +100,16 @@ class ServiceContainer:
         Initialize the service container.
 
         Args:
-            config_path: Path to the Conbus CLI configuration file
+            client_config_path: Path to the Conbus CLI configuration file
+            logger_config_path: Path to the Conbus Loggerr configuration file
             homekit_config_path: Path to the HomeKit configuration file
             conson_config_path: Path to the Conson configuration file
             server_port: Port for the server service
             reverse_proxy_port: Port for the reverse proxy service
         """
         self.container = punq.Container()
-        self._config_path = config_path
+        self._client_config_path = client_config_path
+        self._logger_config_path = logger_config_path
         self._homekit_config_path = homekit_config_path
         self._conson_config_path = conson_config_path
         self._server_port = server_port
@@ -117,7 +122,13 @@ class ServiceContainer:
         # ConbusClientConfig
         self.container.register(
             ConbusClientConfig,
-            factory=lambda: ConbusClientConfig.from_yaml(self._config_path),
+            factory=lambda: ConbusClientConfig.from_yaml(self._client_config_path),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ConbusLoggerConfig,
+            factory=lambda: ConbusLoggerConfig.from_yaml(self._logger_config_path),
             scope=punq.Scope.singleton,
         )
 
@@ -332,8 +343,7 @@ class ServiceContainer:
         self.container.register(
             ConbusReceiveService,
             factory=lambda: ConbusReceiveService(
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
+                conbus_protocol=self.container.resolve(ConbusEventProtocol)
             ),
             scope=punq.Scope.singleton,
         )
@@ -387,6 +397,15 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        # Logging
+        self.container.register(
+            LoggerService,
+            factory=lambda: LoggerService(
+                logger_config=self.container.resolve(ConbusLoggerConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         # Module type services layer
         self.container.register(ModuleTypeService, scope=punq.Scope.singleton)
 

xp/utils/logging.py

@@ -0,0 +1,91 @@
+"""Logging service for XP application."""
+
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+from xp.models.conbus.conbus_logger_config import ConbusLoggerConfig
+
+
+class LoggerService:
+    """Service for managing logging configuration and setup."""
+
+    def __init__(self, logger_config: ConbusLoggerConfig):
+        """Initialize LoggerService with configuration.
+
+        Args:
+            logger_config: Logger configuration object.
+        """
+        self.logging_config = logger_config.log
+        self.logger = logging.getLogger(__name__)
+
+    def setup(self) -> None:
+        """Setup console and file logging with configured levels."""
+        # Setup file logging for term app
+        self.setup_console_logging(
+            self.logging_config.log_format, self.logging_config.date_format
+        )
+        self.setup_file_logging(
+            self.logging_config.log_format, self.logging_config.date_format
+        )
+
+        for module in self.logging_config.levels.keys():
+            logging.getLogger(module).setLevel(self.logging_config.levels[module])
+
+    def setup_console_logging(self, log_format: str, date_format: str) -> None:
+        """Setup console logging with specified format.
+
+        Args:
+            log_format: Log message format string.
+            date_format: Date format string for log timestamps.
+        """
+        # Force format on root logger and all handlers
+        formatter = logging.Formatter(log_format, datefmt=date_format)
+        root_logger = logging.getLogger()
+
+        # Set log level from CLI argument
+        numeric_level = getattr(logging, self.logging_config.default_level.upper())
+        root_logger.setLevel(numeric_level)
+
+        # Update all existing handlers or create new one
+        if root_logger.handlers:
+            for handler in root_logger.handlers:
+                handler.setFormatter(formatter)
+        else:
+            handler = logging.StreamHandler()
+            handler.setFormatter(formatter)
+            root_logger.addHandler(handler)
+
+    def setup_file_logging(self, log_format: str, date_format: str) -> None:
+        """Setup file logging with rotation for term application.
+
+        Args:
+            log_format: Log message format string.
+            date_format: Date format string for log timestamps.
+        """
+        log_path = Path(self.logging_config.path)
+        log_level = self.logging_config.default_level
+
+        try:
+            # Create log directory if it doesn't exist
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Create rotating file handler
+            file_handler = RotatingFileHandler(
+                log_path,
+                maxBytes=self.logging_config.max_bytes,
+                backupCount=self.logging_config.backup_count,
+            )
+
+            # Configure formatter to match console format
+            formatter = logging.Formatter(log_format, datefmt=date_format)
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(log_level)
+
+            # Attach to root logger
+            root_logger = logging.getLogger()
+            root_logger.addHandler(file_handler)
+
+        except (OSError, PermissionError) as e:
+            self.logger.warning(f"Failed to setup file logging at {log_path}: {e}")
+            self.logger.warning("Continuing without file logging")