@josephyan/qingflow-cli 0.2.0-beta.58 → 0.2.0-beta.60

package/src/qingflow_mcp/solution/executor.py

@@ -236,8 +236,14 @@ class SolutionExecutor:
         existing_role_id = existing.get("role_id")
         if existing_role_id:
             return
-        page = self.role_tools.role_search(profile=profile, keyword=role.name, page_num=1, page_size=50).get("page") or {}
-        role_list = page.get("list") if isinstance(page, dict) else []
+        try:
+            page = self.role_tools.role_search(profile=profile, keyword=role.name, page_num=1, page_size=50).get("page") or {}
+            role_list = page.get("list") if isinstance(page, dict) else []
+        except Exception as exc:  # noqa: BLE001
+            api_error = _coerce_qingflow_error(exc)
+            if api_error is None or not _is_permission_restricted_error(api_error):
+                raise
+            role_list = []
         matched_role = next(
             (
                 item
@@ -312,7 +318,18 @@ class SolutionExecutor:
         if not isinstance(app_key, str) or not app_key:
             raise ValueError(f"missing app_key for package attach on entity '{entity.entity_id}'")
 
-        package_detail = self.package_tools.package_get(profile=profile, tag_id=tag_id, include_raw=True)
+        try:
+            package_detail = self.package_tools.package_get(profile=profile, tag_id=tag_id, include_raw=True)
+        except Exception as exc:  # noqa: BLE001
+            api_error = _coerce_qingflow_error(exc)
+            if api_error is None or not _is_permission_restricted_error(api_error):
+                raise
+            raise _required_state_read_blocked_error(
+                resource="package_attach",
+                message=f"package attach requires readable package state before sorting items for tag '{tag_id}'",
+                error=api_error,
+                details={"tag_id": tag_id, "app_key": app_key},
+            ) from exc
         package_result = package_detail.get("result") if isinstance(package_detail.get("result"), dict) else {}
         tag_items = [deepcopy(item) for item in package_result.get("tagItems", []) if isinstance(item, dict)]
         if any(_package_item_app_key(item) == app_key for item in tag_items):
@@ -675,7 +692,18 @@ class SolutionExecutor:
             if dash_key:
                 store.set_artifact("portal", "dash_key", dash_key)
         if dash_key:
-            base_payload = self.portal_tools.portal_get(profile=profile, dash_key=dash_key, being_draft=True).get("result") or {}
+            try:
+                base_payload = self.portal_tools.portal_get(profile=profile, dash_key=dash_key, being_draft=True).get("result") or {}
+            except Exception as exc:  # noqa: BLE001
+                api_error = _coerce_qingflow_error(exc)
+                if api_error is None or not _is_permission_restricted_error(api_error):
+                    raise
+                raise _required_state_read_blocked_error(
+                    resource="portal",
+                    message=f"portal update requires readable draft state for dash '{dash_key}'",
+                    error=api_error,
+                    details={"dash_key": dash_key},
+                ) from exc
             update_payload = self._resolve_portal_payload(compiled.portal_plan["update_payload"], store, base_payload=base_payload)
             self.portal_tools.portal_update(profile=profile, dash_key=dash_key, payload=update_payload)
             self._refresh_portal_artifact(profile=profile, store=store, being_draft=True, artifact_key="draft_result")
@@ -2123,6 +2151,37 @@ def _coerce_qingflow_error(error: Exception) -> QingflowApiError | None:
     )
 
 
+def _is_permission_restricted_error(error: QingflowApiError) -> bool:
+    return error.backend_code in {40002, 40027}
+
+
+def _required_state_read_blocked_error(
+    *,
+    resource: str,
+    message: str,
+    error: QingflowApiError,
+    details: dict[str, Any] | None = None,
+) -> QingflowApiError:
+    merged_details = deepcopy(details) if isinstance(details, dict) else {}
+    merged_details["state_read_blocked"] = {
+        "resource": resource,
+        "transport_error": {
+            "http_status": error.http_status,
+            "backend_code": error.backend_code,
+            "category": error.category,
+            "request_id": error.request_id,
+        },
+    }
+    return QingflowApiError(
+        category=error.category,
+        message=message,
+        backend_code=error.backend_code,
+        request_id=error.request_id,
+        http_status=error.http_status,
+        details=merged_details,
+    )
+
+
 def _portal_component_position(
     source_type: Any,
     *,

package/src/qingflow_mcp/tools/solution_tools.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
+import json
 from typing import Any
 from uuid import uuid4
 
@@ -8,6 +9,7 @@ from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, ValidationError
 
 from ..config import DEFAULT_PROFILE
+from ..errors import QingflowApiError
 from ..list_type_labels import get_record_list_type_label
 from ..solution.build_assembly_store import BuildAssemblyStore, default_manifest
 from ..solution.compiler import CompiledSolution, ExecutionPlan, ExecutionStep, build_execution_plan, compile_solution
@@ -1850,7 +1852,35 @@ class SolutionTools(ToolBase):
         packages = PackageTools(self.sessions, self.backend)
         normalized_name = package_name.strip()
         if package_tag_id > 0:
-            result = packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=False)
+            try:
+                result = packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=False)
+            except (QingflowApiError, RuntimeError) as exc:
+                error = _coerce_solution_api_error(exc)
+                if error.backend_code in {40002, 40027}:
+                    return {
+                        "status": "resolved",
+                        "matched_via": "tag_id",
+                        "tag_id": package_tag_id,
+                        "tag_name": None,
+                        "candidates": [],
+                        "metadata_unverified": True,
+                        "lookup_permission_blocked": {
+                            "scope": "package",
+                            "target": {"tag_id": package_tag_id},
+                            "transport_error": {
+                                "http_status": error.http_status,
+                                "backend_code": error.backend_code,
+                                "category": error.category,
+                                "request_id": error.request_id,
+                            },
+                        },
+                    }
+                return _builder_package_resolution_failed(
+                    package_name=normalized_name,
+                    package_tag_id=package_tag_id,
+                    error=error,
+                    retried=False,
+                )
             summary = result.get("result") if isinstance(result.get("result"), dict) else {}
             return {
                 "status": "resolved",
@@ -1869,12 +1899,28 @@ class SolutionTools(ToolBase):
                 "source_shape": None,
                 "retried": False,
             }
