fix(mcp): serialize dashboard role permissions

superset/mcp_service/dashboard/schemas.py

@@ -79,6 +79,7 @@
     model_validator,
     PositiveInt,
 )
+from sqlalchemy.orm.exc import DetachedInstanceError
 
 if TYPE_CHECKING:
     from superset.models.dashboard import Dashboard
@@ -152,15 +153,58 @@ def serialize_role_object(role: Any) -> RoleInfo | None:
     if not role:
         return None
 
+    try:
+        raw_permissions = getattr(role, "permissions", None)
+    except DetachedInstanceError:
+        raw_permissions = None
+
+    permissions: list[str] | None = None
+    if raw_permissions is not None:
+        permissions = []
+        try:
+            permission_iterator = iter(raw_permissions)
+        except TypeError:
+            permission_iterator = iter(())
+
+        while True:
+            try:
+                permission = next(permission_iterator)
+            except StopIteration:
+                break
+            except (DetachedInstanceError, TypeError):
+                break
+
+            try:
+                permission_name = _serialize_permission_name(permission)
+            except (DetachedInstanceError, TypeError):
+                continue
+
+            if permission_name is not None:
+                permissions.append(permission_name)
+
     return RoleInfo(
         id=getattr(role, "id", None),
         name=getattr(role, "name", None),
-        permissions=[perm.name for perm in getattr(role, "permissions", [])]
-        if hasattr(role, "permissions")
-        else None,
+        permissions=permissions,
     )
 
 
+def _serialize_permission_name(permission: Any) -> str | None:
+    """Return direct permission names or FAB permission/view pairs.
+
+    Returns None when neither representation is available.
+    """
+    if (name := getattr(permission, "name", None)) is not None:
+        return str(name)
+
+    permission_name = getattr(getattr(permission, "permission", None), "name", None)
+    view_menu_name = getattr(getattr(permission, "view_menu", None), "name", None)
+    if permission_name and view_menu_name:
+        return f"{permission_name} on {view_menu_name}"
+
+    return None
+
+
 class DashboardFilter(ColumnOperator):
     """
     Filter object for dashboard listing.

tests/unit_tests/mcp_service/dashboard/tool/test_dashboard_tools.py

@@ -21,16 +21,19 @@
 
 import logging
 from importlib import import_module
+from types import SimpleNamespace
 from unittest.mock import Mock, patch
 
 import pytest
 from fastmcp import Client
 from fastmcp.exceptions import ToolError
 from flask import g
+from sqlalchemy.orm.exc import DetachedInstanceError
 
 from superset.mcp_service.app import mcp
 from superset.mcp_service.dashboard.schemas import (
     ListDashboardsRequest,
+    serialize_role_object,
 )
 from superset.mcp_service.dashboard.tool.get_dashboard_info import (
     _refresh_request_user_for_permalink_access,
@@ -134,6 +137,109 @@ async def test_list_dashboards_basic(mock_list, mcp_server):
         assert "slug" in data["columns_loaded"]
 
 
+def test_dashboard_role_serializer_serializes_permission_view_names() -> None:
+    permission_view = SimpleNamespace(
+        permission=SimpleNamespace(name="can_read"),
+        view_menu=SimpleNamespace(name="Dashboard"),
+    )
+    role = SimpleNamespace(id=1, name="Gamma", permissions=[permission_view])
+
+    role_info = serialize_role_object(role)
+
+    assert role_info is not None
+    assert role_info.model_dump() == {
+        "id": 1,
+        "name": "Gamma",
+        "permissions": ["can_read on Dashboard"],
+    }
+
+
+def test_dashboard_role_serializer_skips_bad_permission_items() -> None:
+    class DetachedPermission:
+        @property
+        def name(self) -> str:
+            raise DetachedInstanceError("detached permission")
+
+    permission_view = SimpleNamespace(
+        permission=SimpleNamespace(name="can_read"),
+        view_menu=SimpleNamespace(name="Dashboard"),
+    )
+    role = SimpleNamespace(
+        id=1,
+        name="Gamma",
+        permissions=[
+            permission_view,
+            DetachedPermission(),
+            SimpleNamespace(name="can_write"),
+        ],
+    )
+
+    role_info = serialize_role_object(role)
+
+    assert role_info is not None
+    assert role_info.permissions == ["can_read on Dashboard", "can_write"]
+
+
+def test_dashboard_role_serializer_handles_detached_permissions() -> None:
+    class DetachedRole:
+        id = 1
+        name = "Gamma"
+
+        @property
+        def permissions(self) -> list[object]:
+            raise DetachedInstanceError("detached permissions")
+
+    role_info = serialize_role_object(DetachedRole())
+
+    assert role_info is not None
+    assert role_info.permissions is None
+
+
+def test_dashboard_role_serializer_handles_non_iterable_permissions() -> None:
+    role = SimpleNamespace(id=1, name="Gamma", permissions=object())
+
+    role_info = serialize_role_object(role)
+
+    assert role_info is not None
+    assert role_info.permissions == []
+
+
+def test_dashboard_role_serializer_stops_on_detached_permission_iterator() -> None:
+    class DetachedPermissionIterator:
+        def __iter__(self) -> "DetachedPermissionIterator":
+            return self
+
+        def __next__(self) -> object:
+            raise DetachedInstanceError("detached permission iterator")
+
+    role = SimpleNamespace(
+        id=1,
+        name="Gamma",
+        permissions=DetachedPermissionIterator(),
+    )
+
+    role_info = serialize_role_object(role)
+
+    assert role_info is not None
+    assert role_info.permissions == []
+
+
+def test_dashboard_role_serializer_skips_unnamed_permission_items() -> None:
+    role = SimpleNamespace(
+        id=1,
+        name="Gamma",
+        permissions=[
+            SimpleNamespace(permission=SimpleNamespace(name="can_read")),
+            SimpleNamespace(view_menu=SimpleNamespace(name="Dashboard")),
+        ],
+    )
+
+    role_info = serialize_role_object(role)
+
+    assert role_info is not None
+    assert role_info.permissions == []
+
+
 @patch("superset.daos.dashboard.DashboardDAO.list")
 @pytest.mark.asyncio
 async def test_list_dashboards_with_filters(mock_list, mcp_server):