@qingflow-tech/qingflow-app-builder-mcp 1.0.2 → 1.0.3

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -35,6 +35,26 @@ class WorkspaceTools(ToolBase):
                 include_external=include_external,
             )
 
+        @mcp.tool()
+        def workspace_get(
+            profile: str = DEFAULT_PROFILE,
+            ws_id: int = 0,
+        ) -> dict[str, Any]:
+            return self.workspace_get(
+                profile=profile,
+                ws_id=ws_id if ws_id > 0 else None,
+            )
+
+        @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,
@@ -93,6 +113,68 @@ class WorkspaceTools(ToolBase):
 
         return self._run(profile, runner, require_workspace=False)
 
+    @tool_cn_name("工作区详情")
+    def workspace_get(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        ws_id: int | None = None,
+    ) -> dict[str, Any]:
+        """读取单个工作区详情，并尽量补齐真实 systemVersion。"""
+
+        def runner(session_profile, context):
+            target_ws_id = ws_id or (session_profile.selected_ws_id if session_profile is not None else None)
+            if target_ws_id is None or target_ws_id <= 0:
+                raise_tool_error(QingflowApiError.workspace_not_selected(profile))
+            workspace = self._fetch_workspace_with_fallback(context, ws_id=target_ws_id)
+            system_version = self._workspace_system_version(workspace)
+            return {
+                "profile": profile,
+                "ws_id": target_ws_id,
+                "qf_version": system_version,
+                "qf_version_source": "workspace_system_version" if system_version else "unverified",
+                "workspace": workspace,
+            }
+
+        return self._run(profile, runner, require_workspace=False)
+
+    @tool_cn_name("切换工作区")
+    def workspace_select(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        ws_id: int,
+    ) -> dict[str, Any]:
+        """切换当前 profile 选中的工作区，并尽量同步真实 systemVersion。"""
+        if ws_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("ws_id must be positive"))
+
+        def runner(_, context):
+            workspace = self._fetch_workspace_with_fallback(context, ws_id=ws_id)
+            workspace_name = str(workspace.get("workspaceName") or workspace.get("wsName") or workspace.get("remark") or "").strip() or None
+            selected = self.sessions.select_workspace(profile, ws_id=ws_id, ws_name=workspace_name)
+            system_version = self._workspace_system_version(workspace)
+            qf_version_source = "workspace_system_version" if system_version else "unverified"
+            if system_version:
+                selected = self.sessions.update_route(
+                    profile,
+                    qf_version=system_version,
+                    qf_version_source=qf_version_source,
+                )
+            return {
+                "profile": profile,
+                "ws_id": ws_id,
+                "qf_version": selected.qf_version,
+                "qf_version_source": selected.qf_version_source or qf_version_source,
+                "workspace": workspace,
+                "selected": {
+                    "ws_id": selected.selected_ws_id,
+                    "workspace_name": selected.selected_ws_name,
+                },
+            }
+
+        return self._run(profile, runner, require_workspace=False)
+
     @tool_cn_name("设置工作区插件状态")
     def workspace_set_plugin_status(
         self,
@@ -123,3 +205,62 @@ class WorkspaceTools(ToolBase):
             }
 
         return self._run(profile, runner)
+
+    def _fetch_workspace_with_fallback(
+        self,
+        context: BackendRequestContext,
+        *,
+        ws_id: int,
+    ) -> dict[str, Any]:
+        workspace = self.backend.request("GET", context, f"/user/workspace/{ws_id}")
+        if not isinstance(workspace, dict):
+            raise_tool_error(QingflowApiError(category="workspace", message=f"Workspace {ws_id} is not accessible"))
+        if self._workspace_needs_list_fallback(workspace):
+            fallback = self._fetch_workspace_from_list(context, ws_id=ws_id)
+            if isinstance(fallback, dict):
+                merged = dict(workspace)
+                for key, value in fallback.items():
+                    if merged.get(key) in (None, "") and value not in (None, ""):
+                        merged[key] = value
+                workspace = merged
+        return workspace
+
+    def _fetch_workspace_from_list(self, context: BackendRequestContext, *, ws_id: int) -> dict[str, Any] | None:
+        payload = self.backend.request(
+            "POST",
+            BackendRequestContext(
+                base_url=context.base_url,
+                token=context.token,
+                ws_id=None,
+                qf_version=context.qf_version,
+                qf_version_source=context.qf_version_source,
+            ),
+            "/user/workspaceList/pageQuery",
+            json_body={"pageNum": 1, "pageSize": 100, "authList": [0, 1, 2, 3]},
+        )
+        workspaces = payload.get("list") if isinstance(payload, dict) else []
+        if not isinstance(workspaces, list):
+            return None
+        found = next(
+            (
+                item
+                for item in workspaces
+                if isinstance(item, dict) and item.get("wsId") == ws_id
+            ),
+            None,
+        )
+        return found if isinstance(found, dict) else None
+
+    def _workspace_needs_list_fallback(self, workspace: dict[str, Any]) -> bool:
+        workspace_name = str(workspace.get("workspaceName") or workspace.get("wsName") or "").strip()
+        system_version = self._workspace_system_version(workspace)
+        return not workspace_name or system_version is None
+
+    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