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

package/src/qingflow_mcp/tools/package_tools.py

@@ -62,7 +62,11 @@ class PackageTools(ToolBase):
 
         def runner(session_profile, context):
             result = self.backend.request("GET", context, f"/tag/{tag_id}")
-            compact = self._compact_package(result if isinstance(result, dict) else {})
+            base_info = self.backend.request("GET", context, f"/tag/{tag_id}/baseInfo")
+            compact = self._compact_package(
+                result if isinstance(result, dict) else {},
+                base_info=base_info if isinstance(base_info, dict) else None,
+            )
             response = {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
@@ -77,7 +81,7 @@ class PackageTools(ToolBase):
         return self._run(profile, runner)
 
     def package_get_base(self, *, profile: str, tag_id: int, include_raw: bool = False) -> JSONObject:
-        self._require_tag_id(tag_id)
+        self._require_readable_tag_id(tag_id)
 
         def runner(session_profile, context):
             result = self.backend.request("GET", context, f"/tag/{tag_id}/baseInfo")
@@ -160,6 +164,10 @@ class PackageTools(ToolBase):
         if tag_id <= 0:
             raise_tool_error(QingflowApiError.config_error("tag_id must be positive"))
 
+    def _require_readable_tag_id(self, tag_id: int) -> None:
+        if tag_id < 0:
+            raise_tool_error(QingflowApiError.config_error("tag_id must be non-negative"))
+
     def _normalize_package_payload(self, payload: JSONObject, existing: JSONObject | None = None) -> JSONObject:
         data = deepcopy(existing) if isinstance(existing, dict) else {}
         data.update(deepcopy(payload))
@@ -174,8 +182,9 @@ class PackageTools(ToolBase):
         data.setdefault("auth", _default_package_auth())
         return data
 
-    def _compact_package(self, result: dict[str, object]) -> JSONObject:
+    def _compact_package(self, result: dict[str, object], *, base_info: dict[str, object] | None = None) -> JSONObject:
         tag_items = result.get("tagItems") if isinstance(result.get("tagItems"), list) else []
+        permission_source = base_info if isinstance(base_info, dict) else result
         preview = []
         for item in tag_items[:10]:
             if not isinstance(item, dict):
@@ -191,10 +200,15 @@ class PackageTools(ToolBase):
         compact = {
             "tagId": result.get("tagId"),
             "tagName": result.get("tagName"),
-            "publishStatus": result.get("publishStatus"),
+            "tagIcon": result.get("tagIcon") if result.get("tagIcon") is not None else permission_source.get("tagIcon"),
+            "publishStatus": result.get("publishStatus") if result.get("publishStatus") is not None else permission_source.get("publishStatus"),
             "beingTrial": result.get("beingTrial"),
             "itemCount": len(tag_items),
             "itemPreview": preview,
+            "addAppStatus": permission_source.get("addAppStatus"),
+            "editAppStatus": permission_source.get("editAppStatus"),
+            "delAppStatus": permission_source.get("delAppStatus"),
+            "editTagStatus": permission_source.get("editTagStatus"),
         }
         return {key: value for key, value in compact.items() if value is not None}
 

package/src/qingflow_mcp/tools/portal_tools.py

@@ -18,10 +18,18 @@ class PortalTools(ToolBase):
         def portal_get(profile: str = DEFAULT_PROFILE, dash_key: str = "", being_draft: bool = False) -> JSONObject:
             return self.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft)
 
+        @mcp.tool()
+        def portal_get_base_info(profile: str = DEFAULT_PROFILE, dash_key: str = "") -> JSONObject:
+            return self.portal_get_base_info(profile=profile, dash_key=dash_key)
+
         @mcp.tool()
         def portal_create(profile: str = DEFAULT_PROFILE, payload: JSONObject | None = None) -> JSONObject:
             return self.portal_create(profile=profile, payload=payload or {})
 
