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

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-builder-mcp@0.2.0-beta.7
+npm install @josephyan/qingflow-app-builder-mcp@0.2.0-beta.9
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-builder-mcp@0.2.0-beta.7 qingflow-app-builder-mcp
+npx -y -p @josephyan/qingflow-app-builder-mcp@0.2.0-beta.9 qingflow-app-builder-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.9",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b7"
+version = "0.2.0b9"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -2,4 +2,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0b7"
+__version__ = "0.2.0b9"

package/src/qingflow_mcp/builder_facade/models.py

@@ -332,6 +332,8 @@ def _normalize_field_payload(value: Any) -> Any:
     if not isinstance(value, dict):
         return value
     payload = dict(value)
+    if "fields" in payload and "subfields" not in payload:
+        payload["subfields"] = payload.pop("fields")
     raw_type = payload.get("type")
     if isinstance(raw_type, str):
         normalized = FIELD_TYPE_ALIASES.get(raw_type.strip().lower())

package/src/qingflow_mcp/builder_facade/service.py

@@ -233,8 +233,9 @@ class AiBuilderFacade:
                 recoverable=False,
                 suggested_next_call={"tool_name": "auth_whoami", "arguments": {"profile": profile}},
             )
-        current_email = str(session_profile.email or "").strip().lower()
-        current_name = str(session_profile.nick_name or "").strip()
+        identity = self._resolve_current_user_identity(profile=profile)
+        current_email = str(identity.get("email") or "").strip().lower()
+        current_name = str(identity.get("nick_name") or "").strip()
         requested_owner_email = str(lock_owner_email or "").strip().lower()
         requested_owner_name = str(lock_owner_name or "").strip()
         if not requested_owner_email and not requested_owner_name:
@@ -244,8 +245,8 @@ class AiBuilderFacade:
                 normalized_args=normalized_args,
                 recoverable=False,
                 details={
-                    "current_user_email": session_profile.email,
-                    "current_user_name": session_profile.nick_name,
+                    "current_user_email": identity.get("email"),
+                    "current_user_name": identity.get("nick_name"),
                 },
                 suggested_next_call=None,
             )
@@ -263,8 +264,8 @@ class AiBuilderFacade:
                 details={
                     "lock_owner_email": requested_owner_email or None,
                     "lock_owner_name": requested_owner_name or None,
-                    "current_user_email": session_profile.email,
-                    "current_user_name": session_profile.nick_name,
+                    "current_user_email": identity.get("email"),
+                    "current_user_name": identity.get("nick_name"),
                 },
                 suggested_next_call=None,
             )
@@ -307,8 +308,8 @@ class AiBuilderFacade:
             "details": {
                 "lock_owner_email": requested_owner_email or None,
                 "lock_owner_name": requested_owner_name or None,
-                "current_user_email": session_profile.email,
-                "current_user_name": session_profile.nick_name,
+                "current_user_email": identity.get("email"),
+                "current_user_name": identity.get("nick_name"),
                 "edit_version_no": edit_version_no,
             },
             "request_id": None,
@@ -1057,6 +1058,11 @@ class AiBuilderFacade:
             fields=current_fields,
             layout=layout,
         )
+        payload["editVersionNo"] = self._resolve_form_edit_version(
+            profile=profile,
+            app_key=target.app_key,
+            current_schema=schema_result,
+        )
         try:
             self.apps.app_update_form_schema(profile=profile, app_key=target.app_key, payload=payload)
         except (QingflowApiError, RuntimeError) as error:
@@ -1272,6 +1278,11 @@ class AiBuilderFacade:
             current_schema=schema_result,
             layout=target_layout,
         )
+        payload["editVersionNo"] = self._resolve_form_edit_version(
+            profile=profile,
+            app_key=app_key,
+            current_schema=schema_result,
+        )
         applied_layout = target_layout
         fallback_applied = None
         try:
@@ -1284,6 +1295,11 @@ class AiBuilderFacade:
                     current_schema=schema_result,
                     layout=flattened_layout,
                 )
