@josephyan/qingflow-cli 1.1.4 → 1.1.5

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

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..spec_models import EntitySpec, WorkflowNodeType
+
+
+WORKFLOW_TYPE_MAP = {
+    WorkflowNodeType.start: {"type": 0, "dealType": 3},
+    WorkflowNodeType.branch: {"type": 1, "dealType": None},
+    WorkflowNodeType.audit: {"type": 0, "dealType": 0},
+    WorkflowNodeType.fill: {"type": 0, "dealType": 1},
+    WorkflowNodeType.copy: {"type": 0, "dealType": 2},
+    WorkflowNodeType.webhook: {"type": 3, "dealType": 10},
+    WorkflowNodeType.condition: {"type": 2, "dealType": None},
+}
+
+
+def _default_audit_user_infos() -> dict[str, Any]:
+    return {
+        "member": [],
+        "depart": [],
+        "role": [],
+        "dynamic": [],
+        "includeSubDeparts": None,
+        "externalMemberList": [],
+        "externalDepartList": [],
+        "role_refs": [],
+    }
+
+
+def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
+    workflow = entity.workflow
+    if workflow is None or not workflow.enabled:
+        return 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)
+            continue
+        if node.parent_node_id and node.parent_node_id not in seen_node_ids:
+            raise ValueError(f"workflow node '{node.node_id}' must appear after parent node '{node.parent_node_id}'")
+        if node.branch_parent_id and node.branch_parent_id not in seen_node_ids:
+            raise ValueError(f"workflow node '{node.node_id}' must appear after branch node '{node.branch_parent_id}'")
+        branch_index = _branch_index(node)
+        branch_lane_ref = _branch_lane_ref(node.branch_parent_id, branch_index) if node.branch_parent_id else None
+        if branch_lane_ref and branch_index > 2 and branch_lane_ref not in created_extra_branch_lanes:
+            actions.append(
+                {
+                    "action": "create_sub_branch",
+                    "node_id": branch_lane_ref,
+                    "payload": {
+                        "editVersionNo": 1,
+                        "auditNodeRef": node.branch_parent_id,
+                    },
+                }
+            )
+            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",
+                "node_id": node.node_id,
+                "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"],
+                    "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,
+                    **node.config,
+                },
+            }
+        )
+        seen_node_ids.add(node.node_id)
+    return {
+        "global_settings": {
+            "editVersionNo": 1,
+            **workflow.global_settings,
+        },
+        "actions": actions,
+    }
+
+
+def _build_audit_user_infos(node) -> dict[str, Any]:
+    audit_user_infos = _default_audit_user_infos()
+    assignees = node.assignees or {}
+    member_uids = assignees.get("member_uids") or []
+    if member_uids:
+        audit_user_infos["member"] = [
+            {"uid": uid, "beingFrontendConfig": True}
+            for uid in member_uids
+            if isinstance(uid, int) and uid > 0
+        ]
+    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, 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__"
+
+
+def _branch_index(node) -> int:
+    config = node.config or {}
+    raw_value = getattr(node, "branch_index", None)
+    if raw_value is None:
+        raw_value = config.get("branch_index", config.get("branchIndex", config.get("lane_index", config.get("laneIndex", 1))))
+    try:
+        branch_index = int(raw_value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"workflow node '{node.node_id}' has invalid branch index '{raw_value}'") from exc
+    if branch_index <= 0:
+        raise ValueError(f"workflow node '{node.node_id}' branch index must be positive")
+    return branch_index
+
+
+def _branch_lane_ref(branch_parent_id: str | None, branch_index: int) -> str:
+    if not branch_parent_id:
+        raise ValueError("branch_parent_id is required for branch lane references")
+    return f"__branch_lane__{branch_parent_id}__{branch_index}"

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
@@ -14,6 +14,7 @@ from ..tools.qingbi_report_tools import QingbiReportTools
 from ..tools.record_tools import RecordTools
 from ..tools.role_tools import RoleTools
 from ..tools.view_tools import ViewTools
+from ..tools.workflow_tools import WorkflowTools
 from ..tools.workspace_tools import WorkspaceTools
 from .compiler import CompiledEntity, CompiledRole, CompiledSolution
 from .compiler.form_compiler import QUESTION_TYPE_MAP
@@ -35,6 +36,7 @@ class SolutionExecutor:
         role_tools: RoleTools,
         app_tools: AppTools,
         record_tools: RecordTools,
+        workflow_tools: WorkflowTools,
         view_tools: ViewTools,
         chart_tools: QingbiReportTools,
         portal_tools: PortalTools,
