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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.20.0
+Version: 1.21.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

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

@@ -1,8 +1,8 @@
-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
+conson_xp-1.21.0.dist-info/METADATA,sha256=HK1EyLvZ5dYaq4J30bnPy8dCvOHt7Zg7eZEI_6yjAbk,9584
+conson_xp-1.21.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.21.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.21.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=XRUlxeaLq3T5GvQqiQm4B3VDGuqGInrFa511pFvemqI,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
 xp/cli/commands/__init__.py,sha256=noh8fdZAWq-ihJEboP8WugbIgq4LJ3jUWMRA7720xWE,4909
@@ -42,7 +42,7 @@ xp/cli/commands/telegram/telegram_parse_commands.py,sha256=_OYOso1hS4f_ox96qlkYL
 xp/cli/commands/telegram/telegram_version_commands.py,sha256=WQyx1-B9yJ8V9WrFyBpOvULJ-jq12GoZZDDoRbM7eyw,1553
 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/commands/term/term_commands.py,sha256=5LwxOp1oHqki3iWPHXm6enPCF4De6uDg5N1QDVxjROs,739
 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
@@ -104,6 +104,8 @@ xp/models/telegram/system_telegram.py,sha256=9FNQ4Mf47mRK7wGrTg2GzziVsrEWCE5ZkZp
 xp/models/telegram/telegram.py,sha256=IJUxHX6ftLcET9C1pjvLhUO5Db5JO6W7rUItzdEW30I,842
 xp/models/telegram/telegram_type.py,sha256=GhqKP63oNMyh2tIvCPcsC5RFp4s4JjhmEqCLCC-8XMk,423
 xp/models/telegram/timeparam_type.py,sha256=Ar8xvSfPmOAgR2g2Je0FgvP01SL7bPvZn5_HrVDpmJM,1137
+xp/models/term/__init__.py,sha256=c1AMtVitYk80o9K_zWjYNzZYpFDASqM8S1Djm1PD4Qo,192
+xp/models/term/protocol_keys_config.py,sha256=CTujcfI2_NOeltjvHy_cnsHzxLSVsGFXieMZlD-zj0Q,1204
 xp/models/write_config_type.py,sha256=T2RaO52RpzoJ4782uMHE-fX7Ymx3CaIQAEwByydXq1M,881
 xp/services/__init__.py,sha256=W9YZyrkh7vm--ZHhAXNQiOYQs5yhhmUHXP5I0Lf1XBg,782
 xp/services/actiontable/__init__.py,sha256=z6js4EuJ6xKHaseTEhuEvKo1tr9K1XyQiruReJtBiPY,26
@@ -149,7 +151,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=48KCTkJLDHV1ijVXHf0TraY663Nk3_dEV3lkZpvduDo,13671
+xp/services/protocol/conbus_event_protocol.py,sha256=t_ovcLbwXays-y8u-EqFpDSfo2Xc_BNl3jAj9PqxRwg,13885
 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
@@ -173,16 +175,18 @@ 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/term/__init__.py,sha256=Xg2DhBeI3xQJLfc7_BPWI1por-rUXemyer5OtOt9Cus,51
+xp/term/app.py,sha256=vrC5VJbw1tlCvKnLR0n9NvGWaJx44yz0gG6k3--BaNk,5652
+xp/term/protocol.tcss,sha256=biaIv6X-bmD1tbXENFUNsXOF8ABkuoRAUgeSDqwudtQ,2126
+xp/term/protocol.yml,sha256=vPtTsMdasWiruj8iqqQX4f4ZtQdJ5wA39IJ-et3qiZc,2110
+xp/term/widgets/__init__.py,sha256=Ewiza9u6k5K50zZRIMD7jjOHY1IvGhoX1ViwlqhdGms,27
+xp/term/widgets/protocol_log.py,sha256=yuSfc61azgQmWQxLvBcmVik3cJAW1Hocj2Sk8qr3hSg,14343
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
 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/logging.py,sha256=rZDXwlBrYK8A6MPq5StsMNpgsRowzJXM6fvROPwJdGM,3750
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
+xp/utils/state_machine.py,sha256=Oe2sLwCh9z_vr1tF6X0ZRGTeuckRQAGzmef7xc9CNdc,2413
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.20.0.dist-info/RECORD,,
+conson_xp-1.21.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/term/term_commands.py