+                fallback_payload["editVersionNo"] = self._resolve_form_edit_version(
+                    profile=profile,
+                    app_key=app_key,
+                    current_schema=schema_result,
+                )
                 try:
                     self.apps.app_update_form_schema(profile=profile, app_key=app_key, payload=fallback_payload)
                     applied_layout = flattened_layout
@@ -1874,6 +1890,13 @@ class AiBuilderFacade:
             "published": True,
         }
 
+    def _resolve_form_edit_version(self, *, profile: str, app_key: str, current_schema: dict[str, Any]) -> int:
+        try:
+            version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+        except (QingflowApiError, RuntimeError):
+            version_result = {}
+        return _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or int(current_schema.get("editVersionNo") or 1)
+
     def _append_publish_result(self, *, profile: str, app_key: str, publish: bool, response: JSONObject) -> JSONObject:
         response["publish_requested"] = publish
         if not publish:
@@ -2118,6 +2141,33 @@ class AiBuilderFacade:
         payload.setdefault("ws_id", session_profile.selected_ws_id)
         return payload
 
+    def _resolve_current_user_identity(self, *, profile: str) -> JSONObject:
+        session_profile = self.apps.sessions.get_profile(profile)
+        backend_session = self.apps.sessions.get_backend_session(profile)
+        current_email = str((session_profile.email if session_profile else None) or "").strip()
+        current_name = str((session_profile.nick_name if session_profile else None) or "").strip()
+        if current_email or current_name or session_profile is None or backend_session is None:
+            return {"email": current_email or None, "nick_name": current_name or None}
+        try:
+            user_info = self.apps.backend.request(
+                "GET",
+                BackendRequestContext(
+                    base_url=backend_session.base_url,
+                    token=backend_session.token,
+                    ws_id=session_profile.selected_ws_id,
+                    qf_version=backend_session.qf_version,
+                    qf_version_source=backend_session.qf_version_source,
+                ),
+                "/user",
+            )
+        except (QingflowApiError, RuntimeError):
+            return {"email": current_email or None, "nick_name": current_name or None}
+        if not isinstance(user_info, dict):
+            return {"email": current_email or None, "nick_name": current_name or None}
+        resolved_email = str(user_info.get("email") or "").strip() or None
+        resolved_name = str(user_info.get("nickName") or user_info.get("displayName") or user_info.get("name") or "").strip() or None
+        return {"email": resolved_email, "nick_name": resolved_name}
+
     def _attach_app_to_package(self, *, profile: str, app_key: str, app_title: str, package_tag_id: int) -> None:
         detail = self.packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=True)
         result = detail.get("result") if isinstance(detail.get("result"), dict) else {}

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

@@ -249,7 +249,7 @@ def build_question(field: dict[str, Any], temp_id: int) -> tuple[dict[str, Any],
             sub_question, next_temp_id = build_question(subfield, next_temp_id)
             sub_questions.append(sub_question)
         question["subQuestions"] = sub_questions
-        question["innerQuestions"] = deepcopy(sub_questions)
+        question["innerQuestions"] = [deepcopy(sub_questions)]
         question["queDefaultValues"] = {"queId": temp_id, "queTitle": field["label"], "queType": que_type, "values": [], "tableValues": []}
     return question, next_temp_id
 

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)
@@ -69,7 +74,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,
@@ -106,11 +111,13 @@ def _build_audit_user_infos(node) -> dict[str, Any]:
     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

@@ -415,13 +415,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 +429,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
@@ -2046,6 +2059,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)

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import time
 
 from pydantic import ValidationError
 
@@ -276,12 +277,22 @@ class AiBuilderTools(ToolBase):
 
     def package_attach_app(self, *, profile: str, tag_id: int, app_key: str, app_title: str = "") -> JSONObject:
         normalized_args = {"tag_id": tag_id, "app_key": app_key, "app_title": app_title}
