@qingflow-tech/qingflow-app-user-mcp 1.0.10 → 1.0.12

package/src/qingflow_mcp/solution/compiler/icon_utils.py

@@ -5,6 +5,215 @@ import re
 
 
 DEFAULT_ICON_COLOR = "qing-orange"
+WORKSPACE_ICON_COLORS: tuple[str, ...] = (
+    "qing-orange",
+    "yellow",
+    "green",
+    "emerald",
+    "blue",
+    "azure",
+    "indigo",
+    "qing-purple",
+    "purple",
+    "pink",
+    "red",
+    "orange",
+)
+WORKSPACE_ICON_NAMES: tuple[str, ...] = (
+    "user",
+    "user-group",
+    "user-remove",
+    "user-add",
+    "user-circle",
+    "base-camera",
+    "view-grid",
+    "inbox",
+    "inbox-in",
+    "share",
+    "sitemap",
+    "airplane",
+    "template",
+    "music-note",
+    "movie-play",
+    "clock",
+    "document",
+    "document-search",
+    "clipboard-check",
+    "document-download",
+    "document-text",
+    "clipboard-copy",
+    "presentation-chart-bar",
+    "chart-square-bar",
+    "database",
+    "server",
+    "calendar",
+    "mail",
+    "annotation",
+    "chat",
+    "bell",
+    "key",
+    "shopping-bag",
+    "download",
+    "eye",
+    "eye-off",
+    "emoji-happy",
+    "emoji-sad",
+    "sun",
+    "moon",
+    "cloud",
+    "lightning-bolt",
+    "fire",
+    "star",
+    "sparkles",
+    "heart",
+    "cake",
+    "gift",
+    "light-bulb",
+    "exclamation",
+    "cog",
+    "thumb-up",
+    "thumb-down",
+    "cloud-download",
+    "cloud-upload",
+    "printer",
+    "phone-incoming",
+    "phone-missed-call",
+    "terminal",
+    "search-circle",
+    "x-circle",
+    "check-circle",
+    "exclamation-circle",
+    "question-mark-circle",
+    "information-circle",
+    "academic-cap",
+    "briefcase",
+    "home",
+    "phone",
+    "photograph",
+    "puzzle",
+    "color-swatch",
+    "lock-open",
+    "lock-closed",
+    "shield-check",
+    "shield-exclamation",
+    "currency-dollar",
+    "currency-yen",
+    "globe",
+    "at-symbol",
+    "slack",
+    "microphone",
+    "speakerphone",
+    "trash",
+    "book-open",
+    "truck",
+    "filter",
+    "essetional-filter-search",
+    "essetional-filter-tick",
+    "table",
+    "calculator",
+    "location-radar",
+    "essetional-weight",
+    "school-award",
+    "comp-cloud-connection",
+    "comp-cloud-remove",
+    "comp-cpu-charge",
+    "comp-cpu-setting",
+    "comp-cpu",
+    "comp-devices",
+    "comp-driver-2",
+    "comp-driver-refresh",
+    "location-global",
+    "location-location",
+    "location-map",
+    "location-gps",
+    "essetional-ranking",
+    "chart-bar",
+    "business-graph",
+    "business-status-up",
+    "business-trend-down",
+    "business-trend-up",
+    "business-presention-chart",
+    "business-favorite-chart",
+    "business-health",
+    "receipt-refund",
+    "receipt-tax",
+    "money-receipt-2-1",
+    "money-transaction-minus",
+    "action-hourglass-full",
+    "action-work",
+    "bug-f",
+    "essetional-pet",
+    "files-folder",
+    "badge-check",
+    "money-wallet-1",
+    "money-ticket",
+    "money-money",
+    "money-tag",
+    "money-wallet-2",
+    "business-personalcard",
+    "car-airplane",
+    "car-bus",
+    "car-car",
+    "car-driving",
+    "car-gas-station",
+    "car-smart-car",
+    "car-ship",
+    "location-map-1",
+    "location-route-square",
+    "cone",
+    "design-brush-4",
+    "paint-roll",
+    "wrench-f",
+    "essetional-reserve",
+    "essetional-broom",
+    "design-brush-2",
+    "essetional-judge",
+    "design-bucket",
+    "palette",
+    "comp-electricity",
+    "vial",
+    "beaker",
+    "leaf-f",
+    "cursor-click",
+    "solid-search-alt-2",
+    "md-library",
+    "building-3",
+    "office-building",
+    "building-hospital",
+    "school",
+    "store",
+    "video-camera-vintage-f",
+    "comp-monitor",
+    "delivery-truck",
+    "delivery-box-1",
+    "delivery-box-add",
+    "delivery-box-remove",
+    "settings-setting-3",
+    "document-duplicate",
+    "essetional-flag-2",
+    "flag",
+    "icon-currency-dollar",
+    "clipboard-list",
+    "save-as",
+    "wifi",
+    "status-online",
+    "scissors",
+    "globe-alt",
+    "ban",
+    "finger-print",
+    "qrcode",
+    "paper-clip",
+    "translate",
+    "cube-transparent",
+    "variable",
+    "switch-vertical",
+    "sports-baseball",
+    "sports-basketball",
+    "sports-soccer",
+    "sports-football",
+    "sports-volleyball",
+)
+GENERIC_WORKSPACE_ICON_NAMES: tuple[str, ...] = ("template",)
 DEFAULT_ICON_STYLE_POOL: tuple[tuple[str, str], ...] = (
     ("briefcase", "qing-orange"),
     ("calendar", "emerald"),
@@ -115,6 +324,91 @@ def parse_workspace_icon(value: str | None) -> tuple[str | None, str | None, str
     return normalize_workspace_icon_name(stripped), None, None
 
 
+def workspace_icon_config(value: str | None) -> dict[str, str | None]:
+    icon_name, icon_color, icon_text = parse_workspace_icon(value)
+    raw = str(value).strip() if value not in (None, "") else None
+    return {
+        "icon_name": icon_name,
+        "icon_color": icon_color,
+        "icon_text": icon_text,
+        "raw": raw,
+    }
+
+
+def workspace_icon_catalog_payload() -> dict[str, object]:
+    return {
+        "icon_names": list(WORKSPACE_ICON_NAMES),
+        "icon_colors": list(WORKSPACE_ICON_COLORS),
+        "generic_icon_names": list(GENERIC_WORKSPACE_ICON_NAMES),
+        "notes": [
+            "Use explicit icon + color for app/package/portal creation.",
+            "Do not use template for newly created workspace resources.",
+            "The CLI validates candidates only; it does not infer an icon from business names.",
+        ],
+        "common_examples": {
+            "employee": ["business-personalcard", "user-group", "user"],
+            "task": ["clipboard-check", "action-work"],
+            "worklog": ["clock", "action-hourglass-full"],
+            "order": ["delivery-box-1", "shopping-bag"],
+            "payment": ["money-receipt-2-1", "money-wallet-1"],
+            "opportunity": ["business-graph", "business-trend-up"],
+            "dashboard": ["view-grid", "chart-square-bar", "presentation-chart-bar"],
+        },
+    }
+
+
+def validate_workspace_icon_choice(
+    *,
+    icon: str | None,
+    color: str | None,
+    require_explicit: bool,
+    disallow_generic: bool,
+) -> tuple[bool, str | None, str | None, dict[str, object]]:
+    normalized_icon = _normalize_workspace_icon_candidate(icon)
+    normalized_color = str(color or "").strip() or None
+    details: dict[str, object] = {
+        "icon": icon,
+        "normalized_icon": normalized_icon,
+        "color": color,
+        "icon_catalog_command": "qingflow --json builder icon catalog",
+    }
+    if require_explicit and not normalized_icon:
+        return False, "WORKSPACE_ICON_REQUIRED", "icon is required when creating a workspace resource", details
+    if require_explicit and not normalized_color:
+        return False, "WORKSPACE_ICON_COLOR_REQUIRED", "color is required when creating a workspace resource", details
+    if normalized_icon and normalized_icon not in WORKSPACE_ICON_NAMES:
+        details["allowed_icon_names"] = list(WORKSPACE_ICON_NAMES)
+        return False, "WORKSPACE_ICON_NOT_FOUND", "icon is not in the workspace icon catalog", details
+    if normalized_color and normalized_color not in WORKSPACE_ICON_COLORS:
+        details["allowed_icon_colors"] = list(WORKSPACE_ICON_COLORS)
+        return False, "WORKSPACE_ICON_COLOR_NOT_FOUND", "color is not in the workspace icon color catalog", details
+    if disallow_generic and normalized_icon in GENERIC_WORKSPACE_ICON_NAMES:
+        details["generic_icon_names"] = list(GENERIC_WORKSPACE_ICON_NAMES)
+        return False, "GENERIC_WORKSPACE_ICON_NOT_ALLOWED", "template is a generic icon and is not allowed for new workspace resources", details
+    return True, None, None, details
+
+
+def _normalize_workspace_icon_candidate(icon: str | None) -> str | None:
+    if not icon:
+        return None
+    raw = str(icon).strip()
+    if not raw:
+        return None
+    if _looks_like_icon_json(raw):
+        try:
+            payload = json.loads(raw)
+        except Exception:
+            return None
+        return _normalize_workspace_icon_candidate(payload.get("iconName"))
+    normalized = raw.lower()
+    if normalized in WORKSPACE_ICON_NAMES:
+        return normalized
+    legacy = LEGACY_EX_ICON_MAP.get(normalized)
+    if legacy in WORKSPACE_ICON_NAMES:
+        return legacy
+    return normalized
+
+
 def encode_workspace_icon_with_defaults(
     *,
     icon: str | None,

package/src/qingflow_mcp/solution/executor.py

@@ -5,7 +5,7 @@ from copy import deepcopy
 from typing import Any
 from uuid import uuid4
 
-from ..errors import QingflowApiError
+from ..errors import QingflowApiError, backend_code_int, is_auth_like_error
 from ..tools.app_tools import AppTools
 from ..tools.navigation_tools import NavigationTools
 from ..tools.package_tools import PackageTools
@@ -76,7 +76,8 @@ class SolutionExecutor:
             except Exception as exc:  # noqa: BLE001
                 store.record_step_failed(step.step_name, str(exc), debug_context=debug_context)
                 return store.summary()
-        store.mark_finished(status="success")
+        final_status = "partial_success" if _artifacts_have_post_write_readback_pending(store.data.get("artifacts", {})) else "success"
+        store.mark_finished(status=final_status)
         return store.summary()
 
     def _repair_start_index(self, compiled: CompiledSolution, store: RunArtifactStore) -> int:
@@ -203,6 +204,11 @@ class SolutionExecutor:
             dash_key = store.get_artifact("portal", "dash_key")
             if dash_key:
                 self.portal_tools.portal_publish(profile=profile, dash_key=dash_key)
+                store.set_artifact(
+                    "portal",
+                    "publish",
+                    {"published": True, "write_executed": True, "safe_to_retry": False},
+                )
                 self._refresh_portal_artifact(profile=profile, store=store, being_draft=False, artifact_key="published_result")
             return
         if step_name == "publish.navigation" and publish and compiled.normalized_spec.publish_policy.navigation:
@@ -347,7 +353,32 @@ class SolutionExecutor:
         updated_items.insert(insert_at, item)
         self.package_tools.package_sort_items(profile=profile, tag_id=tag_id, tag_items=updated_items)
 
-        verified_detail = _verify_package_attachment(self.package_tools, profile=profile, tag_id=tag_id, app_key=app_key)
+        try:
+            verified_detail = _verify_package_attachment(self.package_tools, profile=profile, tag_id=tag_id, app_key=app_key)
+        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
+            store.set_artifact(
+                "package",
+                "attachment_readback",
+                _post_write_readback_artifact(
+                    resource="package_attach",
+                    target={"tag_id": tag_id, "app_key": app_key},
+                    error=api_error,
+                ),
+            )
+            self._record_package_attachment(
+                store,
+                entity.entity_id,
+                app_artifact,
+                tag_id=tag_id,
+                attached=True,
+                reused=False,
+                readback_status="unavailable",
+                readback_verified=False,
+            )
+            return
         verified_result = verified_detail.get("result") if isinstance(verified_detail.get("result"), dict) else {}
         verified_items = [deepcopy(existing) for existing in verified_result.get("tagItems", []) if isinstance(existing, dict)]
         if not any(_package_item_app_key(existing) == app_key for existing in verified_items):
@@ -369,12 +400,18 @@ class SolutionExecutor:
         tag_id: int,
         attached: bool,
         reused: bool,
+        readback_status: str = "verified",
+        readback_verified: bool = True,
     ) -> None:
         next_artifact = deepcopy(app_artifact)
         next_artifact["package_attachment"] = {
             "tag_id": tag_id,
             "attached": attached,
             "reused": reused,
+            "readback_status": readback_status,
+            "readback_verified": readback_verified,
+            "write_executed": not reused,
+            "safe_to_retry": reused or not attached,
         }
         store.set_artifact("apps", entity_id, next_artifact)
 
@@ -698,12 +735,23 @@ class SolutionExecutor:
                 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
+                if not result:
+                    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
+                base_payload = {}
+                store.set_artifact(
+                    "portal",
+                    "draft_readback_before_update",
+                    _post_write_readback_artifact(
+                        resource="portal",
+                        target={"dash_key": dash_key, "phase": "created_portal_draft_readback"},
+                        error=api_error,
+                    ),
+                )
             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")
@@ -744,7 +792,19 @@ class SolutionExecutor:
             return
         try:
             result = self.portal_tools.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft)
-        except Exception:  # noqa: BLE001
+        except Exception as exc:  # noqa: BLE001
+            api_error = _coerce_qingflow_error(exc)
+            if api_error is None:
+                raise
+            store.set_artifact(
+                "portal",
+                f"{artifact_key}_readback",
+                _post_write_readback_artifact(
+                    resource="portal",
+                    target={"dash_key": dash_key, "being_draft": being_draft, "artifact_key": artifact_key},
+                    error=api_error,
+                ),
+            )
             return
         store.set_artifact("portal", artifact_key, result)
         store.set_artifact("portal", "result", result)
@@ -2112,10 +2172,9 @@ def _has_explicit_workflow_global_settings(global_settings: dict[str, Any] | Non
 
 
 def _is_navigation_plugin_unavailable(error: QingflowApiError) -> bool:
-    try:
-        backend_code = int(error.backend_code)
-    except (TypeError, ValueError):
-        backend_code = None
+    if is_auth_like_error(error):
+        return False
+    backend_code = backend_code_int(error)
     if backend_code != 50004:
         return False
     message = error.message or ""
@@ -2152,7 +2211,9 @@ def _coerce_qingflow_error(error: Exception) -> QingflowApiError | None:
 
 
 def _is_permission_restricted_error(error: QingflowApiError) -> bool:
-    return error.backend_code in {40002, 40027}
+    if is_auth_like_error(error):
+        return False
+    return backend_code_int(error) in {40002, 40027}
 
 
 def _required_state_read_blocked_error(
@@ -2182,6 +2243,42 @@ def _required_state_read_blocked_error(
     )
 
 
+def _post_write_readback_artifact(
+    *,
+    resource: str,
+    target: dict[str, Any],
+    error: QingflowApiError,
+) -> dict[str, Any]:
+    return {
+        "resource": resource,
+        "target": deepcopy(target),
+        "readback_status": "unavailable",
+        "readback_verified": False,
+        "write_executed": True,
+        "safe_to_retry": False,
+        "transport_error": {
+            "http_status": error.http_status,
+            "backend_code": error.backend_code,
+            "category": error.category,
+            "request_id": error.request_id,
+        },
+    }
+
+
+def _artifacts_have_post_write_readback_pending(value: Any) -> bool:
+    if isinstance(value, dict):
+        if (
+            value.get("write_executed") is True
+            and value.get("safe_to_retry") is False
+            and value.get("readback_status") == "unavailable"
+        ):
+            return True
+        return any(_artifacts_have_post_write_readback_pending(item) for item in value.values())
+    if isinstance(value, list):
+        return any(_artifacts_have_post_write_readback_pending(item) for item in value)
+    return False
+
+
 def _portal_component_position(
     source_type: Any,
     *,