@@ -21,7 +21,7 @@ def protocol_monitor(ctx: Context) -> None:
         \b
         xp term protocol
     """
-    from xp.tui.app import ProtocolMonitorApp
+    from xp.term.app import ProtocolMonitorApp
 
     # Resolve ServiceContainer from context
     container = ctx.obj.get("container").get_container()

xp/models/term/__init__.py

@@ -0,0 +1,11 @@
+"""Terminal UI models."""
+
+from xp.models.term.protocol_keys_config import (
+    ProtocolKeyConfig,
+    ProtocolKeysConfig,
+)
+
+__all__ = [
+    "ProtocolKeyConfig",
+    "ProtocolKeysConfig",
+]

xp/models/term/protocol_keys_config.py

@@ -0,0 +1,45 @@
+"""Protocol keys configuration model."""
+
+from pathlib import Path
+from typing import Dict
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ProtocolKeyConfig(BaseModel):
+    """Configuration for a single protocol key.
+
+    Attributes:
+        name: Human-readable command name.
+        telegrams: List of raw telegram strings to send (without angle brackets).
+    """
+
+    name: str = Field(..., description="Human-readable command name")
+    telegrams: list[str] = Field(..., description="List of raw telegram strings")
+
+
+class ProtocolKeysConfig(BaseModel):
+    """Protocol keys configuration.
+
+    Attributes:
+        protocol: Dictionary mapping key to protocol configuration.
+    """
+
+    protocol: Dict[str, ProtocolKeyConfig] = Field(
+        default_factory=dict, description="Protocol key mappings"
+    )
+
+    @classmethod
+    def from_yaml(cls, config_path: Path) -> "ProtocolKeysConfig":
+        """Load protocol keys from YAML file.
+
+        Args:
+            config_path: Path to YAML configuration file.
+
+        Returns:
+            ProtocolKeysConfig instance.
+        """
+        with config_path.open("r") as f:
+            data = yaml.safe_load(f)
+        return cls(**data)

xp/services/protocol/conbus_event_protocol.py

@@ -209,6 +209,14 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             f"F{system_function.value}"
             f"D{data_value}"
         )
+        self.send_raw_telegram(payload)
+
+    def send_raw_telegram(self, payload: str) -> None:
+        """Send telegram with specified parameters.
+
+        Args:
+            payload: Telegram to send.
+        """
         self.telegram_queue.put_nowait(payload.encode())
         self.call_later(0.0, self.start_queue_manager)
 

xp/term/app.py

@@ -0,0 +1,158 @@
+"""Protocol Monitor TUI Application."""
+
+from pathlib import Path
+from typing import Any, Optional
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import DataTable, Footer, Static
+
+from xp.models.term import ProtocolKeysConfig
+from xp.term.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.
+        ENABLE_COMMAND_PALETTE: Disable Textual's command palette feature.
+    """
+
+    CSS_PATH = Path(__file__).parent / "protocol.tcss"
+    TITLE = "Protocol Monitor"
+    ENABLE_COMMAND_PALETTE = False
+
+    BINDINGS = [
+        ("Q", "quit", "Quit"),
+        ("C", "toggle_connection", "Connect"),
+        ("R", "reset", "Reset"),
+        ("0-9,a-q", "protocol_keys", "Keys"),
+    ]
+
+    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
+        self.status_widget: Optional[Static] = None
+        self.status_text_widget: Optional[Static] = None
+        self.help_table: Optional[DataTable] = None
+        self.protocol_keys = self._load_protocol_keys()
+
+    def _load_protocol_keys(self) -> ProtocolKeysConfig:
+        """Load protocol keys from YAML config file.
+
+        Returns:
+            ProtocolKeysConfig instance.
+        """
+        config_path = Path(__file__).parent / "protocol.yml"
+        return ProtocolKeysConfig.from_yaml(config_path)
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout with widgets.
+
+        Yields:
+            ProtocolLogWidget and Footer widgets.
+        """
+        with Horizontal(id="main-container"):
+            self.protocol_widget = ProtocolLogWidget(container=self.container)
+            yield self.protocol_widget
+
+            # Help menu (hidden by default)
+            help_container = Vertical(id="help-menu")
+            help_container.border_title = "Help menu"
+            help_container.can_focus = False
+            with help_container:
+                self.help_table = DataTable(id="help-table", show_header=False)
+                self.help_table.can_focus = False
+                yield self.help_table
+
+        with Horizontal(id="footer-container"):
+            yield Footer()
+            self.status_widget = Static("○", id="status-line")
+            yield self.status_widget
+
+    def action_toggle_connection(self) -> None:
+        """Toggle connection on 'c' key press.
+
+        Connects if disconnected/failed, disconnects if connected/connecting.
+        """
+        if self.protocol_widget:
+            from xp.term.widgets.protocol_log import ConnectionState
+
+            state = self.protocol_widget.connection_state
+            if state in (ConnectionState.CONNECTED, ConnectionState.CONNECTING):
+                self.protocol_widget.disconnect()
+            else:
+                self.protocol_widget.connect()
+
+    def action_reset(self) -> None:
+        """Reset and clear protocol widget on 'r' key press."""
+        if self.protocol_widget:
+            self.protocol_widget.clear_log()
+
+    def on_key(self, event: Any) -> None:
+        """Handle key press events for protocol keys.
+
+        Args:
+            event: Key press event from Textual.
+        """
+        if event.key in self.protocol_keys.protocol and self.protocol_widget:
+            key_config = self.protocol_keys.protocol[event.key]
+            for telegram in key_config.telegrams:
+                self.protocol_widget.send_telegram(key_config.name, telegram)
+
+    def on_mount(self) -> None:
+        """Set up status line updates when app mounts."""
+        if self.protocol_widget:
+            self.protocol_widget.watch(
+                self.protocol_widget,
+                "connection_state",
+                self._update_status,
+            )
+
+        # Initialize help table
+        if self.help_table:
+            self.help_table.add_columns("Key", "Command")
+            for key, config in self.protocol_keys.protocol.items():
+                self.help_table.add_row(key, config.name)
+
+    def _update_status(self, state: Any) -> None:
+        """Update status line with connection state.
+
+        Args:
+            state: Current connection state.
+        """
+        if self.status_widget:
+            # Map states to colored dots
+            status_map = {
+                "CONNECTED": "[green]●[/green]",
+                "CONNECTING": "[yellow]●[/yellow]",
+                "DISCONNECTING": "[yellow]●[/yellow]",
+                "FAILED": "[red]●[/red]",
+                "DISCONNECTED": "○",
+            }
+            dot = status_map.get(state.value, "○")
+            self.status_widget.update(dot)
+
+    def on_protocol_log_widget_status_message_changed(
+        self, message: ProtocolLogWidget.StatusMessageChanged
+    ) -> None:
+        """Handle status message changes from protocol widget.
+
+        Args:
+            message: Message containing the status text.
+        """
+        if self.status_text_widget:
+            self.status_text_widget.update(message.message)

xp/term/protocol.tcss

@@ -0,0 +1,135 @@
+/* Protocol Monitor TUI Styling */
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Protocol Log Widget */
+ProtocolLogWidget {
+    border: solid $success;
+    width: 1fr;
+    height: 1fr;
+    background: $background;
+    padding: 1;
+}
+
+ProtocolLogWidget > RichLog {
+    background: $background !important;
+    scrollbar-background: $background;
+}
+
+ProtocolLogWidget > RichLog:focus {
+    background: $background !important;
+    background-tint: transparent;
+}
+
+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;
+}
+
+/* Main container */
+#main-container {
+    height: 1fr;
+}
+
+/* Help menu styling */
+#help-menu {
+    width: 35;
+    height: 1fr;
+    background: $background;
+    border: solid $success;
+    padding: 1;
+}
+
+#help-menu:focus {
+    border: solid $success;
+}
+
+#help-title {
+    color: $success;
+    text-align: center;
+    text-style: bold;
+    margin-bottom: 1;
+}
+
+#help-table {
+    background: $background;
+    height: auto;
+    color: $success;
+}
+
+DataTable {
+    background: $background;
+}
+
+DataTable > .datatable--header {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--cursor {
+    background: $background;
+}
+
+DataTable:focus > .datatable--cursor {
+    background: $background;
+}
+
+/* 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 1;
+    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/protocol.yml

@@ -0,0 +1,139 @@
+protocol:
+  "1":
+    name: "Discover"
+    telegrams:
+      - S0000000000F01D00
+  "2":
+    name: "Error Code"
+    telegrams:
+      - S0020044966F02D10
+  "3":
+    name: "Module Type"
+    telegrams:
+      - S0020044966F02D00
+  "4":
+    name: "Auto Report"
+    telegrams:
+      - S0020044966F02D21
+  "5":
+    name: "Link Number"
+    telegrams:
+      - S0020044966F02D04
+  "6":
+    name: "Blink On"
+    telegrams:
+      - S0020044966F01D01
+  "7":
+    name: "Blink Off"
+    telegrams:
+      - S0020044966F01D00
+  "8":
+    name: "Output 1 On"
+    telegrams:
+      - S0020044966F02101
+  "9":
+    name: "Output 1 Off"
+    telegrams:
+      - S0020044966F02100
+  "0":
+    name: "Output State"
+    telegrams:
+      - S0020044966F02D09
+  "a":
+    name: "Module State"
+    telegrams:
+      - S0020044966F02D09
+  "b":
+    name: "All Off"
+    telegrams:
+      - E02L00I00M
+      - E02L00I00B
+  "c":
+    name: "All On"
+    telegrams:
+      - E02L00I08M
+      - E02L00I08B
+
+  "d":
+    name: "All 1 On"
+    telegrams:
+      - E02L01I08M
+      - E02L01I08B
+
+  "e":
+    name: "All 1 Off"
+    telegrams:
+      - E02L01I00M
+      - E02L01I00B
+
+  "f":
+    name: "All 2 On"
+    telegrams:
+      - E02L02I08M
+      - E02L02I08B
+
+  "g":
+    name: "All 2 Off"
+    telegrams:
+      - E02L02I00M
+      - E02L02I00B
+
+  "h":
+    name: "All 3 On"
+    telegrams:
+      - E02L03I08M
+      - E02L03I08B
+
+  "i":
+    name: "All 3 Off"
+    telegrams:
+      - E02L03I00M
+      - E02L03I00B
+
+  "j":
+    name: "All 4 On"
+    telegrams:
+      - E02L04I08M
+      - E02L04I08B
+
+  "k":
+    name: "All 4 Off"
+    telegrams:
+      - E02L04I00M
+      - E02L04I00B
+
+  "l":
+    name: "All 5 On"
+    telegrams:
+      - E02L05I08M
+      - E02L05I08B
+
+  "m":
+    name: "All 5 Off"
+    telegrams:
+      - E02L05I00M
+      - E02L05I00B
+
+  "n":
+    name: "All 6 On"
+    telegrams:
+      - E02L06I08M
+      - E02L06I08B
+
+  "o":
+    name: "All 6 Off"
+    telegrams:
+      - E02L06I00M
+      - E02L06I00B
+
+  "p":
+    name: "All 7 On"
+    telegrams:
+      - E02L07I08M
+      - E02L07I08B
+
+  "q":
+    name: "All 7 Off"
+    telegrams:
+      - E02L07I00M
+      - E02L07I00B

xp/{tui → term}/widgets/protocol_log.py

@@ -5,6 +5,7 @@ import logging
 from enum import Enum
 from typing import Any, Optional
 
+from textual.message import Message
 from textual.reactive import reactive
 from textual.widget import Widget
 from textual.widgets import RichLog
@@ -12,24 +13,62 @@ 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
+from xp.utils.state_machine import StateMachine
 
 
 class ConnectionState(str, Enum):
     """Connection state enumeration.
 
     Attributes:
+        DISCONNECTING: Disconnecting to server.
         DISCONNECTED: Not connected to server.
         CONNECTING: Connection in progress.
         CONNECTED: Successfully connected.
         FAILED: Connection failed.
     """
 
+    DISCONNECTING = "DISCONNECTING"
     DISCONNECTED = "DISCONNECTED"
     CONNECTING = "CONNECTING"
     CONNECTED = "CONNECTED"
     FAILED = "FAILED"
 
 
+def create_connection_state_machine() -> StateMachine:
+    """Create and configure state machine for connection management.
+
+    Returns:
+        Configured StateMachine with connection state transitions.
+    """
+    sm = StateMachine(ConnectionState.DISCONNECTED)
+
+    # Define valid transitions
+    sm.define_transition(
+        "connect", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
+    )
+    sm.define_transition(
+        "disconnect", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
+    )
+    sm.define_transition(
+        "connecting", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
+    )
+    sm.define_transition("connected", {ConnectionState.CONNECTING})
+    sm.define_transition(
+        "disconnecting", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
+    )
+    sm.define_transition("disconnected", {ConnectionState.DISCONNECTING})
+    sm.define_transition(
+        "failed",
+        {
+            ConnectionState.CONNECTING,
+            ConnectionState.CONNECTED,
+            ConnectionState.DISCONNECTING,
+        },
+    )
+
+    return sm
+
+
 class ProtocolLogWidget(Widget):
     """Widget for displaying protocol telegram stream.
 
@@ -45,6 +84,18 @@ class ProtocolLogWidget(Widget):
         log_widget: RichLog widget for displaying messages.
     """
 
+    class StatusMessageChanged(Message):
+        """Message posted when status message changes."""
+
+        def __init__(self, message: str) -> None:
+            """Initialize the message.
+
+            Args:
+                message: The status message to display.
+            """
+            super().__init__()
+            self.message = message
+
     connection_state = reactive(ConnectionState.DISCONNECTED)
 
     def __init__(self, container: Any) -> None:
@@ -54,11 +105,13 @@ class ProtocolLogWidget(Widget):
             container: ServiceContainer for resolving services.
         """
         super().__init__()
+        self.border_title = "Protocol"
         self.container = container
         self.protocol: Optional[ConbusEventProtocol] = None
         self.service: Optional[ConbusReceiveService] = None
         self.logger = logging.getLogger(__name__)
         self.log_widget: Optional[RichLog] = None
+        self._state_machine = create_connection_state_machine()
 
     def compose(self) -> Any:
         """Compose the widget layout.
@@ -66,7 +119,7 @@ class ProtocolLogWidget(Widget):
         Yields:
             RichLog widget for message display.
         """
-        self.log_widget = RichLog(highlight=True, markup=True)
+        self.log_widget = RichLog(highlight=False, markup=True)
         yield self.log_widget
 
     async def on_mount(self) -> None:
@@ -88,7 +141,7 @@ class ProtocolLogWidget(Widget):
 
         # Delay connection to let UI render
         await asyncio.sleep(0.5)
-        await self._start_connection_async()
+        self._start_connection()
 
     async def _start_connection_async(self) -> None:
         """Start TCP connection to Conbus server (async).
@@ -105,11 +158,22 @@ class ProtocolLogWidget(Widget):
             self.logger.error("Protocol not initialized")
             return
 
+        # Guard: Don't connect if already connected or connecting
+        if not self._state_machine.can_transition("connecting"):
+            self.logger.warning(
+                f"Already {self._state_machine.get_state().value}, ignoring connect request"
+            )
+            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]")
+            # Transition to CONNECTING
+            if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
+                self.connection_state = ConnectionState.CONNECTING
+                self.post_message(
+                    self.StatusMessageChanged(
+                        f"Connecting to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}..."
+                    )
+                )
 
             # Store protocol reference
             self.logger.info(f"Protocol object: {self.protocol}")
@@ -146,26 +210,11 @@ class ProtocolLogWidget(Widget):
             )
 
             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]"
-                )
+            reactor.connectTCP(
+                self.protocol.cli_config.ip,
+                self.protocol.cli_config.port,
+                self.protocol,
+            )
 
             # Wait for connection to establish
             await asyncio.sleep(1.0)
@@ -173,15 +222,15 @@ class ProtocolLogWidget(Widget):
 
         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)
+            # Transition to FAILED
+            if self._state_machine.transition("failed", ConnectionState.FAILED):
+                self.connection_state = ConnectionState.FAILED
+                self.post_message(self.StatusMessageChanged(f"Connection error: {e}"))
 
     def _start_connection(self) -> None:
         """Start connection (sync wrapper for async method)."""
         # Use run_worker to run async method from sync context
+        self.logger.debug("Start connection")
         self.run_worker(self._start_connection_async(), exclusive=True)
 
     def _on_connection_made(self) -> None:
@@ -189,10 +238,16 @@ class ProtocolLogWidget(Widget):
 
         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]")
+        self.logger.debug("Connection made")
+        # Transition to CONNECTED
+        if self._state_machine.transition("connected", ConnectionState.CONNECTED):
+            self.connection_state = ConnectionState.CONNECTED
+            if self.protocol:
+                self.post_message(
+                    self.StatusMessageChanged(
+                        f"Connected to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}"
+                    )
+                )
 
     def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
         """Handle telegram received signal.
@@ -200,9 +255,10 @@ class ProtocolLogWidget(Widget):
         Args:
             event: Telegram received event with frame data.
         """
+        self.logger.debug("Telegram received")
         if self.log_widget:
-            # Display [RX] in green, frame in gray
-            self.log_widget.write(f"[green]\\[RX][/green] [dim]{event.frame}[/dim]")
+            # Display [RX] and frame in bright green
+            self.log_widget.write(f"[#00ff00]\\[RX] {event.frame}[/#00ff00]")
 
     def _on_telegram_sent(self, telegram: str) -> None:
         """Handle telegram sent signal.
@@ -210,15 +266,17 @@ class ProtocolLogWidget(Widget):
         Args:
             telegram: Sent telegram string.
         """
+        self.logger.debug("Telegram sent")
         if self.log_widget:
-            # Display [TX] in green, frame in gray
-            self.log_widget.write(f"[green]\\[TX][/green] [dim]{telegram}[/dim]")
+            # Display [TX] and frame in bold bright green
+            self.log_widget.write(f"[bold #00ff00]\\[TX] {telegram}[/bold #00ff00]")
 
     def _on_timeout(self) -> None:
         """Handle timeout signal.
 
         Logs timeout but continues monitoring (no action needed).
         """
+        self.logger.debug("Timeout")
         self.logger.debug("Timeout occurred (continuous monitoring)")
 
     def _on_failed(self, error: str) -> None:
@@ -227,60 +285,83 @@ class ProtocolLogWidget(Widget):
         Args:
             error: Error message describing the failure.
         """
-        self.connection_state = ConnectionState.FAILED
-        self.logger.error(f"Connection failed: {error}")
+        # Transition to FAILED
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self.connection_state = ConnectionState.FAILED
+            self.logger.error(f"Connection failed: {error}")
+            self.post_message(self.StatusMessageChanged(f"Failed: {error}"))
 
-        if self.log_widget:
-            self.log_widget.write(f"[red]Connection failed: {error}[/red]")
+    def connect(self) -> None:
+        """Connect to Conbus server.
 
-        # Exit app after brief delay to show error
-        self.set_timer(2.0, self.app.exit)
+        Only initiates connection if currently DISCONNECTED or FAILED.
+        """
+        self.logger.debug("Connect")
+
+        # Guard: Check if connection is allowed
+        if not self._state_machine.can_transition("connect"):
+            self.logger.warning(
+                f"Cannot connect: current state is {self._state_machine.get_state().value}"
+            )
+            return
 
-    def connect(self) -> None:
-        """Connect to Conbus server."""
         self._start_connection()
 
     def disconnect(self) -> None:
-        """Disconnect from Conbus server."""
+        """Disconnect from Conbus server.
+
+        Only disconnects if currently CONNECTED or CONNECTING.
+        """
+        self.logger.debug("Disconnect")
+
+        # Guard: Check if disconnection is allowed
+        if not self._state_machine.can_transition("disconnect"):
+            self.logger.warning(
+                f"Cannot disconnect: current state is {self._state_machine.get_state().value}"
+            )
+            return
+
+        # Transition to DISCONNECTING
+        if self._state_machine.transition(
+            "disconnecting", ConnectionState.DISCONNECTING
+        ):
+            self.connection_state = ConnectionState.DISCONNECTING
+            self.post_message(self.StatusMessageChanged("Disconnecting..."))
+
         if self.protocol:
             self.protocol.disconnect()
 
-    def send_discover(self) -> None:
-        """Send discover telegram.
+        # Transition to DISCONNECTED
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self.connection_state = ConnectionState.DISCONNECTED
+            self.post_message(self.StatusMessageChanged("Disconnected"))
+
+    def send_telegram(self, name: str, telegram: str) -> None:
+        """Send a raw telegram string.
 