-        return _safe_tool_call(
+        result = _safe_tool_call(
             lambda: self._facade.package_attach_app(profile=profile, tag_id=tag_id, app_key=app_key, app_title=app_title),
             error_code="PACKAGE_ATTACH_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "package_attach_app", "arguments": {"profile": profile, **normalized_args}},
         )
+        return self._retry_after_self_lock_release(
+            profile=profile,
+            result=result,
+            retry_call=lambda: self._facade.package_attach_app(
+                profile=profile,
+                tag_id=tag_id,
+                app_key=app_key,
+                app_title=app_title,
+            ),
+        )
 
     def app_release_edit_lock_if_mine(
         self,
@@ -576,7 +587,7 @@ class AiBuilderTools(ToolBase):
             "update_fields": [patch.model_dump(mode="json") for patch in parsed_update],
             "remove_fields": [patch.model_dump(mode="json") for patch in parsed_remove],
         }
-        return _safe_tool_call(
+        result = _safe_tool_call(
             lambda: self._facade.app_schema_apply(
                 profile=profile,
                 app_key=app_key,
@@ -592,6 +603,17 @@ class AiBuilderTools(ToolBase):
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_schema_apply", "arguments": {"profile": profile, **normalized_args}},
         )
+        return self._retry_after_self_lock_release(profile=profile, result=result, retry_call=lambda: self._facade.app_schema_apply(
+            profile=profile,
+            app_key=app_key,
+            package_tag_id=package_tag_id,
+            app_name=effective_app_name,
+            create_if_missing=create_if_missing,
+            publish=publish,
+            add_fields=parsed_add,
+            update_fields=parsed_update,
+            remove_fields=parsed_remove,
+        ))
 
     def app_layout_apply(self, *, profile: str, app_key: str, mode: str = "merge", publish: bool = True, sections: list[JSONObject]) -> JSONObject:
         try:
@@ -632,12 +654,23 @@ class AiBuilderTools(ToolBase):
             "publish": publish,
             "sections": [section.model_dump(mode="json") for section in parsed_sections],
         }
-        return _safe_tool_call(
+        result = _safe_tool_call(
             lambda: self._facade.app_layout_apply(profile=profile, app_key=app_key, mode=parsed_mode, publish=publish, sections=parsed_sections),
             error_code="LAYOUT_APPLY_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_layout_apply", "arguments": {"profile": profile, **normalized_args}},
         )
+        return self._retry_after_self_lock_release(
+            profile=profile,
+            result=result,
+            retry_call=lambda: self._facade.app_layout_apply(
+                profile=profile,
+                app_key=app_key,
+                mode=parsed_mode,
+                publish=publish,
+                sections=parsed_sections,
+            ),
+        )
 
     def app_flow_apply(
         self,
@@ -680,7 +713,7 @@ class AiBuilderTools(ToolBase):
             "nodes": [node.model_dump(mode="json") for node in request.nodes],
             "transitions": [transition.model_dump(mode="json", by_alias=True) for transition in request.transitions],
         }
-        return _safe_tool_call(
+        result = _safe_tool_call(
             lambda: self._facade.app_flow_apply(
                 profile=profile,
                 app_key=request.app_key,
@@ -693,6 +726,18 @@ class AiBuilderTools(ToolBase):
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_flow_apply", "arguments": {"profile": profile, **normalized_args}},
         )
+        return self._retry_after_self_lock_release(
+            profile=profile,
+            result=result,
+            retry_call=lambda: self._facade.app_flow_apply(
+                profile=profile,
+                app_key=request.app_key,
+                mode=request.mode,
+                publish=publish,
+                nodes=[node.model_dump(mode="json") for node in request.nodes],
+                transitions=[transition.model_dump(mode="json", by_alias=True) for transition in request.transitions],
+            ),
+        )
 
     def app_views_apply(
         self,
@@ -724,21 +769,98 @@ class AiBuilderTools(ToolBase):
             "upsert_views": [view.model_dump(mode="json") for view in parsed_views],
             "remove_views": list(remove_views),
         }
-        return _safe_tool_call(
+        result = _safe_tool_call(
             lambda: self._facade.app_views_apply(profile=profile, app_key=app_key, publish=publish, upsert_views=parsed_views, remove_views=remove_views),
             error_code="VIEWS_APPLY_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_views_apply", "arguments": {"profile": profile, **normalized_args}},
         )
+        return self._retry_after_self_lock_release(
+            profile=profile,
+            result=result,
+            retry_call=lambda: self._facade.app_views_apply(
+                profile=profile,
+                app_key=app_key,
+                publish=publish,
+                upsert_views=parsed_views,
+                remove_views=remove_views,
+            ),
+        )
 
     def app_publish_verify(self, *, profile: str, app_key: str, expected_package_tag_id: int | None = None) -> JSONObject:
         normalized_args = {"app_key": app_key, "expected_package_tag_id": expected_package_tag_id}
-        return _safe_tool_call(
+        result = _safe_tool_call(
             lambda: self._facade.app_publish_verify(profile=profile, app_key=app_key, expected_package_tag_id=expected_package_tag_id),
             error_code="PUBLISH_VERIFY_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_publish_verify", "arguments": {"profile": profile, **normalized_args}},
         )
+        return self._retry_after_self_lock_release(
+            profile=profile,
+            result=result,
+            retry_call=lambda: self._facade.app_publish_verify(
+                profile=profile,
+                app_key=app_key,
+                expected_package_tag_id=expected_package_tag_id,
+            ),
+        )
+
+    def _retry_after_self_lock_release(self, *, profile: str, result: JSONObject, retry_call) -> JSONObject:
+        if not isinstance(result, dict) or result.get("status") != "failed" or result.get("error_code") != "APP_EDIT_LOCKED":
+            return result
+        suggested = result.get("suggested_next_call")
+        if not isinstance(suggested, dict) or suggested.get("tool_name") != "app_release_edit_lock_if_mine":
+            return result
+        arguments = suggested.get("arguments")
+        if not isinstance(arguments, dict):
+            return result
+        app_key = str(arguments.get("app_key") or "")
+        lock_owner_email = str(arguments.get("lock_owner_email") or "")
+        lock_owner_name = str(arguments.get("lock_owner_name") or "")
+        release_attempts: list[JSONObject] = []
+        retried: JSONObject = result
+        for _ in range(3):
+            release_result = self.app_release_edit_lock_if_mine(
+                profile=profile,
+                app_key=app_key,
+                lock_owner_email=lock_owner_email,
+                lock_owner_name=lock_owner_name,
+            )
+            release_attempts.append(release_result)
+            if not isinstance(release_result, dict) or release_result.get("status") != "success":
+                result.setdefault("details", {})
+                if isinstance(result["details"], dict):
+                    result["details"]["edit_lock_release_result"] = release_result
+                    result["details"]["edit_lock_release_attempts"] = release_attempts
+                return result
+            retried = retry_call()
+            if not (
+                isinstance(retried, dict)
+                and retried.get("status") == "failed"
+                and retried.get("error_code") == "APP_EDIT_LOCKED"
+            ):
+                break
+            time.sleep(0.2)
+        if (
+            isinstance(retried, dict)
+            and retried.get("status") == "failed"
+            and retried.get("error_code") == "APP_EDIT_LOCKED"
+        ):
+            retried = {
+                **retried,
+                "error_code": "PERSISTENT_SELF_LOCK",
+                "message": "app remains locked by the current user's active editor session after repeated forced release attempts",
+                "recoverable": True,
+                "suggested_next_call": None,
+            }
+        if isinstance(retried, dict):
+            retried.setdefault("details", {})
+            if isinstance(retried["details"], dict):
+                retried["details"]["edit_lock_release_result"] = release_attempts[-1] if release_attempts else None
+                retried["details"]["edit_lock_release_attempts"] = release_attempts
+            retried["edit_lock_released"] = bool(release_attempts)
+            retried["retried_after_edit_lock_release"] = True
+        return retried
 
 
 def _validation_failure(detail: str, *, suggested_next_call: JSONObject | None = None) -> JSONObject: