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

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, backend_code_int, is_auth_like_error
+from ..errors import QingflowApiError
 from ..tools.app_tools import AppTools
 from ..tools.navigation_tools import NavigationTools
 from ..tools.package_tools import PackageTools
@@ -14,7 +14,6 @@ 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
@@ -36,7 +35,6 @@ class SolutionExecutor:
         role_tools: RoleTools,
         app_tools: AppTools,
         record_tools: RecordTools,
-        workflow_tools: WorkflowTools,
         view_tools: ViewTools,
         chart_tools: QingbiReportTools,
         portal_tools: PortalTools,
@@ -47,7 +45,6 @@ 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
@@ -76,8 +73,7 @@ class SolutionExecutor:
             except Exception as exc:  # noqa: BLE001
                 store.record_step_failed(step.step_name, str(exc), debug_context=debug_context)
                 return store.summary()
-        final_status = "partial_success" if _artifacts_have_post_write_readback_pending(store.data.get("artifacts", {})) else "success"
-        store.mark_finished(status=final_status)
+        store.mark_finished(status="success")
         return store.summary()
 
     def _repair_start_index(self, compiled: CompiledSolution, store: RunArtifactStore) -> int:
@@ -204,11 +200,6 @@ 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:
@@ -353,32 +344,7 @@ class SolutionExecutor:
         updated_items.insert(insert_at, item)
         self.package_tools.package_sort_items(profile=profile, tag_id=tag_id, tag_items=updated_items)
 
-        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_detail = _verify_package_attachment(self.package_tools, profile=profile, tag_id=tag_id, app_key=app_key)
         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):
@@ -400,18 +366,12 @@ 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)
 
@@ -456,123 +416,10 @@ class SolutionExecutor:
     def _build_workflow(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         if entity.workflow_plan is None:
             return
-        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,
+        raise RuntimeError(
+            "Legacy auditNode workflow execution was removed. "
+            "Pass {app_key, spec} to solution_build_flow or use qingflow builder flow apply."
         )
-        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)
@@ -735,23 +582,12 @@ class SolutionExecutor:
                 api_error = _coerce_qingflow_error(exc)
                 if api_error is None or not _is_permission_restricted_error(api_error):
                     raise
-                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,
-                    ),
-                )
+                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")
@@ -792,19 +628,7 @@ class SolutionExecutor:
             return
         try:
             result = self.portal_tools.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft)
-        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,
-                ),
-            )
+        except Exception:  # noqa: BLE001
             return
         store.set_artifact("portal", artifact_key, result)
         store.set_artifact("portal", "result", result)
@@ -2157,24 +1981,11 @@ 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:
-    if is_auth_like_error(error):
-        return False
-    backend_code = backend_code_int(error)
+    try:
+        backend_code = int(error.backend_code)
+    except (TypeError, ValueError):
+        backend_code = None
     if backend_code != 50004:
         return False
     message = error.message or ""
@@ -2211,9 +2022,7 @@ def _coerce_qingflow_error(error: Exception) -> QingflowApiError | None:
 
 
 def _is_permission_restricted_error(error: QingflowApiError) -> bool:
-    if is_auth_like_error(error):
-        return False
-    return backend_code_int(error) in {40002, 40027}
+    return error.backend_code in {40002, 40027}
 
 
 def _required_state_read_blocked_error(
@@ -2243,42 +2052,6 @@ 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,
     *,