topicgate 1.1.0__py3-none-any.whl

topicgate/gui/components/mcp_setup_dialog.py

@@ -0,0 +1,198 @@
+from PySide6.QtCore import Signal
+from PySide6.QtGui import QGuiApplication
+from PySide6.QtWidgets import (
+    QComboBox,
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QPlainTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from topicgate.gui.main_view_model import MainViewModel
+
+
+class McpSetupDialog(QDialog):
+    """Configure MCP clients and diagnose the shared TopicGate installation."""
+
+    reconnect_observe_requested = Signal()
+
+    def __init__(
+        self,
+        view_model: MainViewModel,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._view_model = view_model
+        self.setObjectName("mcpSetupDialog")
+        self.setWindowTitle("Configure TopicGate MCP")
+        self.resize(760, 700)
+        layout = QVBoxLayout(self)
+
+        introduction = QLabel(
+            "TopicGate Desktop is the setup and maintenance control center. "
+            "The MCP process is normally started by your host and shares this "
+            "database with the desktop. Read-only mode is recommended."
+        )
+        introduction.setWordWrap(True)
+        introduction.setAccessibleName("MCP setup introduction")
+        layout.addWidget(introduction)
+
+        information = self._view_model.mcp_setup_information
+        installation = QGroupBox("Installation")
+        install_form = QFormLayout(installation)
+        self._version = QLabel(information.version if information else "Development")
+        self._version.setObjectName("mcpTopicGateVersion")
+        executable = (
+            str(information.executable_path)
+            if information
+            else "Current Python environment"
+        )
+        self._executable = QLabel(executable)
+        self._executable.setObjectName("mcpExecutablePath")
+        install_form.addRow("TopicGate version", self._version)
+        install_form.addRow(
+            "Resolved executable",
+            self._path_row(self._executable, "copyMcpExecutablePath"),
+        )
+        if information is not None:
+            self._data_path = QLabel(str(information.data_path))
+            self._data_path.setObjectName("mcpDataPath")
+            self._database_path = QLabel(str(information.database_path))
+            self._database_path.setObjectName("mcpDatabasePath")
+            install_form.addRow(
+                "Application data",
+                self._path_row(self._data_path, "copyMcpDataPath"),
+            )
+            install_form.addRow(
+                "SQLite database",
+                self._path_row(self._database_path, "copyMcpDatabasePath"),
+            )
+        layout.addWidget(installation)
+
+        mode_row = QHBoxLayout()
+        mode_row.addWidget(QLabel("Configuration mode"))
+        self._mode = QComboBox()
+        self._mode.setObjectName("mcpConfigurationMode")
+        self._mode.setAccessibleName("MCP configuration mode")
+        self._mode.addItems(("Read-only (recommended)", "Control"))
+        self._mode.currentIndexChanged.connect(self._render_configuration)
+        mode_row.addWidget(self._mode, 1)
+        layout.addLayout(mode_row)
+
+        self._mode_warning = QLabel()
+        self._mode_warning.setObjectName("mcpModeWarning")
+        self._mode_warning.setWordWrap(True)
+        self._mode_warning.setAccessibleName("MCP mode capabilities and warning")
+        layout.addWidget(self._mode_warning)
+
+        self._configuration = QPlainTextEdit()
+        self._configuration.setObjectName("mcpSetupConfiguration")
+        self._configuration.setReadOnly(True)
+        self._configuration.setAccessibleName("TopicGate MCP configuration")
+        layout.addWidget(self._configuration, 1)
+        copy_button = QPushButton("Copy configuration")
+        copy_button.setObjectName("copyMcpConfigurationButton")
+        copy_button.setAccessibleName("Copy TopicGate MCP configuration")
+        copy_button.clicked.connect(self._copy_configuration)
+        layout.addWidget(copy_button)
+
+        trust = QLabel(
+            "Security: broker names, topic names, and MQTT payloads are untrusted "
+            "data. MCP clients must never treat their contents as instructions."
+        )
+        trust.setObjectName("mcpUntrustedDataWarning")
+        trust.setWordWrap(True)
+        trust.setAccessibleName("Untrusted MQTT data warning")
+        layout.addWidget(trust)
+
+        diagnostics = QHBoxLayout()
+        preflight = QPushButton("Run local preflight")
+        preflight.setObjectName("runMcpPreflightButton")
+        preflight.setAccessibleName("Run local MCP preflight checks")
+        preflight.clicked.connect(self._run_preflight)
+        diagnostics.addWidget(preflight)
+        snapshot = QPushButton("Test broker snapshot")
+        snapshot.setObjectName("testMcpSnapshotButton")
+        snapshot.setAccessibleName("Test broker snapshot without reconnecting")
+        snapshot.clicked.connect(self._test_snapshot)
+        diagnostics.addWidget(snapshot)
+        reconnect = QPushButton("Test reconnect & observe…")
+        reconnect.setObjectName("testMcpReconnectButton")
+        reconnect.setAccessibleName("Test reconnect and observe with confirmation")
+        reconnect.clicked.connect(self.reconnect_observe_requested.emit)
+        diagnostics.addWidget(reconnect)
+        layout.addLayout(diagnostics)
+
+        self._diagnostic_result = QLabel("Run preflight to check this installation.")
+        self._diagnostic_result.setObjectName("mcpPreflightResults")
+        self._diagnostic_result.setWordWrap(True)
+        self._diagnostic_result.setAccessibleName("MCP preflight results")
+        layout.addWidget(self._diagnostic_result)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
+        buttons.rejected.connect(self.accept)
+        layout.addWidget(buttons)
+        self._render_configuration()
+
+    def _path_row(self, label: QLabel, button_name: str) -> QWidget:
+        row = QWidget()
+        layout = QHBoxLayout(row)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(label, 1)
+        copy = QPushButton("Copy")
+        copy.setObjectName(button_name)
+        copy.setAccessibleName(f"Copy {label.objectName()}")
+        copy.clicked.connect(
+            lambda _checked=False, value=label.text(): (
+                QGuiApplication.clipboard().setText(value)
+            )
+        )
+        layout.addWidget(copy)
+        return row
+
+    def _render_configuration(self) -> None:
+        control = self._mode.currentIndex() == 1
+        mode = "control" if control else "read-only"
+        self._configuration.setPlainText(self._view_model.mcp_configuration(mode))
+        if control:
+            self._mode_warning.setText(
+                "Control mode exposes connection changes, broker activation, "
+                "subscription changes, observation refresh, and publishing. "
+                "It uses the shared control lease and can be blocked by desktop work."
+            )
+            self._mode_warning.setStyleSheet("color: #991b1b; font-weight: 600;")
+        else:
+            self._mode_warning.setText(
+                "Read-only exposes broker, connection, subscription, topic, and "
+                "snapshot inspection. It does not reconnect, subscribe, or publish."
+            )
+            self._mode_warning.setStyleSheet("")
+
+    def _run_preflight(self) -> None:
+        checks = self._view_model.run_mcp_preflight()
+        self._diagnostic_result.setText(
+            "\n".join(
+                f"{check.status.upper()}: {check.name} — {check.detail}"
+                for check in checks
+            )
+        )
+
+    def _test_snapshot(self) -> None:
+        try:
+            health = self._view_model.test_broker_snapshot()
+        except Exception as error:
+            self._diagnostic_result.setText(f"FAIL: Broker snapshot — {error}")
+            return
+        self._diagnostic_result.setText(
+            "PASS: Broker snapshot — "
+            f"{health.returned_count} returned; {health.completeness_status}."
+        )
+
+    def _copy_configuration(self) -> None:
+        QGuiApplication.clipboard().setText(self._configuration.toPlainText())

topicgate/gui/components/observer_tree.py

@@ -0,0 +1,434 @@
+from uuid import UUID
+
+from PySide6.QtCore import QModelIndex, QSize, QSortFilterProxyModel, Qt, Signal
+from PySide6.QtGui import QStandardItem, QStandardItemModel
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QFrame,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QMenu,
+    QScrollArea,
+    QStyle,
+    QToolButton,
+    QTreeView,
+    QWidget,
+)
+
+from topicgate.core.models.broker_summary import BrokerSummary
+from topicgate.core.models.subscription import Subscription
+from topicgate.gui.components.workspace_pane import WorkspacePane
+from topicgate.gui.components.snapshot_panel import SnapshotPanel
+from topicgate.presentation.topic_presentation import TopicTreeNode
+
+TOPIC_ROLE = Qt.ItemDataRole.UserRole + 1
+
+
+class ObserverTreePane(WorkspacePane):
+    """Searchable tree of configured and dynamically observed MQTT topics."""
+
+    topic_selected = Signal(str)
+    add_filter_requested = Signal()
+    remove_filter_requested = Signal(object)
+    broker_profile_selected = Signal(object)
+    add_broker_profile_requested = Signal()
+    edit_broker_profile_requested = Signal(object)
+    delete_broker_profile_requested = Signal()
+    snapshot_apply_requested = Signal(object)
+    snapshot_reset_requested = Signal()
+    reconnect_observe_requested = Signal(object)
+    empty_state_action_requested = Signal(str)
+
+    def __init__(self) -> None:
+        super().__init__("Observer Tree")
+        self._items: dict[str, QStandardItem] = {}
+
+        controls = QHBoxLayout()
+        self._search_edit = QLineEdit()
+        self._search_edit.setPlaceholderText("Search topics...")
+        self._search_edit.setAccessibleName("Search observed topics")
+        self._search_edit.setClearButtonEnabled(True)
+        controls.addWidget(self._search_edit, 1)
+
+        add_button = QToolButton()
+        add_button.setText("+ Filter")
+        add_button.setToolTip("Add an MQTT subscription filter")
+        add_button.setAccessibleName("Add MQTT subscription filter")
+        add_button.clicked.connect(self.add_filter_requested)
+        controls.addWidget(add_button)
+
+        self._broker_profile_button = QToolButton()
+        self._broker_profile_button.setObjectName("brokerProfileButton")
+        self._broker_profile_button.setMinimumWidth(126)
+        self._broker_profile_button.setPopupMode(
+            QToolButton.ToolButtonPopupMode.InstantPopup
+        )
+        self._broker_profile_menu = QMenu(self._broker_profile_button)
+        self._broker_profile_button.setMenu(self._broker_profile_menu)
+        controls.addWidget(self._broker_profile_button)
+        self.content_layout.addLayout(controls)
+
+        self._model = QStandardItemModel(self)
+        self._model.setHorizontalHeaderLabels(["Topic", "", "State"])
+        self._proxy = QSortFilterProxyModel(self)
+        self._proxy.setSourceModel(self._model)
+        self._proxy.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self._proxy.setRecursiveFilteringEnabled(True)
+        self._proxy.setFilterKeyColumn(0)
+
+        self._tree = QTreeView()
+        self._tree.setObjectName("observerTree")
+        self._tree.setModel(self._proxy)
+        self._tree.setAlternatingRowColors(True)
+        self._tree.setUniformRowHeights(True)
+        self._tree.header().setSectionResizeMode(
+            0,
+            QHeaderView.ResizeMode.Stretch,
+        )
+        self._tree.header().setStretchLastSection(False)
+        self._tree.header().setSectionResizeMode(
+            1,
+            QHeaderView.ResizeMode.Fixed,
+        )
+        self._tree.header().resizeSection(1, 34)
+        self._tree.header().setSectionResizeMode(
+            2,
+            QHeaderView.ResizeMode.Fixed,
+        )
+        self._tree.header().resizeSection(2, 136)
+        self._tree.selectionModel().currentChanged.connect(
+            self._selection_changed
+        )
+        self._search_edit.textChanged.connect(self._proxy.setFilterFixedString)
+        self.content_layout.addWidget(self._tree, 1)
+        self._empty_state = QFrame()
+        self._empty_state.setObjectName("observerEmptyState")
+        self._empty_state.setFrameShape(QFrame.Shape.StyledPanel)
+        empty_layout = QHBoxLayout(self._empty_state)
+        self._empty_state_text = QLabel()
+        self._empty_state_text.setObjectName("observerEmptyStateText")
+        self._empty_state_text.setWordWrap(True)
+        empty_layout.addWidget(self._empty_state_text, 1)
+        self._empty_state_action = QToolButton()
+        self._empty_state_action.setObjectName("observerEmptyStateAction")
+        self._empty_state_action.clicked.connect(
+            lambda: self.empty_state_action_requested.emit(
+                str(self._empty_state_action.property("action") or "")
+            )
+        )
+        empty_layout.addWidget(self._empty_state_action)
+        self.content_layout.addWidget(self._empty_state)
+        self.snapshot_panel = SnapshotPanel()
+        self.snapshot_panel.apply_requested.connect(
+            self.snapshot_apply_requested.emit
+        )
+        self.snapshot_panel.reset_requested.connect(
+            self.snapshot_reset_requested.emit
+        )
+        self.snapshot_panel.reconnect_observe_requested.connect(
+            self.reconnect_observe_requested.emit
+        )
+        snapshot_scroll = QScrollArea()
+        snapshot_scroll.setObjectName("snapshotPanelScrollArea")
+        snapshot_scroll.setWidgetResizable(True)
+        snapshot_scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+        snapshot_scroll.setHorizontalScrollBarPolicy(
+            Qt.ScrollBarPolicy.ScrollBarAlwaysOff
+        )
+        snapshot_scroll.setMinimumHeight(68)
+        snapshot_scroll.setMaximumHeight(68)
+        snapshot_scroll.setWidget(self.snapshot_panel)
+
+        def resize_snapshot(expanded: bool) -> None:
+            snapshot_scroll.setMinimumHeight(300 if expanded else 68)
+            snapshot_scroll.setMaximumHeight(360 if expanded else 68)
+
+        self.snapshot_panel.expansion_changed.connect(resize_snapshot)
+        self.content_layout.addWidget(snapshot_scroll)
+
+    def render(
+        self,
+        topic_paths: list[str],
+        selected_topic: str,
+        subscriptions: tuple[Subscription, ...] = (),
+    ) -> None:
+        expanded_paths = {
+            path
+            for path, item in self._items.items()
+            if self._tree.isExpanded(self._proxy.mapFromSource(item.index()))
+        }
+        self._model.removeRows(0, self._model.rowCount())
+        self._items.clear()
+
+        for topic in topic_paths:
+            self._add_topic(topic)
+
+        for subscription in subscriptions:
+            self._add_remove_button(subscription)
+
+        if expanded_paths:
+            self._restore_expanded_paths(expanded_paths)
+        else:
+            self._tree.expandToDepth(1)
+        self.select_topic(selected_topic)
+
+    def render_empty_state(
+        self,
+        connection_status: str,
+        subscriptions: tuple[Subscription, ...],
+        query_is_filtered: bool,
+        has_cached_values: bool,
+        has_topics: bool,
+    ) -> None:
+        """Explain why the workspace has no immediately useful live values."""
+        if has_topics and not has_cached_values:
+            self._empty_state.setVisible(False)
+            return
+        if not subscriptions:
+            message, action, label = (
+                "No subscriptions are configured. Add a filter before TopicGate can observe values.",
+                "add-filter",
+                "Add filter",
+            )
+        elif connection_status == "disconnected":
+            message, action, label = (
+                "The active broker is disconnected. Cached values may be old until you reconnect.",
+                "connect",
+                "Connect",
+            )
+        elif query_is_filtered and not has_topics:
+            message, action, label = (
+                "No values match the current snapshot filters. Clear filters or capture a fresh snapshot.",
+                "clear-filters",
+                "Clear filters",
+            )
+        elif has_cached_values:
+            message, action, label = (
+                "Only persisted values are available. Their source and age are shown in Details; reconnect to collect fresh values.",
+                "observe",
+                "Reconnect & observe",
+            )
+        else:
+            message, action, label = (
+                "No values have been observed yet. Capture a fresh snapshot after publishers send messages.",
+                "observe",
+                "Reconnect & observe",
+            )
+        self._empty_state_text.setText(message)
+        self._empty_state_text.setAccessibleName(message)
+        self._empty_state_action.setText(label)
+        self._empty_state_action.setAccessibleName(label)
+        self._empty_state_action.setProperty("action", action)
+        self._empty_state.setVisible(True)
+
+    def render_tree(
+        self,
+        nodes: tuple[TopicTreeNode, ...],
+        selected_topic: str,
+        subscriptions: tuple[Subscription, ...] = (),
+    ) -> None:
+        paths: list[str] = []
+
+        def append(items: tuple[TopicTreeNode, ...]) -> None:
+            for item in items:
+                paths.append(item.path)
+                append(item.children)
+
+        append(nodes)
+        self.render(paths, selected_topic, subscriptions)
+
+        def add_badges(items: tuple[TopicTreeNode, ...]) -> None:
+            for node in items:
+                if node.badges:
+                    self._set_badges(node)
+                add_badges(node.children)
+
+        add_badges(nodes)
+
+    def select_topic(self, topic: str) -> None:
+        item = self._items.get(topic)
+        if item is None:
+            return
+        proxy_index = self._proxy.mapFromSource(item.index())
+        if proxy_index.isValid():
+            self._tree.setCurrentIndex(proxy_index)
+            self._tree.scrollTo(proxy_index)
+
+    def expand_all(self) -> None:
+        self._tree.expandAll()
+
+    def collapse_all(self) -> None:
+        self._tree.collapseAll()
+
+    def focus_search(self) -> None:
+        self._search_edit.setFocus(Qt.FocusReason.ShortcutFocusReason)
+
+    def render_broker_profiles(
+        self,
+        profiles: tuple[BrokerSummary, ...],
+        active_profile_id: UUID,
+    ) -> None:
+        """Render a quick-switch menu for the available broker profiles."""
+        self._broker_profile_menu.clear()
+        active_profile = next(
+            profile for profile in profiles if profile.id == active_profile_id
+        )
+        self._broker_profile_button.setText(active_profile.name)
+        self._broker_profile_button.setToolTip(
+            f"Switch broker profile (current: {active_profile.name})"
+        )
+        self._broker_profile_button.setAccessibleName("Switch broker profile")
+        for profile in profiles:
+            action = self._broker_profile_menu.addAction(profile.name)
+            action.setCheckable(True)
+            action.setChecked(profile.id == active_profile_id)
+            action.setEnabled(profile.id != active_profile_id)
+            action.triggered.connect(
+                lambda _checked=False, profile_id=profile.id: (
+                    self.broker_profile_selected.emit(profile_id)
+                )
+            )
+        self._broker_profile_menu.addSeparator()
+        add_action = self._broker_profile_menu.addAction("Add profile...")
+        add_action.setObjectName("addBrokerProfileAction")
+        add_action.triggered.connect(self.add_broker_profile_requested.emit)
+        edit_menu = self._broker_profile_menu.addMenu("Edit profile...")
+        edit_menu.menuAction().setObjectName("editBrokerProfileAction")
+        for profile in profiles:
+            edit_action = edit_menu.addAction(profile.name)
+            edit_action.triggered.connect(
+                lambda _checked=False, profile_id=profile.id: (
+                    self.edit_broker_profile_requested.emit(profile_id)
+                )
+            )
+        delete_action = self._broker_profile_menu.addAction(
+            "Delete current profile..."
+        )
+        delete_action.setObjectName("deleteBrokerProfileAction")
+        delete_action.setEnabled(len(profiles) > 1)
+        delete_action.triggered.connect(self.delete_broker_profile_requested.emit)
+
+    def set_profile_switching(self, switching: bool) -> None:
+        """Prevent duplicate profile switches while the broker reconnects."""
+        self._broker_profile_button.setEnabled(not switching)
+        action = str(self._empty_state_action.property("action") or "")
+        if action in {"connect", "observe"}:
+            self._empty_state_action.setEnabled(not switching)
+
+    def _add_topic(self, topic: str) -> None:
+        parent = self._model.invisibleRootItem()
+        partial_path: list[str] = []
+        for segment in topic.split("/"):
+            partial_path.append(segment)
+            path = "/".join(partial_path)
+            item = self._items.get(path)
+            if item is None:
+                item = QStandardItem(segment or "/")
+                item.setEditable(False)
+                item.setData(path, TOPIC_ROLE)
+                state_item = QStandardItem()
+                state_item.setEditable(False)
+                action_item = QStandardItem()
+                action_item.setEditable(False)
+                parent.appendRow([item, state_item, action_item])
+                self._items[path] = item
+            parent = item
+
+    def _add_remove_button(self, subscription: Subscription) -> None:
+        item = self._items.get(subscription.topic_filter)
+        if item is None:
+            return
+
+        action_widget = QWidget()
+        action_layout = QHBoxLayout(action_widget)
+        action_layout.setContentsMargins(5, 0, 5, 0)
+        action_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        button = QToolButton(action_widget)
+        button.setObjectName("removeSubscriptionButton")
+        button.setFixedSize(24, 18)
+        button.setIconSize(QSize(12, 12))
+        button.setIcon(
+            self.style().standardIcon(QStyle.StandardPixmap.SP_TrashIcon)
+        )
+        button.setStyleSheet(
+            "QToolButton {"
+            " background-color: #7f1d1d;"
+            " border: 1px solid #b91c1c;"
+            " border-radius: 4px;"
+            " padding: 0;"
+            "}"
+            "QToolButton:hover {"
+            " background-color: #b91c1c;"
+            " border-color: #ef4444;"
+            "}"
+            "QToolButton:pressed {"
+            " background-color: #450a0a;"
+            " border-color: #991b1b;"
+            "}"
+        )
+        button.setToolTip(f"Remove subscription {subscription.topic_filter}")
+        button.setAccessibleName(
+            f"Remove subscription {subscription.topic_filter}"
+        )
+        button.clicked.connect(
+            lambda _checked=False, subscription=subscription: (
+                self.remove_filter_requested.emit(subscription)
+            )
+        )
+        action_layout.addWidget(button)
+        action_index = item.index().siblingAtColumn(1)
+        self._tree.setIndexWidget(
+            self._proxy.mapFromSource(action_index),
+            action_widget,
+        )
+
+    def _set_badges(self, node: TopicTreeNode) -> None:
+        item = self._items.get(node.path)
+        if item is None:
+            return
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
+        layout.setContentsMargins(2, 0, 2, 0)
+        layout.setSpacing(3)
+        colors = {
+            "success": ("#dcfce7", "#166534"),
+            "info": ("#dbeafe", "#1e40af"),
+            "warning": ("#fef3c7", "#92400e"),
+            "neutral": ("#e5e7eb", "#374151"),
+        }
+        for badge in node.badges:
+            label = QLabel(badge.label)
+            label.setObjectName("topicStateBadge")
+            label.setProperty("badgeKey", badge.key)
+            background, foreground = colors[badge.tone]
+            label.setStyleSheet(
+                f"background: {background}; color: {foreground}; "
+                "border-radius: 5px; padding: 1px 4px; font-size: 10px;"
+            )
+            layout.addWidget(label)
+        layout.addStretch(1)
+        state_index = item.index().siblingAtColumn(2)
+        self._tree.setIndexWidget(self._proxy.mapFromSource(state_index), widget)
+
+    def _restore_expanded_paths(self, expanded_paths: set[str]) -> None:
+        for path in expanded_paths:
+            item = self._items.get(path)
+            if item is not None:
+                self._tree.setExpanded(
+                    self._proxy.mapFromSource(item.index()),
+                    True,
+                )
+
+    def _selection_changed(
+        self,
+        current: QModelIndex,
+        _previous: QModelIndex,
+    ) -> None:
+        source_index = self._proxy.mapToSource(current)
+        topic = self._model.data(source_index, TOPIC_ROLE) or ""
+        self.topic_selected.emit(str(topic))
+
+
+TopicNavigationPane = ObserverTreePane