+        @mcp.tool(description=self._high_risk_tool_description(operation="update", target="portal base settings"))
+        def portal_update_base_info(profile: str = DEFAULT_PROFILE, dash_key: str = "", payload: JSONObject | None = None) -> JSONObject:
+            return self.portal_update_base_info(profile=profile, dash_key=dash_key, payload=payload or {})
+
         @mcp.tool(description=self._high_risk_tool_description(operation="update", target="portal configuration"))
         def portal_update(profile: str = DEFAULT_PROFILE, dash_key: str = "", payload: JSONObject | None = None) -> JSONObject:
             return self.portal_update(profile=profile, dash_key=dash_key, payload=payload or {})
@@ -59,6 +67,29 @@ class PortalTools(ToolBase):
 
         return self._run(profile, runner)
 
+    def portal_get_base_info(self, *, profile: str, dash_key: str) -> JSONObject:
+        self._require_dash_key(dash_key)
+
+        def runner(session_profile, context):
+            result = self.backend.request("GET", context, f"/dash/{dash_key}/baseInfo")
+            return {"profile": profile, "ws_id": session_profile.selected_ws_id, "dash_key": dash_key, "result": result}
+
+        return self._run(profile, runner)
+
+    def portal_update_base_info(self, *, profile: str, dash_key: str, payload: JSONObject) -> JSONObject:
+        self._require_dash_key(dash_key)
+        body = self._require_dict(payload)
+
+        def runner(session_profile, context):
+            result = self.backend.request("POST", context, f"/dash/{dash_key}/baseInfo", json_body=body)
+            return self._attach_human_review_notice(
+                {"profile": profile, "ws_id": session_profile.selected_ws_id, "dash_key": dash_key, "result": result},
+                operation="update",
+                target="portal base settings",
+            )
+
+        return self._run(profile, runner)
+
     def portal_update(self, *, profile: str, dash_key: str, payload: JSONObject) -> JSONObject:
         self._require_dash_key(dash_key)
         body = self._require_dict(payload)

package/src/qingflow_mcp/tools/qingbi_report_tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from uuid import uuid4
 
 from mcp.server.fastmcp import FastMCP
@@ -18,6 +19,37 @@ def _qingbi_base_url(base_url: str) -> str:
     return normalized[:-4] if normalized.endswith("/api") else normalized
 
 
+def _should_retry_qflow_base(error: QingflowApiError) -> bool:
+    return int(getattr(error, "backend_code", 0) or 0) == 81007
+
+
+def _should_retry_asos_data(error: QingflowApiError) -> bool:
+    backend_code = int(getattr(error, "backend_code", 0) or 0)
+    http_status = getattr(error, "http_status", None)
+    return backend_code in {44011, 81007} or http_status == 404
+
+
+def _coerce_tool_error(error: RuntimeError | QingflowApiError) -> QingflowApiError | None:
+    if isinstance(error, QingflowApiError):
+        return error
+    if not isinstance(error, RuntimeError):
+        return None
+    try:
+        payload = json.loads(str(error))
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    return QingflowApiError(
+        category=str(payload.get("category") or "runtime"),
+        message=str(payload.get("message") or str(error)),
+        backend_code=payload.get("backend_code"),
+        request_id=payload.get("request_id"),
+        http_status=payload.get("http_status"),
+        details=payload.get("details") if isinstance(payload.get("details"), dict) else None,
+    )
+
+
 class QingbiReportTools(ToolBase):
     def register(self, mcp: FastMCP) -> None:
         @mcp.tool()
@@ -95,13 +127,45 @@ class QingbiReportTools(ToolBase):
         self._require_app_key(app_key)
         return self._request(profile, "GET", f"/qingbi/charts/data/bichart/{app_key}", app_key=app_key, items_key="items")
 
