@josephyan/qingflow-app-user-mcp 1.1.22 → 1.1.24

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@1.1.22
+npm install @josephyan/qingflow-app-user-mcp@1.1.24
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@1.1.22 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@1.1.24 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

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

package/src/qingflow_mcp/builder_facade/service.py

@@ -24897,8 +24897,8 @@ def _build_form_payload_for_edit_fields(
         parsed_section_id = _coerce_positive_int(section.get("section_id"))
         if parsed_section_id is not None:
             wrapper["sectionId"] = parsed_section_id
-        elif template is None and section.get("section_id") is not None:
-            wrapper["sectionId"] = section.get("section_id")
+        elif template is None and _coerce_positive_int(wrapper.get("sectionId")) is None:
+            wrapper.pop("sectionId", None)
         wrapper["innerQuestions"] = inner_rows
         form_rows.append([wrapper])
 

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -2259,6 +2259,7 @@ class AiBuilderTools(ToolBase):
         app_shell_apply_ms = 0
         relation_compile_ms = 0
         app_field_apply_ms = 0
+        relation_repair_ms = 0
         inline_layout_fallback_ms = 0
         child_schema_write_ms = 0
         child_inline_layout_ms = 0
@@ -2307,6 +2308,7 @@ class AiBuilderTools(ToolBase):
                 relation_compile_ms=relation_compile_ms,
                 app_field_apply_ms=app_field_apply_ms,
                 app_schema_parallel_wall_ms=app_field_apply_ms,
+                relation_repair_parallel_wall_ms=relation_repair_ms,
                 native_inline_layout_ms=child_inline_layout_ms,
                 inline_layout_fallback_ms=inline_layout_fallback_ms,
                 child_schema_write_ms=child_schema_write_ms,
@@ -2930,6 +2932,125 @@ class AiBuilderTools(ToolBase):
             item if isinstance(item, dict) else _multi_app_item_failure(index, apps[index], "APP_ITEM_NOT_PROCESSED", "app item was not processed")
             for index, item in enumerate(final_items_by_index)
         ]
