@josephyan/qingflow-app-builder-mcp 1.1.25 → 1.1.26

package/src/qingflow_mcp/tools/app_tools.py

@@ -7,7 +7,7 @@ from mcp.server.fastmcp import FastMCP
 
 from ..backend_client import BackendRequestContext
 from ..config import DEFAULT_PROFILE
-from ..errors import QingflowApiError, backend_code_int, is_auth_like_error, raise_tool_error
+from ..errors import QingflowApiError, raise_tool_error
 from ..json_types import JSONObject
 from ..list_type_labels import SYSTEM_VIEW_DEFINITIONS, get_app_publish_status_label
 from ..solution.compiler.icon_utils import workspace_icon_config
@@ -132,20 +132,6 @@ class AppTools(ToolBase):
                 matched.append(item)
         return matched
 
-    def _resolve_visible_app(self, context: BackendRequestContext, app_key: str) -> JSONObject | None:
-        """Resolve app display metadata from the current user's visible app tree."""
-        try:
-            result = self.backend.request("GET", context, "/tag/apps")
-        except QingflowApiError as exc:
-            if not _is_optional_app_metadata_error(exc):
-                raise
-            return None
-        items, _source_shape = self._extract_visible_apps(result)
-        for item in items:
-            if str(item.get("app_key") or "").strip() == app_key:
-                return item
-        return None
-
     @tool_cn_name("应用搜索")
     def app_search(self, *, profile: str, keyword: str = "", page_num: int = 1, page_size: int = 50) -> JSONObject:
         """Search apps by keyword in name/title using backend search API.
@@ -155,50 +141,9 @@ class AppTools(ToolBase):
             params: JSONObject = {"pageNum": page_num, "pageSize": page_size}
             if keyword:
                 params["queryKey"] = keyword
-
-            warnings: list[JSONObject] = []
-            source = "app_item_search"
-            try:
-                result = self.backend.request("GET", context, "/app/item", params=params)
-            except QingflowApiError as exc:
-                if is_auth_like_error(exc):
-                    raise
-                if not _is_optional_app_metadata_error(exc):
-                    raise
-                visible_payload = self.backend.request("GET", context, "/tag/apps")
-                all_apps, source_shape = self._extract_visible_apps(visible_payload)
-                matched_apps = self._filter_visible_apps(all_apps, keyword) if keyword else all_apps
-                page_start = max(page_num - 1, 0) * page_size
-                page_end = page_start + page_size
-                apps = matched_apps[page_start:page_end]
-                warnings.append(
-                    {
-                        "code": "APP_SEARCH_FALLBACK_VISIBLE_APPS",
-                        "message": (
-                            "app_search used the current user's visible app tree because the global app search "
-                            "endpoint is unavailable in this permission context."
-                        ),
-                        "backend_code": exc.backend_code,
-                        "http_status": exc.http_status,
-                        "request_id": exc.request_id,
-                    }
-                )
-                return {
-                    "profile": profile,
-                    "ws_id": session_profile.selected_ws_id,
-                    "keyword": keyword,
-                    "page_num": page_num,
-                    "page_size": page_size,
-                    "total": len(matched_apps),
-                    "items": apps,
-                    "apps": apps,
-                    "source": "visible_apps_fallback",
-                    "source_shape": source_shape,
-                    "unfiltered_count": len(all_apps),
-                    "matched_count": len(matched_apps),
-                    "warnings": warnings,
-                }
-
+            
+            result = self.backend.request("GET", context, "/app/item", params=params)
+            
             apps = []
             if isinstance(result, dict):
                 items = result.get("list", [])
@@ -223,7 +168,6 @@ class AppTools(ToolBase):
                 "total": result.get("total") if isinstance(result, dict) else len(apps),
                 "items": apps,
                 "apps": apps,
-                "source": source,
             }
 
         return self._run(profile, runner)
@@ -238,7 +182,6 @@ class AppTools(ToolBase):
             app_name = app_key
             base_info: JSONObject | None = None
             app_icon = None
-            visible_app: JSONObject | None = None
 
             try:
                 base_info = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
@@ -249,31 +192,31 @@ class AppTools(ToolBase):
                     )
                     app_icon = str(base_info.get("appIcon") or "").strip() or None
             except QingflowApiError as exc:
-                if not _is_optional_app_metadata_error(exc):
+                if exc.backend_code not in {40002, 40027}:
                     raise
-                visible_app = self._resolve_visible_app(context, app_key)
-                if visible_app is not None:
-                    app_name = str(visible_app.get("app_name") or visible_app.get("title") or app_key).strip() or app_key
-                    app_icon = str(visible_app.get("app_icon") or "").strip() or None
                 warnings.append(
-                    _with_api_error_fields(
-                        {
+                    {
                         "code": "APP_BASE_INFO_UNAVAILABLE",
+                        "message": f"app_get could not load base info for {app_key}; using app_key as app_name.",
+                    }
+                )
+
+            try:
+                can_create = self._probe_create_access(context, app_key)
+            except QingflowApiError as exc:
+                can_create = False
+                warnings.append(
+                    {
+                        "code": "APP_CREATE_PROBE_UNVERIFIED",
                         "message": (
-                            f"app_get could not load base info for {app_key}; "
-                            "using the current user's visible app tree when available."
+                            f"app_get could not fully verify create access for {app_key}: "
+                            f"{exc.message or 'probe failed'}"
                         ),
-                        },
-                        exc,
-                    )
+                    }
                 )
-
-            can_create = self._probe_create_access(context, app_key)
             accessible_views, system_view_warnings = self._resolve_accessible_system_views(context, app_key)
             warnings.extend(system_view_warnings)
-            custom_views, custom_view_warnings = self._resolve_accessible_custom_views(context, app_key)
-            warnings.extend(custom_view_warnings)
-            accessible_views.extend(custom_views)
+            accessible_views.extend(self._resolve_accessible_custom_views(context, app_key))
             import_capability, import_warnings = _derive_import_capability(base_info)
             warnings.extend(import_warnings)
             return {
@@ -287,7 +230,6 @@ class AppTools(ToolBase):
                     "app_name": app_name,
                     "app_icon": app_icon,
                     "icon_config": workspace_icon_config(app_icon),
-                    **({"visible_app": visible_app} if base_info is None and visible_app is not None else {}),
                     "can_create": can_create,
                     "import_capability": import_capability,
                     "accessible_views": accessible_views,
@@ -302,30 +244,7 @@ class AppTools(ToolBase):
         self._require_app_key(app_key)
 
         def runner(session_profile, context):
-            warnings: list[JSONObject] = []
-            verification: JSONObject = {"base_info_verified": True, "fallback_visible_app_used": False}
-            try:
-                result = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
-            except QingflowApiError as exc:
-                if not _is_optional_app_metadata_error(exc):
-                    raise
-                visible_app = self._resolve_visible_app(context, app_key)
-                if visible_app is None:
-                    raise
-                result = self._base_info_from_visible_app(app_key, visible_app)
-                warnings.append(
-                    _with_api_error_fields(
-                        {
-                        "code": "APP_BASE_INFO_UNAVAILABLE",
-                        "message": (
-                            f"app_get_base could not load base info for {app_key}; "
-                            "using the current user's visible app tree."
-                        ),
-                        },
-                        exc,
-                    )
-                )
-                verification = {"base_info_verified": False, "fallback_visible_app_used": True}
+            result = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
             publish_status = result.get("appPublishStatus") if isinstance(result, dict) else None
             compact = self._compact_base_info(result if isinstance(result, dict) else {})
             response = {
@@ -336,10 +255,7 @@ class AppTools(ToolBase):
                 "app_publish_status": publish_status,
                 "app_publish_status_label": get_app_publish_status_label(publish_status if isinstance(publish_status, int) else None),
                 "compact": not include_raw,
-                "verification": verification,
             }
-            if warnings:
-                response["warnings"] = warnings
             if include_raw:
                 response["summary"] = compact
             return response
@@ -573,9 +489,7 @@ class AppTools(ToolBase):
             )
             return True
         except QingflowApiError as exc:
-            if is_auth_like_error(exc):
-                raise
-            if backend_code_int(exc) in {40002, 40027, 404} or exc.http_status == 404:
+            if exc.backend_code in {40002, 40027}:
                 return False
             raise
 
@@ -590,9 +504,7 @@ class AppTools(ToolBase):
             )
             return True
         except QingflowApiError as exc:
-            if is_auth_like_error(exc):
-                raise
-            if backend_code_int(exc) in {40002, 40027, 404} or exc.http_status == 404:
+            if exc.backend_code in {40002, 40027}:
                 return False
             raise
 
@@ -604,42 +516,40 @@ class AppTools(ToolBase):
             try:
                 can_access = self._probe_list_type_access(context, app_key, list_type)
             except QingflowApiError as exc:
-                raise
+                warnings.append(
+                    {
+                        "code": "SYSTEM_VIEW_PROBE_UNVERIFIED",
+                        "message": (
+                            f"app_get skipped system view '{name}' because access probing failed: "
+                            f"{exc.message or 'probe failed'}"
+                        ),
+                        "view_id": view_id,
+                        "list_type": list_type,
+                    }
+                )
+                continue
             if not can_access:
                 continue
             items.append({"view_id": view_id, "name": name, "kind": "system", "analysis_supported": True})
         return items, warnings
 
-    def _resolve_accessible_custom_views(self, context: BackendRequestContext, app_key: str) -> tuple[list[JSONObject], list[JSONObject]]:
+    def _resolve_accessible_custom_views(self, context: BackendRequestContext, app_key: str) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
-        warnings: list[JSONObject] = []
         try:
             payload = self.backend.request("GET", context, f"/app/{app_key}/view/viewList")
         except QingflowApiError as exc:
-            if _is_optional_app_metadata_error(exc):
-                warnings.append(
-                    _with_api_error_fields(
-                        {
-                        "code": "CUSTOM_VIEW_LIST_UNAVAILABLE",
-                        "message": (
-                            f"app_get could not load custom views for {app_key}; "
-                            "system views and other app metadata may still be usable."
-                        ),
-                        },
-                        exc,
-                    )
-                )
-                return [], warnings
+            if exc.backend_code in {40002, 40027}:
+                return []
             raise
 
         items: list[JSONObject] = []
         for item in _normalize_view_list(payload):
-            view_key = str(item.get("viewKey") or item.get("viewgraphKey") or "").strip()
+            view_key = str(item.get("viewKey") or "").strip()
             if not view_key:
                 continue
             normalized: JSONObject = {
                 "view_id": f"custom:{view_key}",
-                "name": str(item.get("viewName") or item.get("viewgraphName") or view_key).strip() or view_key,
+                "name": str(item.get("viewName") or view_key).strip() or view_key,
                 "kind": "custom",
             }
             view_type = str(item.get("viewType") or item.get("viewgraphType") or "").strip()
@@ -647,7 +557,7 @@ class AppTools(ToolBase):
                 normalized["view_type"] = view_type
             normalized["analysis_supported"] = _analysis_supported_for_view_type(view_type or None)
             items.append(normalized)
-        return items, warnings
+        return items
 
     def _compact_base_info(self, result: dict[str, Any]) -> JSONObject:
         """执行内部辅助逻辑。"""
@@ -691,30 +601,6 @@ class AppTools(ToolBase):
             },
         }
 
-    def _base_info_from_visible_app(self, app_key: str, visible_app: JSONObject) -> JSONObject:
-        """Build a base-info-shaped fallback from a current-user visible app item."""
-        tag_ids: list[int] = []
-        tag_id = _coerce_positive_int(visible_app.get("tag_id"))
-        if tag_id is not None:
-            tag_ids.append(tag_id)
-        for value in visible_app.get("tag_ids") if isinstance(visible_app.get("tag_ids"), list) else []:
-            tag_id = _coerce_positive_int(value)
-            if tag_id is not None and tag_id not in tag_ids:
-                tag_ids.append(tag_id)
-
-        fallback: JSONObject = {
-            "appKey": app_key,
-            "formId": visible_app.get("form_id"),
-            "formTitle": visible_app.get("app_name") or visible_app.get("title") or app_key,
-            "appIcon": visible_app.get("app_icon"),
-            "tagIds": tag_ids,
-            "visibleApp": visible_app,
-        }
-        package_name = visible_app.get("package_name") or visible_app.get("tag_name") or visible_app.get("group_name")
-        if package_name:
-            fallback["tagItems"] = [{"tagId": tag_id, "tagName": package_name} for tag_id in tag_ids]
-        return fallback
-
     def _compact_form_schema(self, result: dict[str, Any]) -> JSONObject:
         """执行内部辅助逻辑。"""
         base_questions_raw = result.get("baseQues") if isinstance(result.get("baseQues"), list) else []
@@ -873,7 +759,6 @@ class AppTools(ToolBase):
             "app_key": app_key,
             "app_name": title,
             "title": title,
-            "app_icon": str(item.get("appIcon") or "").strip() or None,
             "form_id": item.get("formId"),
             "tag_id": package_tag_id,
             "package_name": package_name,
@@ -934,26 +819,17 @@ def _normalize_form_type(value: int | str) -> int:
 
 
 def _normalize_view_list(payload: Any) -> list[JSONObject]:
-    if isinstance(payload, dict):
-        raw_list = payload.get("list")
-        if isinstance(raw_list, list):
-            payload = raw_list
-        else:
-            payload = [payload]
     if not isinstance(payload, list):
         return []
     flattened: list[JSONObject] = []
     for group in payload:
         if not isinstance(group, dict):
             continue
-        if group.get("viewKey") or group.get("viewgraphKey"):
-            flattened.append(group)
-            continue
         view_list = group.get("viewList")
         if not isinstance(view_list, list):
             continue
         for item in view_list:
-            if isinstance(item, dict) and (item.get("viewKey") or item.get("viewgraphKey")):
+            if isinstance(item, dict) and item.get("viewKey"):
                 flattened.append(item)
     return flattened
 
@@ -965,23 +841,6 @@ def _analysis_supported_for_view_type(view_type: str | None) -> bool:
     return normalized not in {"boardview", "ganttview"}
 
 
-def _is_optional_app_metadata_error(error: QingflowApiError) -> bool:
-    if is_auth_like_error(error):
-        return False
-    backend_code = backend_code_int(error)
-    return backend_code in {40002, 40027, 404} or error.http_status == 404
-
-
-def _with_api_error_fields(payload: JSONObject, error: QingflowApiError) -> JSONObject:
-    if error.backend_code is not None:
-        payload["backend_code"] = error.backend_code
-    if error.http_status is not None:
-        payload["http_status"] = error.http_status
-    if error.request_id:
-        payload["request_id"] = error.request_id
-    return payload
-
-
 def _derive_import_capability(base_info: Any) -> tuple[JSONObject, list[JSONObject]]:
     warnings: list[JSONObject] = []
     if not isinstance(base_info, dict):