+    def qingbi_report_list_sorted(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        page_num: int = 1,
+        page_size: int = 500,
+        search_key: str | None = None,
+    ) -> JSONObject:
+        self._require_app_key(app_key)
+        body: JSONObject = {"appKey": app_key, "pageNum": page_num, "pageSize": page_size}
+        if search_key:
+            body["searchKey"] = search_key
+        return self._request(
+            profile,
+            "POST",
+            "/qingbi/charts/chart/list",
+            app_key=app_key,
+            page_num=page_num,
+            page_size=page_size,
+            search_key=search_key,
+            items_key="items",
+            result_transform=_extract_sorted_chart_items,
+            json_body=body,
+        )
+
     def qingbi_report_create(self, *, profile: str, payload: JSONObject) -> JSONObject:
         body = self._require_dict(payload)
         return self._request(profile, "POST", "/qingbi/charts", json_body=body)
 
     def qingbi_report_get_base(self, *, profile: str, chart_id: str) -> JSONObject:
         self._require_chart_id(chart_id)
-        return self._request(profile, "GET", f"/qingbi/charts/baseinfo/{chart_id}", chart_id=chart_id)
+        try:
+            return self._request(profile, "GET", f"/qingbi/charts/baseinfo/{chart_id}", chart_id=chart_id)
+        except (QingflowApiError, RuntimeError) as raw_error:
+            error = _coerce_tool_error(raw_error)
+            if error is None or not _should_retry_qflow_base(error):
+                raise
+        return self._request(profile, "GET", f"/qingbi/charts/qflow/baseinfo/{chart_id}", chart_id=chart_id)
 
     def qingbi_report_update_base(self, *, profile: str, chart_id: str, payload: JSONObject) -> JSONObject:
         self._require_chart_id(chart_id)
@@ -129,16 +193,46 @@ class QingbiReportTools(ToolBase):
         page_size_y: int | None = None,
     ) -> JSONObject:
         self._require_chart_id(chart_id)
-        params = {"qfUUID": uuid4().hex}
-        if page_num is not None:
-            params["pageNum"] = page_num
-        if page_size is not None:
-            params["pageSize"] = page_size
+        params = {
+            "qfUUID": uuid4().hex,
+            # Match Qingflow's real BI/qflow read path defaults so a caller can
+            # fetch chart data without having to synthesize pagination first.
+            "pageNum": page_num if page_num is not None else 1,
+            "pageSize": page_size if page_size is not None else 20,
+        }
         if page_num_y is not None:
             params["pageNumY"] = page_num_y
         if page_size_y is not None:
             params["pageSizeY"] = page_size_y
-        return self._request(profile, "POST", f"/qingbi/charts/data/{chart_id}", chart_id=chart_id, params=params, json_body=payload)
+        try:
+            if payload:
+                return self._request(
+                    profile,
+                    "POST",
+                    f"/qingbi/charts/data/qflow/{chart_id}/detail",
+                    chart_id=chart_id,
+                    params=params,
+                    json_body=payload,
+                )
+            return self._request(
+                profile,
+                "GET",
+                f"/qingbi/charts/data/qflow/{chart_id}",
+                chart_id=chart_id,
+                params=params,
+            )
+        except (QingflowApiError, RuntimeError) as raw_error:
+            error = _coerce_tool_error(raw_error)
+            if error is None or not _should_retry_asos_data(error):
+                raise
+        return self._request(
+            profile,
+            "POST",
+            f"/qingbi/charts/data/qflow/{chart_id}/asos",
+            chart_id=chart_id,
+            params=params,
+            json_body=payload or {},
+        )
 
     def qingbi_report_delete(self, *, profile: str, chart_id: str) -> JSONObject:
         self._require_chart_id(chart_id)
@@ -233,3 +327,11 @@ def _extract_dataset_fields(result: JSONValue) -> list[JSONObject]:
     if isinstance(result, list):
         return result
     return []
+
+
+def _extract_sorted_chart_items(result: JSONValue) -> list[JSONObject]:
+    if isinstance(result, dict) and isinstance(result.get("list"), list):
+        return result["list"]
+    if isinstance(result, list):
+        return result
+    return []