@josephyan/qingflow-app-builder-mcp 0.1.0-beta.9

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from ..backend_client import BackendRequestContext
+from ..config import DEFAULT_PROFILE
+from ..errors import QingflowApiError, raise_tool_error
+from .base import ToolBase
+
+
+class WorkspaceTools(ToolBase):
+    def register(self, mcp: FastMCP) -> None:
+        @mcp.tool()
+        def workspace_list(
+            profile: str = DEFAULT_PROFILE,
+            page_num: int = 1,
+            page_size: int = 20,
+            include_external: bool = False,
+        ) -> dict[str, Any]:
+            return self.workspace_list(
+                profile=profile,
+                page_num=page_num,
+                page_size=page_size,
+                include_external=include_external,
+            )
+
+        @mcp.tool()
+        def workspace_select(profile: str = DEFAULT_PROFILE, ws_id: int = 0) -> dict[str, Any]:
+            return self.workspace_select(profile=profile, ws_id=ws_id)
+
+        @mcp.tool()
+        def workspace_set_plugin_status(
+            profile: str = DEFAULT_PROFILE,
+            plugin_id: int = 0,
+            being_installed: bool = True,
+        ) -> dict[str, Any]:
+            return self.workspace_set_plugin_status(
+                profile=profile,
+                plugin_id=plugin_id,
+                being_installed=being_installed,
+            )
+
+    def workspace_list(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        page_num: int = 1,
+        page_size: int = 20,
+        include_external: bool = False,
+    ) -> dict[str, Any]:
+        if page_num <= 0 or page_size <= 0:
+            raise_tool_error(QingflowApiError.config_error("page_num and page_size must be positive"))
+
+        def runner(_, context):
+            path = "/user/allWorkspaceList/pageQuery" if include_external else "/user/workspaceList/pageQuery"
+            result = self.backend.request(
+                "POST",
+                context,
+                path,
+                json_body={"pageNum": page_num, "pageSize": page_size, "authList": [0, 1, 2]},
+            )
+            return {
+                "profile": profile,
+                "include_external": include_external,
+                "page": result,
+            }
+
+        return self._run(profile, runner, require_workspace=False)
+
+    def workspace_select(self, *, profile: str = DEFAULT_PROFILE, ws_id: int) -> dict[str, Any]:
+        if ws_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("ws_id must be positive"))
+
+        def runner(_, context):
+            # Create a context with the target ws_id for the API call
+            # This is necessary because the API requires wsId header even when getting workspace details
+            call_context = BackendRequestContext(
+                base_url=context.base_url,
+                token=context.token,
+                ws_id=ws_id,
+                qf_version=context.qf_version,
+                qf_version_source=context.qf_version_source,
+            )
+            
+            try:
+                result = self.backend.request("GET", call_context, f"/user/workspace/{ws_id}")
+            except QingflowApiError as e:
+                if e.http_status == 404:
+                    # Fallback: try to find the workspace name from the list
+                    try:
+                        workspaces_data = self.backend.request("POST", call_context, "/user/workspaceList/pageQuery", json_body={"pageNum": 1, "pageSize": 100, "authList": [0, 1, 2]})
+                        workspaces = workspaces_data.get("list", []) if isinstance(workspaces_data, dict) else []
+                        found = next((ws for ws in workspaces if ws.get("wsId") == ws_id), None)
+                        if found:
+                            result = found
+                        else:
+                            result = {"wsId": ws_id, "workspaceName": f"Workspace {ws_id}"}
+                    except Exception:
+                        result = {"wsId": ws_id, "workspaceName": f"Workspace {ws_id}"}
+                else:
+                    raise
+
+            ws_name = result.get("workspaceName") or result.get("wsName") if isinstance(result, dict) else None
+            session_profile = self.sessions.select_workspace(profile, ws_id=ws_id, ws_name=ws_name)
+            workspace_qf_version = self._workspace_system_version(result)
+            if context.qf_version is None and workspace_qf_version is not None:
+                session_profile = self.sessions.update_route(
+                    profile,
+                    qf_version=workspace_qf_version,
+                    qf_version_source="workspace_system_version",
+                )
+            return {
+                "profile": profile,
+                "selected_ws_id": session_profile.selected_ws_id,
+                "selected_ws_name": session_profile.selected_ws_name,
+                "workspace": result,
+                "qf_version": session_profile.qf_version,
+                "qf_version_source": session_profile.qf_version_source,
+                "request_route": self.backend.describe_route(
+                    BackendRequestContext(
+                        base_url=session_profile.base_url,
+                        token=context.token,
+                        ws_id=session_profile.selected_ws_id,
+                        qf_version=session_profile.qf_version,
+                        qf_version_source=session_profile.qf_version_source,
+                    )
+                ),
+            }
+
+        return self._run(profile, runner, require_workspace=False)
+
+    def _workspace_system_version(self, workspace: Any) -> str | None:
+        if not isinstance(workspace, dict):
+            return None
+        value = workspace.get("systemVersion")
+        if value is None:
+            return None
+        normalized = str(value).strip()
+        return normalized or None
+
+    def workspace_set_plugin_status(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        plugin_id: int,
+        being_installed: bool = True,
+    ) -> dict[str, Any]:
+        if plugin_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("plugin_id must be positive"))
+
+        def runner(_, context):
+            result = self.backend.request(
+                "POST",
+                context,
+                "/ws/plugin",
+                json_body={
+                    "pluginId": plugin_id,
+                    "beingInstalled": being_installed,
+                },
+            )
+            return {
+                "profile": profile,
+                "plugin_id": plugin_id,
+                "being_installed": being_installed,
+                "result": result,
+            }
+
+        return self._run(profile, runner)