@josephyan/qingflow-app-builder-mcp 0.2.0-beta.7 → 0.2.0-beta.71

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -105,21 +105,27 @@ class WorkspaceTools(ToolBase):
                 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}"}
+                    result = self._workspace_from_list(call_context, ws_id) or {"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
+            if isinstance(result, dict):
+                ws_name = (
+                    str(result.get("workspaceName") or result.get("wsName") or "").strip()
+                    or None
+                )
+                if ws_name is None:
+                    fallback_workspace = self._workspace_from_list(call_context, ws_id)
+                    if isinstance(fallback_workspace, dict):
+                        result = fallback_workspace
+                        ws_name = (
+                            str(result.get("workspaceName") or result.get("wsName") or "").strip()
+                            or None
+                        )
+            else:
+                ws_name = None
+            if ws_name is None:
+                ws_name = f"Workspace {ws_id}"
             session_profile = self.sessions.select_workspace(profile, ws_id=ws_id, ws_name=ws_name)
             workspace_qf_version = self._workspace_system_version(result)
             should_refresh_route = (
@@ -133,26 +139,54 @@ class WorkspaceTools(ToolBase):
                     qf_version=workspace_qf_version,
                     qf_version_source="workspace_system_version",
                 )
+            active_context = 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,
+            )
+            workspace_version = self._workspace_version_summary(
+                self._fetch_workspace_account_info(active_context),
+                workspace_base_info=self._fetch_workspace_base_info(active_context),
+                workspace_detail=result,
+            )
             return {
                 "profile": profile,
                 "selected_ws_id": session_profile.selected_ws_id,
                 "selected_ws_name": session_profile.selected_ws_name,
                 "workspace": result,
+                "workspace_version": workspace_version,
                 "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,
-                    )
+                    active_context
                 ),
             }
 
         return self._run(profile, runner, require_workspace=False)
 
+    def _workspace_from_list(self, context: BackendRequestContext, ws_id: int) -> dict[str, Any] | None:
+        try:
+            payload = self.backend.request(
+                "POST",
+                context,
+                "/user/workspaceList/pageQuery",
+                json_body={"pageNum": 1, "pageSize": 100, "authList": [0, 1, 2]},
+            )
+        except Exception:
+            return None
+        workspaces = payload.get("list", []) if isinstance(payload, dict) else []
+        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_system_version(self, workspace: Any) -> str | None:
         if not isinstance(workspace, dict):
             return None
@@ -162,6 +196,116 @@ class WorkspaceTools(ToolBase):
         normalized = str(value).strip()
         return normalized or None
 
+    def _fetch_workspace_base_info(self, context: BackendRequestContext) -> dict[str, Any] | None:
+        try:
+            payload = self.backend.request("GET", context, "/ws/baseInfo")
+        except QingflowApiError:
+            return None
+        return payload if isinstance(payload, dict) else None
+
+    def _fetch_workspace_account_info(self, context: BackendRequestContext) -> dict[str, Any] | None:
+        try:
+            payload = self.backend.request("GET", context, "/ws/account")
+        except QingflowApiError:
+            return None
+        return payload if isinstance(payload, dict) else None
+
+    def _workspace_version_summary(
+        self,
+        payload: Any,
+        *,
+        workspace_base_info: Any,
+        workspace_detail: Any,
+    ) -> dict[str, Any]:
+        account_info = payload if isinstance(payload, dict) else {}
+        base_info = workspace_base_info if isinstance(workspace_base_info, dict) else {}
+        detail_info = workspace_detail if isinstance(workspace_detail, dict) else {}
+        level_code = self._first_present_int(
+            account_info.get("accountLevel"),
+            base_info.get("accountLevel"),
+            detail_info.get("accountLevel"),
+        )
+        level_name = self._account_level_name(level_code)
+        return {
+            "level_code": level_code,
+            "level_name": level_name,
+            "display_name": self._account_level_display_name(level_name),
+            "being_trial": self._first_present_bool(
+                account_info.get("trial"),
+                base_info.get("trial"),
+                detail_info.get("trial"),
+            ),
+            "expire_date": self._first_present_value(
+                account_info.get("expireDate"),
+                base_info.get("expireDate"),
+                detail_info.get("expireDate"),
+            ),
+        }
+
+    def _account_level_name(self, level_code: int | None) -> str | None:
+        mapping = {
+            0: "FREE",
+            10: "AIR",
+            20: "BASIC",
+            30: "TEAM",
+            35: "PROFESSIONAL",
+            40: "ENTERPRISE",
+        }
+        return mapping.get(level_code)
+
+    def _account_level_display_name(self, level_name: str | None) -> str | None:
+        mapping = {
+            "FREE": "免费版",
+            "AIR": "Air版",
+            "BASIC": "Pro版",
+            "TEAM": "团队版",
+            "PROFESSIONAL": "专业版",
+            "ENTERPRISE": "企业版",
+        }
+        return mapping.get(level_name)
+
+    def _coerce_int(self, value: Any) -> int | None:
+        if isinstance(value, bool) or value is None:
+            return None
+        if isinstance(value, int):
+            return value
+        try:
+            return int(str(value).strip())
+        except (TypeError, ValueError):
+            return None
+
+    def _coerce_bool(self, value: Any) -> bool | None:
+        if isinstance(value, bool):
+            return value
+        if value is None:
+            return None
+        normalized = str(value).strip().lower()
+        if normalized in {"true", "1"}:
+            return True
+        if normalized in {"false", "0"}:
+            return False
+        return None
+
+    def _first_present_int(self, *values: Any) -> int | None:
+        for value in values:
+            coerced = self._coerce_int(value)
+            if coerced is not None:
+                return coerced
+        return None
+
+    def _first_present_bool(self, *values: Any) -> bool | None:
+        for value in values:
+            coerced = self._coerce_bool(value)
+            if coerced is not None:
+                return coerced
+        return None
+
+    def _first_present_value(self, *values: Any) -> Any:
+        for value in values:
+            if value is not None:
+                return value
+        return None
+
     def workspace_set_plugin_status(
         self,
         *,