-        Sends predefined discover telegram <S0000000000F01D00FA> to the bus.
-        Called when user presses 'd' key.
+        Args:
+            name: Telegram name (e.g., "Discover")
+            telegram: Telegram string including angle brackets (e.g., "S0000000000F01D00")
         """
         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]"
-                )
+            self.logger.warning("Cannot send telegram: not connected")
             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]")
+            # Remove angle brackets if present
+            self.post_message(self.StatusMessageChanged(f"Sending {name}..."))
+            # Send raw telegram
+            self.protocol.send_raw_telegram(telegram)
 
         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]")
+            self.logger.error(f"Failed to send telegram: {e}")
+            self.post_message(self.StatusMessageChanged(f"Failed: {e}"))
+
+    def clear_log(self) -> None:
+        """Clear the protocol log widget."""
+        if self.log_widget:
+            self.log_widget.clear()
+            self.post_message(self.StatusMessageChanged("Log cleared"))
 
     def on_unmount(self) -> None:
         """Clean up when widget unmounts.

xp/utils/logging.py

@@ -20,11 +20,22 @@ class LoggerService:
         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
-        )
+        """Setup file logging only with configured levels."""
+        # Setup file logging for term app (console logging disabled)
+        root_logger = logging.getLogger()
+
+        # Remove any existing console handlers
+        root_logger.handlers = [
+            h
+            for h in root_logger.handlers
+            if not isinstance(h, logging.StreamHandler)
+            or isinstance(h, RotatingFileHandler)
+        ]
+
+        # Set root logger level
+        numeric_level = getattr(logging, self.logging_config.default_level.upper())
+        root_logger.setLevel(numeric_level)
+
         self.setup_file_logging(
             self.logging_config.log_format, self.logging_config.date_format
         )

xp/utils/state_machine.py

@@ -0,0 +1,81 @@
+"""Lightweight state machine utilities.
+
+Provides simple, zero-dependency state machine implementation for
+managing state transitions with validation.
+"""
+
+from enum import Enum
+from typing import Set
+
+
+class StateMachine:
+    """Lightweight state machine for managing state transitions.
+
+    Enforces valid state transitions and prevents invalid operations.
+    Zero dependencies, suitable for any state-based logic.
+
+    Example:
+        >>> from enum import Enum
+        >>> class State(str, Enum):
+        ...     IDLE = "IDLE"
+        ...     RUNNING = "RUNNING"
+        ...
+        >>> sm = StateMachine(State.IDLE)
+        >>> sm.define_transition("start", {State.IDLE}, State.RUNNING)
+        >>> sm.can_transition("start")  # True
+        >>> sm.transition("start", State.RUNNING)  # True
+        >>> sm.get_state()  # State.RUNNING
+    """
+
+    def __init__(self, initial: Enum):
+        """Initialize state machine.
+
+        Args:
+            initial: Initial state (any Enum value).
+        """
+        self.state = initial
+        self._valid_transitions: dict[str, Set[Enum]] = {}
+
+    def define_transition(self, action: str, valid_sources: Set[Enum]) -> None:
+        """Define valid source states for an action.
+
+        Args:
+            action: Action name (e.g., "connect", "disconnect").
+            valid_sources: Set of states from which action is valid.
+        """
+        self._valid_transitions[action] = valid_sources
+
+    def can_transition(self, action: str) -> bool:
+        """Check if action is valid from current state.
+
+        Args:
+            action: Action to check (e.g., "connect", "disconnect").
+
+        Returns:
+            True if action is valid from current state.
+        """
+        valid_sources = self._valid_transitions.get(action, set())
+        return self.state in valid_sources
+
+    def transition(self, action: str, new_state: Enum) -> bool:
+        """Attempt state transition.
+
+        Args:
+            action: Action triggering the transition.
+            new_state: Target state.
+
+        Returns:
+            True if transition succeeded, False if invalid.
+        """
+        if self.can_transition(action):
+            self.state = new_state
+            return True
+        return False
+
+    def get_state(self) -> Enum:
+        """Get current state.
+
+        Returns:
+            Current state as Enum value.
+        """
+        return self.state

xp/tui/app.py

@@ -1,72 +0,0 @@
-"""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

@@ -1,50 +0,0 @@
-/* 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;
-}