@@ -45,6 +47,7 @@ class SolutionExecutor:
         self.role_tools = role_tools
         self.app_tools = app_tools
         self.record_tools = record_tools
+        self.workflow_tools = workflow_tools
         self.view_tools = view_tools
         self.chart_tools = chart_tools
         self.portal_tools = portal_tools
@@ -73,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:
@@ -200,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:
@@ -344,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):
@@ -366,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)
 
@@ -416,10 +456,123 @@ class SolutionExecutor:
     def _build_workflow(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         if entity.workflow_plan is None:
             return
-        raise RuntimeError(
-            "Legacy auditNode workflow execution was removed. "
-            "Pass {app_key, spec} to solution_build_flow or use qingflow builder flow apply."
+        app_key = self._get_app_key(store, entity.entity_id)
+        workflow_edit_version_no = self._ensure_edit_version(
+            profile,
+            entity.entity_id,
+            store,
+            app_key=app_key,
+            force_new=True,
+        )
+        node_artifacts = store.get_artifact("apps", entity.entity_id, {}).get("workflow_nodes", {})
+        existing_nodes = self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
+        current_nodes = _coerce_workflow_nodes(existing_nodes)
+        existing_nodes_by_name = {
+            node.get("auditNodeName"): int(node_id)
+            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 current_nodes.items()
+                if isinstance(node, dict) and node.get("type") == 0 and node.get("dealType") == 3
+            ),
+            None,
         )
+        if applicant_node_id is not None:
+            node_artifacts.setdefault("__applicant__", applicant_node_id)
+
+        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
+            if action["action"] == "add_node":
+                if action.get("node_type") == "branch":
+                    existing_branch_id = node_artifacts.get(action["node_id"])
+                    if existing_branch_id is not None and not _workflow_node_is_branch(current_nodes, existing_branch_id):
+                        existing_branch_id = None
+                    if existing_branch_id is not None:
+                        for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, existing_branch_id), start=1):
+                            node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
+                        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
+                        apps_artifact["workflow_nodes"] = node_artifacts
+                        store.set_artifact("apps", entity.entity_id, apps_artifact)
+                        continue
+                existing_node_id = node_artifacts.get(action["node_id"]) or existing_nodes_by_name.get(action.get("node_name"))
+                if existing_node_id is not None:
+                    node_artifacts[action["node_id"]] = existing_node_id
+                    apps_artifact = store.get_artifact("apps", entity.entity_id, {})
+                    apps_artifact["workflow_nodes"] = node_artifacts
+                    store.set_artifact("apps", entity.entity_id, apps_artifact)
+                    continue
+            before_node_ids = set(current_nodes)
+            payload = self._resolve_workflow_payload(action["payload"], node_artifacts)
+            if workflow_edit_version_no is not None:
+                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
+            audit_node_id = _extract_workflow_node_id(result.get("result"), expected_type=expected_type)
+            if action.get("node_type") == "branch" or action["action"] == "create_sub_branch":
+                current_nodes = _coerce_workflow_nodes(
+                    self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
+                )
+            if audit_node_id is not None:
+                node_artifacts[action["node_id"]] = audit_node_id
+            if action.get("node_type") == "branch":
+                branch_node_id = node_artifacts.get(action["node_id"]) or _find_created_branch_node_id(
+                    current_nodes,
+                    before_node_ids=before_node_ids,
+                    prev_id=payload.get("prevId"),
+                )
+                if branch_node_id is not None:
+                    node_artifacts[action["node_id"]] = branch_node_id
+                for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, branch_node_id), start=1):
+                    node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
+            if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is None:
+                created_lane_id = audit_node_id or _find_created_sub_branch_lane_id(
+                    current_nodes,
+                    before_node_ids=before_node_ids,
+                    branch_node_id=payload.get("auditNodeId"),
+                )
+                if created_lane_id is not None:
+                    node_artifacts[action["node_id"]] = created_lane_id
+                apps_artifact = store.get_artifact("apps", entity.entity_id, {})
+                apps_artifact["workflow_nodes"] = node_artifacts
+                store.set_artifact("apps", entity.entity_id, apps_artifact)
+        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
+        apps_artifact["workflow_nodes"] = node_artifacts
+        store.set_artifact("apps", entity.entity_id, apps_artifact)
 
     def _build_views(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         app_key = self._get_app_key(store, entity.entity_id)
@@ -582,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")
@@ -628,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)
@@ -1981,11 +2157,24 @@ 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)
-    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 ""
@@ -2022,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(
@@ -2052,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,
     *,