+
+        def relation_repair_patches(item: JSONObject) -> list[JSONObject]:
+            details = item.get("details") if isinstance(item.get("details"), dict) else {}
+            repair_plan = details.get("relation_repair_plan") if isinstance(details.get("relation_repair_plan"), list) else []
+            patches: list[JSONObject] = []
+            for plan_item in repair_plan:
+                if not isinstance(plan_item, dict):
+                    continue
+                patch = plan_item.get("suggested_patch")
+                if isinstance(patch, dict):
+                    patches.append(deepcopy(patch))
+            return patches
+
+        relation_repair_jobs: list[JSONObject] = []
+        for item in final_items:
+            if item.get("status") != "partial_success":
+                continue
+            app_key = str(item.get("app_key") or "").strip()
+            patches = relation_repair_patches(item)
+            if app_key and patches:
+                relation_repair_jobs.append({"item": item, "app_key": app_key, "patches": patches})
+
+        def run_relation_repair_job(job: JSONObject) -> JSONObject:
+            app_key = str(job.get("app_key") or "")
+            patches = list(job.get("patches") or [])
+            repair_started_at = time.perf_counter()
+            try:
+                repair_result = self._app_schema_apply_once(
+                    profile=profile,
+                    app_key=app_key,
+                    package_id=None,
+                    app_name="",
+                    app_title="",
+                    icon="",
+                    color="",
+                    visibility=None,
+                    publish=publish,
+                    add_fields=[],
+                    update_fields=patches,
+                    remove_fields=[],
+                    inline_form_layout_sections=None,
+                    allow_inline_layout_fallback=False,
+                )
+                public_repair = _publicize_package_fields(repair_result)
+            except Exception as error:  # pragma: no cover - defensive guard for unexpected worker failures
+                return {"job": job, "elapsed_ms": _elapsed_ms(repair_started_at), "exception": repr(error)}
+            return {
+                "job": job,
+                "elapsed_ms": _elapsed_ms(repair_started_at),
+                "public_repair": public_repair,
+            }
+
+        if relation_repair_jobs:
+            repair_phase_started_at = time.perf_counter()
+            repair_workers = worker_count(len(relation_repair_jobs))
+            repair_outputs: list[JSONObject] = []
+            with ThreadPoolExecutor(max_workers=repair_workers) as executor:
+                futures = [executor.submit(run_relation_repair_job, job) for job in relation_repair_jobs]
+                for future in as_completed(futures):
+                    repair_outputs.append(future.result())
+            relation_repair_ms += _elapsed_ms(repair_phase_started_at)
+            for output in repair_outputs:
+                job = output.get("job") if isinstance(output.get("job"), dict) else {}
+                original = job.get("item") if isinstance(job.get("item"), dict) else {}
+                if not original:
+                    continue
+                index = _coerce_nonnegative_int(original.get("index"))
+                if index is None or index >= len(final_items):
+                    continue
+                repaired_item = deepcopy(original)
+                exception = output.get("exception")
+                if exception:
+                    repaired_item["relation_repair"] = {
+                        "attempted": True,
+                        "status": "failed",
+                        "error_code": "RELATION_REPAIR_EXCEPTION",
+                        "message": str(exception),
+                    }
+                    final_items[index] = repaired_item
+                    continue
+                public_repair = output.get("public_repair") if isinstance(output.get("public_repair"), dict) else {}
+                merge_child_duration(public_repair)
+                if _schema_apply_result_has_write(public_repair):
+                    any_write_executed = True
+                if _schema_apply_result_may_have_write(public_repair):
+                    any_write_may_have_succeeded = True
+                repair_payload: JSONObject = {
+                    "attempted": True,
+                    "status": public_repair.get("status"),
+                    "error_code": public_repair.get("error_code"),
+                    "message": public_repair.get("message"),
+                    "verified": bool(public_repair.get("verified")),
+                    "field_diff": public_repair.get("field_diff") or {},
+                    **({"verification": public_repair.get("verification")} if isinstance(public_repair.get("verification"), dict) else {}),
+                    **({"details": public_repair.get("details")} if isinstance(public_repair.get("details"), dict) else {}),
+                    **({"duration_breakdown_ms": public_repair.get("duration_breakdown_ms")} if isinstance(public_repair.get("duration_breakdown_ms"), dict) else {}),
+                }
+                repaired_item["relation_repair"] = repair_payload
+                repaired_item["field_diff"] = _merge_schema_field_diffs(repaired_item.get("field_diff") or {}, public_repair.get("field_diff") or {})
+                repaired_item["field_diff_details"] = _merge_schema_field_diffs(
+                    repaired_item.get("field_diff_details") or {},
+                    public_repair.get("field_diff_details") or {},
+                )
+                if public_repair.get("status") == "success" and bool(public_repair.get("verified")):
+                    repaired_item["status"] = "success"
+                    repaired_item["error_code"] = None
+                    repaired_item["message"] = "applied schema patch; relation readback repaired"
+                    repaired_item["published"] = bool(public_repair.get("published"))
+                    repaired_item["verified"] = True
+                    original_verification = repaired_item.get("verification") if isinstance(repaired_item.get("verification"), dict) else {}
+                    repair_verification = public_repair.get("verification") if isinstance(public_repair.get("verification"), dict) else {}
+                    merged_verification = {**deepcopy(original_verification), **deepcopy(repair_verification)}
+                    repaired_item["verification"] = merged_verification
+                    details = repaired_item.get("details") if isinstance(repaired_item.get("details"), dict) else {}
+                    details = deepcopy(details)
+                    details.pop("relation_repair_plan", None)
+                    repaired_item["details"] = details
+                final_items[index] = repaired_item
+
         pending_readback = sum(1 for item in final_items if item.get("status") == "pending_readback")
         succeeded = sum(1 for item in final_items if item.get("status") in {"success", "partial_success"})
         failed = sum(1 for item in final_items if item.get("status") == "failed")