-        result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+        try:
+            result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+        except (QingflowApiError, RuntimeError) as exc:
+            return _builder_package_resolution_failed(
+                package_name=normalized_name,
+                package_tag_id=package_tag_id,
+                error=_coerce_solution_api_error(exc),
+                retried=False,
+            )
         items = result.get("items") if isinstance(result.get("items"), list) else []
         source_shape = result.get("source_shape")
         retried = False
         if not items:
-            retry_result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+            try:
+                retry_result = packages.package_list(profile=profile, trial_status="all", include_raw=False)
+            except (QingflowApiError, RuntimeError) as exc:
+                return _builder_package_resolution_failed(
+                    package_name=normalized_name,
+                    package_tag_id=package_tag_id,
+                    error=_coerce_solution_api_error(exc),
+                    retried=True,
+                )
             retry_items = retry_result.get("items") if isinstance(retry_result.get("items"), list) else []
             if retry_items:
                 items = retry_items
@@ -2982,6 +3028,72 @@ def _solution_error_fields(
     }
 
 
+def _builder_package_resolution_failed(
+    *,
+    package_name: str,
+    package_tag_id: int,
+    error: QingflowApiError,
+    retried: bool,
+) -> dict[str, Any]:
+    if package_tag_id > 0:
+        detail = f"failed to resolve package_tag_id '{package_tag_id}': {error.message}"
+    elif error.backend_code in {40002, 40027}:
+        detail = (
+            f"failed to resolve package '{package_name}' because package listing is permission-restricted; "
+            "provide package_tag_id explicitly or use an account that can list packages"
+        )
+    else:
+        detail = f"failed to resolve package '{package_name}': {error.message}"
+    error_fields = _solution_error_fields(category="config", detail=detail, suggested_next_call=None, stage="app")
+    error_fields["error_code"] = "PACKAGE_RESOLVE_FAILED"
+    return {
+        "status": "failed",
+        "response": {
+            "status": "failed",
+            "mode": "plan",
+            "stage": "app",
+            "errors": [{"category": "config", "detail": detail}],
+            "package_resolution": {
+                "status": "failed",
+                "requested_name": package_name or None,
+                "requested_tag_id": package_tag_id or None,
+                "resolution_policy": "exact_name_only" if package_name else "tag_id_only",
+                "candidates": [],
+                "source_shape": None,
+                "retried": retried,
+                "transport_error": {
+                    "http_status": error.http_status,
+                    "backend_code": error.backend_code,
+                    "category": error.category,
+                    "request_id": error.request_id,
+                },
+            },
+            **error_fields,
+        },
+    }
+
+
+def _coerce_solution_api_error(error: Exception) -> QingflowApiError:
+    if isinstance(error, QingflowApiError):
+        return error
+    if isinstance(error, RuntimeError):
+        try:
+            payload = json.loads(str(error))
+        except json.JSONDecodeError:
+            payload = None
+        if isinstance(payload, dict) and payload.get("category") and payload.get("message"):
+            details = payload.get("details")
+            return QingflowApiError(
+                category=str(payload.get("category")),
+                message=str(payload.get("message")),
+                backend_code=payload.get("backend_code"),
+                request_id=payload.get("request_id"),
+                http_status=payload.get("http_status"),
+                details=details if isinstance(details, dict) else None,
+            )
+    return QingflowApiError(category="runtime", message=str(error))
+
+
 def _coerce_count(value: Any) -> int | None:
     if isinstance(value, bool) or value is None:
         return None

