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

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

@@ -1,44 +1,57 @@
 from __future__ import annotations
 
 import json
+import re
 
 
 DEFAULT_ICON_COLOR = "qing-orange"
-SUPPORTED_EX_ICONS = {
-    "ex-alert-outlined",
-    "ex-clock-outlined",
-    "ex-folder-outlined",
-    "ex-form-outlined",
-    "ex-home-outlined",
-    "ex-user-outlined",
+DEFAULT_ICON_STYLE_POOL: tuple[tuple[str, str], ...] = (
+    ("briefcase", "qing-orange"),
+    ("calendar", "emerald"),
+    ("files-folder", "azure"),
+    ("shield-check", "indigo"),
+    ("user-group", "qing-purple"),
+    ("chart-square-bar", "blue"),
+    ("clock", "pink"),
+    ("document-text", "green"),
+    ("home", "orange"),
+    ("globe", "red"),
+)
+LEGACY_EX_ICON_MAP = {
+    "ex-alert-outlined": "exclamation-circle",
+    "ex-clock-outlined": "clock",
+    "ex-folder-outlined": "folder",
+    "ex-form-outlined": "template",
+    "ex-home-outlined": "home",
+    "ex-user-outlined": "user",
 }
 
 ICON_ALIAS_MAP = {
-    "archive-box": "ex-form-outlined",
-    "beaker": "ex-form-outlined",
-    "briefcase": "ex-folder-outlined",
-    "building-office": "ex-form-outlined",
-    "calendar": "ex-clock-outlined",
-    "chat": "ex-clock-outlined",
-    "chat-bubble-left-right": "ex-clock-outlined",
-    "chart-bar": "ex-form-outlined",
-    "chart-square-bar": "ex-form-outlined",
-    "check-badge": "ex-alert-outlined",
-    "check-circle": "ex-alert-outlined",
-    "clipboard-check": "ex-form-outlined",
-    "clock": "ex-clock-outlined",
-    "cube": "ex-form-outlined",
-    "document-text": "ex-form-outlined",
-    "folder": "ex-folder-outlined",
-    "home": "ex-home-outlined",
-    "office-building": "ex-form-outlined",
-    "shield-check": "ex-alert-outlined",
-    "template": "ex-form-outlined",
-    "user": "ex-user-outlined",
-    "user-group": "ex-user-outlined",
-    "users": "ex-user-outlined",
-    "view-grid": "ex-home-outlined",
-    "warning": "ex-alert-outlined",
+    "archive-box": "template",
+    "beaker": "beaker",
+    "briefcase": "briefcase",
+    "building-office": "office-building",
+    "calendar": "calendar",
+    "chat": "chat",
+    "chat-bubble-left-right": "chat",
+    "chart-bar": "chart-bar",
+    "chart-square-bar": "chart-square-bar",
+    "check-badge": "badge-check",
+    "check-circle": "check-circle",
+    "clipboard-check": "clipboard-check",
+    "clock": "clock",
+    "cube": "cube-transparent",
+    "document-text": "document-text",
+    "folder": "files-folder",
+    "home": "home",
+    "office-building": "office-building",
+    "shield-check": "shield-check",
+    "template": "template",
+    "user": "user",
+    "user-group": "user-group",
+    "users": "user-group",
+    "view-grid": "view-grid",
+    "warning": "exclamation-circle",
 }
 
 
@@ -52,8 +65,6 @@ def encode_workspace_icon(
     if icon and _looks_like_icon_json(icon):
         return icon
     normalized_icon_name = normalize_workspace_icon_name(icon or fallback_icon_name)
-    if normalized_icon_name and normalized_icon_name.startswith("ex-") and not color:
-        return normalized_icon_name
     icon_name = normalized_icon_name
     icon_color = color or DEFAULT_ICON_COLOR
     if icon_name:
@@ -78,6 +89,65 @@ def encode_workspace_icon(
     )
 
 
+def choose_default_workspace_icon_style(*, title: str) -> tuple[str, str]:
+    seed_text = (title or "未命名").strip() or "未命名"
+    digest = 0
+    for index, char in enumerate(seed_text):
+        digest = (digest * 131 + ord(char) + index) % 1_000_003
+    return DEFAULT_ICON_STYLE_POOL[digest % len(DEFAULT_ICON_STYLE_POOL)]
+
+
+def parse_workspace_icon(value: str | None) -> tuple[str | None, str | None, str | None]:
+    if not value:
+        return None, None, None
+    stripped = str(value).strip()
+    if not stripped:
+        return None, None, None
+    if _looks_like_icon_json(stripped):
+        try:
+            payload = json.loads(stripped)
+        except Exception:
+            return normalize_workspace_icon_name(stripped), None, None
+        icon_name = normalize_workspace_icon_name(payload.get("iconName"))
+        icon_color = str(payload.get("iconColor") or "").strip() or None
+        icon_text = str(payload.get("iconText") or "").strip() or None
+        return icon_name, icon_color, icon_text
+    return normalize_workspace_icon_name(stripped), None, None
+
+
+def encode_workspace_icon_with_defaults(
+    *,
+    icon: str | None,
+    color: str | None,
+    title: str,
+    fallback_icon_name: str | None = None,
+    existing_icon: str | None = None,
+) -> str:
+    if icon and _looks_like_icon_json(icon):
+        return icon
+    if not icon and not color and existing_icon:
+        existing_payload = str(existing_icon).strip()
+        if existing_payload:
+            return existing_payload
+    existing_icon_name, existing_icon_color, _ = parse_workspace_icon(existing_icon)
+    default_icon, default_color = choose_default_workspace_icon_style(title=title)
+    resolved_icon = icon or existing_icon_name
+    resolved_color = color or existing_icon_color
+    if not resolved_icon:
+        if icon is None and color is None:
+            resolved_icon = default_icon
+        else:
+            resolved_icon = fallback_icon_name or default_icon
+    if not resolved_color:
+        resolved_color = default_color
+    return encode_workspace_icon(
+        icon=resolved_icon,
+        color=resolved_color,
+        title=title,
+        fallback_icon_name=fallback_icon_name,
+    )
+
+
 def normalize_workspace_icon_name(icon: str | None) -> str | None:
     if not icon:
         return None
@@ -85,27 +155,31 @@ def normalize_workspace_icon_name(icon: str | None) -> str | None:
         try:
             payload = json.loads(icon)
         except Exception:
-            return "ex-form-outlined"
-        return normalize_workspace_icon_name(payload.get("iconName")) or "ex-form-outlined"
-    if icon in SUPPORTED_EX_ICONS:
-        return icon
+            return "template"
+        return normalize_workspace_icon_name(payload.get("iconName")) or "template"
     normalized = icon.strip().lower()
+    if normalized in LEGACY_EX_ICON_MAP:
+        return LEGACY_EX_ICON_MAP[normalized]
     if normalized in ICON_ALIAS_MAP:
         return ICON_ALIAS_MAP[normalized]
     for token in normalized.replace("_", "-").split("-"):
         if token in ICON_ALIAS_MAP:
             return ICON_ALIAS_MAP[token]
     if "folder" in normalized or "package" in normalized:
-        return "ex-folder-outlined"
-    if "home" in normalized or "portal" in normalized or "dashboard" in normalized:
-        return "ex-home-outlined"
+        return "files-folder"
+    if "home" in normalized:
+        return "home"
+    if "portal" in normalized or "dashboard" in normalized:
+        return "view-grid"
     if "user" in normalized or "member" in normalized or "contact" in normalized:
-        return "ex-user-outlined"
+        return "user"
     if "clock" in normalized or "time" in normalized or "schedule" in normalized or "log" in normalized:
-        return "ex-clock-outlined"
+        return "clock"
     if "risk" in normalized or "alert" in normalized or "warn" in normalized or "safety" in normalized:
-        return "ex-alert-outlined"
-    return "ex-form-outlined"
+        return "exclamation-circle"
+    if re.fullmatch(r"[a-z0-9-]+", normalized):
+        return normalized
+    return "template"
 
 
 def _looks_like_icon_json(value: str) -> bool:

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

@@ -36,6 +36,11 @@ def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
     actions: list[dict[str, Any]] = []
     seen_node_ids: set[str] = set()
     created_extra_branch_lanes: set[str] = set()
+    start_node_ids = {
+        node.node_id
+        for node in workflow.nodes
+        if node.node_type == WorkflowNodeType.start
+    }
     for node in workflow.nodes:
         if node.node_type == WorkflowNodeType.start:
             seen_node_ids.add(node.node_id)
@@ -58,6 +63,26 @@ def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
                 }
             )
             created_extra_branch_lanes.add(branch_lane_ref)
