Эх сурвалжийг харах

update server MCP with tools and resources for LWE group management (ACL)

Khanh Nguyen 5 сар өмнө
parent
commit
7fa9c467ca

+ 1 - 1
src/server_mcp/resources.py → src/server_mcp/resources_element.py

@@ -71,7 +71,7 @@ def _unwrap_data(response: Any) -> Any:
     return response
 
 
-def register_resources(mcp_server: Any, client_rest: ClientRest) -> None:
+def register_element_resources(mcp_server: Any, client_rest: ClientRest) -> None:
     """Enregistre les ressources de lecture du serveur MCP."""
 
     @mcp_server.resource("modx://resource/{id}", 

+ 83 - 0
src/server_mcp/resources_groupmgt.py

@@ -0,0 +1,83 @@
+"""Definition des ressources MCP (lecture groupmgt)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..services.client_rest import ClientRest, HTTPMethod
+
+
+def _unwrap_data(response: Any) -> Any:
+    """Extrait le payload utile des reponses LWE {code,message,data}."""
+    if isinstance(response, dict) and "data" in response:
+        return response["data"]
+    return response
+
+
+def register_groupmgt_resources(mcp_server: Any, client_rest: ClientRest) -> None:
+    """Enregistre les ressources de lecture groupmgt du serveur MCP."""
+
+    @mcp_server.resource(
+        "modx://groupmgt/resourcegroups",
+        mime_type="application/json",
+        description="Liste tous les groupes de resource disponibles au sein de la plateforme.",
+    )
+    def get_resource_groups() -> dict[str, Any]:
+        response = client_rest.execute(
+            method=HTTPMethod.GET,
+            endpoint="/rest/groupmgt/resourcegroups",
+        )
+        data = _unwrap_data(response)
+        return {"items": data} if isinstance(data, list) else {"data": data}
+
+    @mcp_server.resource(
+        "modx://groupmgt/resources/{id}",
+        mime_type="application/json",
+        description="Liste toutes les resources appartenant a un groupe de resource.",
+    )
+    def get_resources_from_group(id: str) -> dict[str, Any]:
+        response = client_rest.execute(
+            method=HTTPMethod.GET,
+            endpoint=f"/rest/groupmgt/resources/{id}",
+        )
+        data = _unwrap_data(response)
+        return {"items": data} if isinstance(data, list) else {"data": data}
+
+    @mcp_server.resource(
+        "modx://groupmgt/resource/{id}",
+        mime_type="application/json",
+        description="Liste toutes les groupes de resources auxquels une resource appartient.",
+    )
+    def get_groups_of_resource(id: str) -> dict[str, Any]:
+        response = client_rest.execute(
+            method=HTTPMethod.GET,
+            endpoint=f"/rest/groupmgt/resource/{id}",
+        )
+        data = _unwrap_data(response)
+        return {"items": data} if isinstance(data, list) else {"data": data}
+
+    @mcp_server.resource(
+        "modx://groupmgt/usergroups",
+        mime_type="application/json",
+        description="Liste tous les groupes d'utilisateur disponibles au sein de la plateforme.",
+    )
+    def get_user_groups() -> dict[str, Any]:
+        response = client_rest.execute(
+            method=HTTPMethod.GET,
+            endpoint="/rest/groupmgt/groups",
+        )
+        data = _unwrap_data(response)
+        return {"items": data} if isinstance(data, list) else {"data": data}
+
+    @mcp_server.resource(
+        "modx://groupmgt/access/{id}",
+        mime_type="application/json",
+        description="Liste tous les acces d'un groupe d'utilisateurs a un groupe de ressources.",
+    )
+    def get_access(id: str) -> dict[str, Any]:
+        response = client_rest.execute(
+            method=HTTPMethod.GET,
+            endpoint=f"/rest/groupmgt/access/{id}",
+        )
+        data = _unwrap_data(response)
+        return {"items": data} if isinstance(data, list) else {"data": data}

+ 8 - 4
src/server_mcp/server.py

@@ -4,14 +4,18 @@ from __future__ import annotations
 
 from mcp.server.fastmcp import FastMCP
 
-from .resources import register_resources
-from .tools import register_tools
+from .resources_element import register_element_resources
+from .resources_groupmgt import register_groupmgt_resources
+from .tools_groupmgt import register_groupmgt_tools
+from .tools_element import register_element_tools
 from src.services.client_rest import ClientRest
 
 
 def build_server(client_rest: ClientRest) -> FastMCP:
     """Construit l'instance MCP et enregistre ses capacités."""
     server = FastMCP("lw-copilot-mcp-server")
-    register_tools(server, client_rest)
-    register_resources(server, client_rest)
+    register_element_tools(server, client_rest)
+    register_groupmgt_tools(server, client_rest)
+    register_element_resources(server, client_rest)
+    register_groupmgt_resources(server, client_rest)
     return server

+ 1 - 1
src/server_mcp/tools.py → src/server_mcp/tools_element.py

@@ -154,7 +154,7 @@ def _search_keyword(html: str, keyword: PageKeyword, offsetTop: PageOffsetTop, s
     end = min(len(html), start + limit)
     return html[start:end]
 
-def register_tools(mcp_server: Any, client_rest: ClientRest) -> None:
+def register_element_tools(mcp_server: Any, client_rest: ClientRest) -> None:
     """Enregistre les outils d'ecriture du serveur MCP."""
 
     @mcp_server.tool(

+ 232 - 0
src/server_mcp/tools_groupmgt.py

@@ -0,0 +1,232 @@
+"""Definition des outils MCP (operations de gestion de groupes)."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from pydantic import Field
+
+from mcp.types import ToolAnnotations
+
+from ..services.client_rest import ClientRest, HTTPMethod
+
+_WRITE_ONLY = ToolAnnotations(readOnlyHint=False, destructiveHint=False)
+_WRITE_DESTRUCTIVE = ToolAnnotations(readOnlyHint=False, destructiveHint=True)
+_WRITE_IDEMPOTENT = ToolAnnotations(
+    readOnlyHint=False, destructiveHint=True, idempotentHint=True
+)
+
+# --- createResourceGroup ---
+ResourceGroupName = Annotated[str, Field(description="name of the resource group")]
+AccessAdmin = Annotated[
+    bool | None,
+    Field(default=None, description="grant the Administrator user group access to the new resource group"),
+]
+AccessAnon = Annotated[
+    bool | None,
+    Field(default=None, description="grant anonymous users view access to the new resource group"),
+]
+AccessParallel = Annotated[
+    bool | None,
+    Field(default=None, description="create a parallel user group with the same name"),
+]
+AccessContexts = Annotated[
+    str | None,
+    Field(default=None, description="comma-separated context keys for access policies"),
+]
+AccessUserGroups = Annotated[
+    str | None,
+    Field(default=None, description="comma-separated user group names to grant access"),
+]
+
+# --- updateResourceGroup / removeResourceGroup ---
+ResourceGroupId = Annotated[int | str, Field(description="resource group id or name")]
+ResourceIds = Annotated[
+    list[int],
+    Field(description="array of resource ids, e.g. [12, 45, 78]"),
+]
+
+# --- createUserGroup ---
+UserGroupName = Annotated[str, Field(description="user group name to create")]
+UserGroupDescription = Annotated[str | None, Field(default=None, description="user group description")]
+Users = Annotated[
+    str | None,
+    Field(default=None, description="comma-separated list of username or username:role key pairs"),
+]
+UserGroupParent = Annotated[int | None, Field(default=None, description="parent of the group")]
+CreateParallelResourceGroup = Annotated[
+    str | None,
+    Field(
+        default=None,
+        description="if set, create a parallel resource group with the same name for the user group",
+    ),
+]
+AddResourceGroups = Annotated[
+    str | None,
+    Field(default=None, description="comma-delimited list of resource group names to add to the user group"),
+]
+
+# --- createAccess / updateAccess ---
+UserGroupId = Annotated[int | str, Field(description="user group id or name")]
+AccessPolicy = Annotated[
+    int | str | None,
+    Field(default=None, description="access policy id or name (default: Resource)"),
+]
+Authority = Annotated[int | None, Field(default=None, description="authority level (minimum user role required)")]
+ContextKey = Annotated[str | None, Field(default=None, description="context key")]
+
+# --- updateAccess / removeAccess ---
+AccessId = Annotated[int, Field(description="ACL access entry id")]
+UserGroupIdRemove = Annotated[int, Field(description="user group id")]
+
+
+def _omit_none(**kwargs: Any) -> dict[str, Any]:
+    return {key: value for key, value in kwargs.items() if value is not None}
+
+
+def register_groupmgt_tools(mcp_server: Any, client_rest: ClientRest) -> None:
+    """Enregistre les outils de gestion de groupes du serveur MCP."""
+
+    @mcp_server.tool(
+        description="Creer un nouveau groupe de ressource.",
+        annotations=_WRITE_ONLY,
+    )
+    def createResourceGroup(
+        name: ResourceGroupName,
+        accessAdmin: AccessAdmin = None,
+        accessAnon: AccessAnon = None,
+        accessParallel: AccessParallel = None,
+        accessContexts: AccessContexts = None,
+        accessUserGroups: AccessUserGroups = None,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.POST,
+            endpoint="/rest/groupmgt/resources",
+            json=_omit_none(
+                name=name,
+                accessAdmin=accessAdmin,
+                accessAnon=accessAnon,
+                accessParallel=accessParallel,
+                accessContexts=accessContexts,
+                accessUserGroups=accessUserGroups,
+            ),
+        )
+
+    @mcp_server.tool(
+        description="Ajouter des ressources MODX a un groupe de ressource existant.",
+        annotations=_WRITE_IDEMPOTENT,
+    )
+    def updateResourceGroup(
+        id: ResourceGroupId,
+        resources: ResourceIds,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.PUT,
+            endpoint="/rest/groupmgt/resources",
+            json={"id": id, "resources": resources},
+        )
+
+    @mcp_server.tool(
+        description="Retirer des ressources MODX d'un groupe de ressource.",
+        annotations=_WRITE_DESTRUCTIVE,
+    )
+    def removeResourceGroup(
+        id: ResourceGroupId,
+        resources: ResourceIds,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.DELETE,
+            endpoint=f"/rest/groupmgt/resources/{id}",
+            params={
+                "resources[]": resources
+            }
+        )
+
+    @mcp_server.tool(
+        description="Creer un nouveau groupe d'utilisateur.",
+        annotations=_WRITE_ONLY,
+    )
+    def createUserGroup(
+        name: UserGroupName,
+        description: UserGroupDescription = None,
+        users: Users = None,
+        parent: UserGroupParent = None,
+        createResourceGroup: CreateParallelResourceGroup = None,
+        addResourceGroups: AddResourceGroups = None,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.POST,
+            endpoint="/rest/groupmgt/group",
+            json=_omit_none(
+                name=name,
+                description=description,
+                users=users,
+                parent=parent,
+                createResourceGroup=createResourceGroup,
+                addResourceGroups=addResourceGroups,
+            ),
+        )
+
+    @mcp_server.tool(
+        description="Creer un acces entre un groupe d'utilisateur et un groupe de ressource.",
+        annotations=_WRITE_ONLY,
+    )
+    def createAccess(
+        id: UserGroupId,
+        resourceGroup: ResourceGroupId,
+        policy: AccessPolicy = None,
+        authority: Authority = None,
+        context: ContextKey = None,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.POST,
+            endpoint="/rest/groupmgt/access",
+            json=_omit_none(
+                id=id,
+                resourceGroup=resourceGroup,
+                policy=policy,
+                authority=authority,
+                context=context,
+            ),
+        )
+
+    @mcp_server.tool(
+        description="Mettre a jour un acces existant entre un groupe d'utilisateur et un groupe de ressource.",
+        annotations=_WRITE_IDEMPOTENT,
+    )
+    def updateAccess(
+        id: UserGroupId,
+        accessId: AccessId,
+        resourceGroup: ResourceGroupId | None = None,
+        policy: AccessPolicy = None,
+        authority: Authority = None,
+        context: ContextKey = None,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.PUT,
+            endpoint="/rest/groupmgt/access",
+            json=_omit_none(
+                id=id,
+                accessId=accessId,
+                resourceGroup=resourceGroup,
+                policy=policy,
+                authority=authority,
+                context=context,
+            ),
+        )
+
+    @mcp_server.tool(
+        description="Supprimer un acces existant entre un groupe d'utilisateur et un groupe de ressource.",
+        annotations=_WRITE_DESTRUCTIVE,
+    )
+    def removeAccess(
+        id: UserGroupIdRemove,
+        accessId: AccessId,
+    ) -> dict[str, Any]:
+        return client_rest.execute(
+            method=HTTPMethod.DELETE,
+            endpoint=f"/rest/groupmgt/access/{id}",
+            params={
+                "accessId": accessId
+            }
+        )