package/src/qingflow_mcp/ops/__init__.py

@@ -1,3 +0,0 @@
-from .context import OperationsRuntime, build_operations_runtime
-
-__all__ = ["OperationsRuntime", "build_operations_runtime"]

package/src/qingflow_mcp/ops/apps.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result
-
-
-class AppOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def list(self, *, profile: str) -> dict:
-        try:
-            raw = self._tools.app.app_list(profile=profile)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        items = raw.get("items") if isinstance(raw.get("items"), list) else []
-        return success_result(
-            "APPS_LISTED",
-            "已读取应用列表",
-            data={"items": items, "count": raw.get("count", len(items))},
-            meta={"profile": profile, "workspace_id": raw.get("ws_id")},
-            legacy=raw,
-        )
-
-    def find(self, *, profile: str, keyword: str, page_num: int, page_size: int) -> dict:
-        try:
-            raw = self._tools.app.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "APPS_FOUND",
-            "已完成应用搜索",
-            data={
-                "items": raw.get("items") if isinstance(raw.get("items"), list) else [],
-                "total": raw.get("total"),
-                "keyword": keyword,
-                "page_num": page_num,
-                "page_size": page_size,
-            },
-            meta={"profile": profile, "workspace_id": raw.get("ws_id")},
-            legacy=raw,
-        )
-
-    def show(self, *, profile: str, app_key: str) -> dict:
-        try:
-            raw = self._tools.app.app_get(profile=profile, app_key=app_key)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = raw.get("data") if isinstance(raw.get("data"), dict) else {}
-        return success_result(
-            "APP_SHOWN",
-            "已读取应用信息",
-            data={
-                "app_key": data.get("app_key", app_key),
-                "app_name": data.get("app_name"),
-                "can_create": data.get("can_create"),
-                "import_capability": data.get("import_capability"),
-                "accessible_views": data.get("accessible_views") if isinstance(data.get("accessible_views"), list) else [],
-            },
-            warnings=raw.get("warnings") if isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "workspace_id": raw.get("ws_id"), "request_route": raw.get("request_route")},
-            legacy=raw,
-        )

package/src/qingflow_mcp/ops/auth.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result
-
-
-class AuthOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def login(
-        self,
-        *,
-        profile: str,
-        base_url: str | None,
-        qf_version: str | None,
-        email: str,
-        password: str,
-        persist: bool,
-    ) -> dict:
-        try:
-            raw = self._tools.auth.auth_login(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                email=email,
-                password=password,
-                persist=persist,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "AUTHENTICATED",
-            "登录成功",
-            data=_auth_payload(raw),
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def use_token(
-        self,
-        *,
-        profile: str,
-        base_url: str | None,
-        qf_version: str | None,
-        token: str,
-        ws_id: int | None,
-        persist: bool,
-    ) -> dict:
-        try:
-            raw = self._tools.auth.auth_use_token(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                token=token,
-                ws_id=ws_id,
-                persist=persist,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "TOKEN_ACCEPTED",
-            "已接入会话令牌",
-            data=_auth_payload(raw),
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def me(self, *, profile: str) -> dict:
-        try:
-            raw = self._tools.auth.auth_whoami(profile=profile)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "SESSION_READY",
-            "当前会话已就绪",
-            data=_auth_payload(raw),
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def logout(self, *, profile: str, forget_persisted: bool) -> dict:
-        try:
-            raw = self._tools.auth.auth_logout(profile=profile, forget_persisted=forget_persisted)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "SESSION_CLEARED",
-            "已退出当前会话",
-            data={
-                "profile": raw.get("profile", profile),
-                "logged_out": bool(raw.get("logged_out", True)),
-                "forgot_persisted": bool(raw.get("forgot_persisted", forget_persisted)),
-            },
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-
-def _auth_payload(raw: dict) -> dict:
-    return {
-        "profile": raw.get("profile"),
-        "base_url": raw.get("base_url"),
-        "qf_version": raw.get("qf_version"),
-        "qf_version_source": raw.get("qf_version_source"),
-        "user": {
-            "uid": raw.get("uid"),
-            "email": raw.get("email"),
-            "nick_name": raw.get("nick_name"),
-        },
-        "workspace": {
-            "ws_id": raw.get("selected_ws_id"),
-            "name": raw.get("selected_ws_name"),
-        },
-        "suggested_workspace": {
-            "ws_id": raw.get("suggested_ws_id"),
-            "name": raw.get("suggested_ws_name"),
-        },
-        "persisted": bool(raw.get("persisted")),
-    }