+        lane_only = bool((node.config or {}).get("__lane_only__")) and node.node_type == WorkflowNodeType.condition and branch_lane_ref
+        if lane_only:
+            lane_payload = {key: value for key, value in node.config.items() if key != "__lane_only__"}
+            actions.append(
+                {
+                    "action": "update_node",
+                    "node_id": branch_lane_ref,
+                    "node_name": node.name,
+                    "node_type": node.node_type.value,
+                    "payload": {
+                        "editVersionNo": 1,
+                        "auditNodeName": node.name,
+                        "type": WORKFLOW_TYPE_MAP[node.node_type]["type"],
+                        "dealType": WORKFLOW_TYPE_MAP[node.node_type]["dealType"],
+                        **lane_payload,
+                    },
+                }
+            )
+            seen_node_ids.add(node.node_id)
+            continue
         actions.append(
             {
                 "action": "add_node",
@@ -69,7 +94,7 @@ def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
                     "auditNodeName": node.name,
                     "type": WORKFLOW_TYPE_MAP[node.node_type]["type"],
                     "dealType": WORKFLOW_TYPE_MAP[node.node_type]["dealType"],
-                    "prevNodeRef": _prev_node_ref(node, branch_lane_ref),
+                    "prevNodeRef": _prev_node_ref(node, branch_lane_ref, start_node_ids),
                     "auditUserInfos": _build_audit_user_infos(node)
                     if node.node_type in {WorkflowNodeType.audit, WorkflowNodeType.fill, WorkflowNodeType.copy}
                     else None,
@@ -100,17 +125,31 @@ def _build_audit_user_infos(node) -> dict[str, Any]:
     role_refs = assignees.get("role_refs") or []
     if role_refs:
         audit_user_infos["role_refs"] = [role_ref for role_ref in role_refs if role_ref]
+    role_entries = assignees.get("role_entries") or []
+    if role_entries:
+        audit_user_infos["role"] = [
+            {
+                "roleId": int(entry.get("roleId") or entry.get("role_id")),
+                "roleName": entry.get("roleName") or entry.get("role_name") or str(entry.get("roleId") or entry.get("role_id")),
+                "roleIcon": entry.get("roleIcon") or entry.get("role_icon") or "ex-user-outlined",
+                "beingFrontendConfig": True,
+            }
+            for entry in role_entries
+            if isinstance(entry, dict) and isinstance(entry.get("roleId") or entry.get("role_id"), int) and int(entry.get("roleId") or entry.get("role_id")) > 0
+        ]
     include_sub_departs = assignees.get("include_sub_departs")
     if include_sub_departs is not None:
         audit_user_infos["includeSubDeparts"] = bool(include_sub_departs)
     return audit_user_infos
 
 
-def _prev_node_ref(node, branch_lane_ref: str | None) -> str:
+def _prev_node_ref(node, branch_lane_ref: str | None, start_node_ids: set[str]) -> str:
     if branch_lane_ref:
         if node.parent_node_id and node.parent_node_id != node.branch_parent_id:
             return node.parent_node_id
         return branch_lane_ref
+    if node.parent_node_id in start_node_ids:
+        return "__applicant__"
     return node.parent_node_id or "__applicant__"
 
 

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):
@@ -415,13 +432,13 @@ class SolutionExecutor:
         current_nodes = _coerce_workflow_nodes(existing_nodes)
         existing_nodes_by_name = {
             node.get("auditNodeName"): int(node_id)
-            for node_id, node in existing_nodes.items()
+            for node_id, node in current_nodes.items()
             if isinstance(node, dict) and node.get("auditNodeName")
         }
         applicant_node_id = next(
             (
                 int(node_id)
-                for node_id, node in existing_nodes.items()
+                for node_id, node in current_nodes.items()
                 if isinstance(node, dict) and node.get("type") == 0 and node.get("dealType") == 3
             ),
             None,
@@ -429,11 +446,24 @@ class SolutionExecutor:
         if applicant_node_id is not None:
             node_artifacts.setdefault("__applicant__", applicant_node_id)
 
-        current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
-        global_settings = deepcopy(current_global_settings if isinstance(current_global_settings, dict) else {})
-        global_settings.update(entity.workflow_plan["global_settings"])
-        global_settings["editVersionNo"] = workflow_edit_version_no or global_settings.get("editVersionNo") or 1
-        self.workflow_tools.workflow_update_global_settings(profile=profile, app_key=app_key, payload=global_settings)
+        desired_global_settings = deepcopy(entity.workflow_plan["global_settings"])
+        explicit_global_settings = _has_explicit_workflow_global_settings(desired_global_settings)
+        current_global_settings: dict[str, Any] = {}
+        if explicit_global_settings:
+            current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
+        else:
+            try:
+                current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = QingflowApiError(**_coerce_nested_error_payload(error))
+                if api_error.http_status != 404:
+                    raise
+                current_global_settings = {}
+        if explicit_global_settings:
+            global_settings = deepcopy(current_global_settings if isinstance(current_global_settings, dict) else {})
+            global_settings.update(desired_global_settings)
+            global_settings["editVersionNo"] = workflow_edit_version_no or global_settings.get("editVersionNo") or 1
+            self.workflow_tools.workflow_update_global_settings(profile=profile, app_key=app_key, payload=global_settings)
         for action in entity.workflow_plan["actions"]:
             if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is not None:
                 continue
@@ -462,6 +492,16 @@ class SolutionExecutor:
                 payload["editVersionNo"] = int(workflow_edit_version_no)
             if action["action"] == "create_sub_branch":
                 result = self.workflow_tools.workflow_create_sub_branch(profile=profile, app_key=app_key, payload=payload)
+            elif action["action"] == "update_node":
+                target_node_id = node_artifacts.get(action["node_id"])
+                if target_node_id is None:
+                    raise RuntimeError(f"workflow lane '{action['node_id']}' could not be resolved before update")
+                result = self.workflow_tools.workflow_update_node(
+                    profile=profile,
+                    app_key=app_key,
+                    audit_node_id=target_node_id,
+                    payload=payload,
+                )
             else:
                 result = self.workflow_tools.workflow_add_node(profile=profile, app_key=app_key, payload=payload)
             expected_type = 1 if action.get("node_type") == "branch" else None
@@ -652,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")
@@ -2046,6 +2097,20 @@ def _find_created_sub_branch_lane_id(
     return candidates[0] if candidates else None
 
 
+def _has_explicit_workflow_global_settings(global_settings: dict[str, Any] | None) -> bool:
+    if not isinstance(global_settings, dict):
+        return False
+    for key, value in global_settings.items():
+        if key == "editVersionNo":
+            continue
+        if value is None:
+            continue
+        if isinstance(value, (list, dict)) and not value:
+            continue
+        return True
+    return False
+
+
 def _is_navigation_plugin_unavailable(error: QingflowApiError) -> bool:
     try:
         backend_code = int(error.backend_code)
@@ -2086,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/solution/spec_models.py

@@ -33,6 +33,8 @@ class FieldType(str, Enum):
     address = "address"
     attachment = "attachment"
     boolean = "boolean"
+    q_linker = "q_linker"
+    code_block = "code_block"
     relation = "relation"
     subtable = "subtable"