@josephyan/qingflow-app-user-mcp 0.2.0-beta.93 → 0.2.0-beta.95

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.93",
+  "version": "0.2.0-beta.95",
   "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 = "0.2.0b93"
+version = "0.2.0b95"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b93"
+_FALLBACK_VERSION = "0.2.0b95"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/builder_facade/service.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
+import base64
 from copy import deepcopy
 from dataclasses import dataclass, field
 import json
 import os
+import random
 import re
+import string
 import tempfile
 from typing import Any, cast
+from urllib.parse import quote_plus, unquote_plus
 from uuid import uuid4
 
 from ..backend_client import BackendRequestContext
@@ -143,6 +147,7 @@ JUDGE_EQUAL_ANY = 9
 JUDGE_FUZZY_MATCH = 19
 JUDGE_INCLUDE_ANY = 20
 DEFAULT_TYPE_RELATION = 2
+DEFAULT_TYPE_FORMULA = 3
 RELATION_TYPE_Q_LINKER = 2
 RELATION_TYPE_CODE_BLOCK = 3
 
@@ -12839,6 +12844,275 @@ _QUESTION_RELATION_SAVE_KEYS = (
     "sortConfig",
 )
 
+_RELATION_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queTempId",
+    "queType",
+    "queOriginType",
+    "queTitle",
+    "queWidth",
+    "scanType",
+    "status",
+    "required",
+    "queHint",
+    "linkedQuestions",
+    "logicalShow",
+    "queDefaultType",
+    "queDefaultValue",
+    "queDefaultValues",
+    "subQueWidth",
+    "innerQuestions",
+    "minOpts",
+    "maxOpts",
+    "beingHide",
+    "beingDesensitized",
+    "relationDisplayMode",
+    "customRenderConfig",
+)
+
+_REFERENCE_CONFIG_SAVE_KEYS = (
+    "referAppKey",
+    "referQueId",
+    "customButtonText",
+    "beingTableSource",
+    "referMatchRules",
+    "canAddData",
+    "dataAdditionButtonText",
+    "canViewProcessLog",
+    "optionalDataNum",
+    "beingDataLogVisible",
+    "beingDefaultFormulaAutoFillEnabled",
+    "defaultValueMatchRules",
+    "configShowForm",
+    "configSortFieldId",
+    "configAsc",
+    "dataShowForm",
+    "defaultRow",
+    "fieldNameShow",
+    "dataSortFieldId",
+    "dataSortAsc",
+)
+
+_REFERENCE_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queTitle",
+    "queType",
+    "queAuth",
+    "ordinal",
+)
+
+_REFERENCE_FILL_RULE_SAVE_KEYS = (
+    "queId",
+    "relatedQueId",
+    "queTitle",
+    "relatedQueTitle",
+)
+
+_REFERENCE_AUTH_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queAuth",
+)
+
+
+def _copy_present_keys(
+    source: dict[str, Any],
+    keys: tuple[str, ...],
+    *,
+    keep_none_keys: tuple[str, ...] = (),
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    keep_none = set(keep_none_keys)
+    for key in keys:
+        if key not in source:
+            continue
+        value = source.get(key)
+        if value is None and key not in keep_none:
+            continue
+        payload[key] = deepcopy(value)
+    return payload
+
+
+def _looks_like_backend_encoded_formula(value: str) -> bool:
+    if len(value) <= 32:
+        return False
+    encoded = value[16:-16]
+    if not encoded:
+        return False
+    try:
+        decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
+        unquote_plus(decoded)
+    except Exception:
+        return False
+    return True
+
+
+def _encode_formula_for_backend_save(value: Any) -> Any:
+    if not isinstance(value, str) or not value:
+        return value
+    if _looks_like_backend_encoded_formula(value):
+        return value
+    encoded = quote_plus(value, encoding="utf-8")
+    b64_value = base64.b64encode(encoded.encode("utf-8")).decode("ascii")
+    alphabet = string.ascii_letters + string.digits
+    prefix = "".join(random.choice(alphabet) for _ in range(16))
+    suffix = "".join(random.choice(alphabet) for _ in range(16))
+    return f"{prefix}{b64_value}{suffix}"
+
+
+def _normalize_formula_defaults_for_save(value: Any) -> None:
+    if isinstance(value, list):
+        for item in value:
+            _normalize_formula_defaults_for_save(item)
+        return
+    if not isinstance(value, dict):
+        return
+    if _coerce_any_int(value.get("queDefaultType")) == DEFAULT_TYPE_FORMULA and value.get("queDefaultValue"):
+        value["queDefaultValue"] = _encode_formula_for_backend_save(value.get("queDefaultValue"))
+    for key in ("subQuestions", "innerQuestions"):
+        nested = value.get(key)
+        if isinstance(nested, (list, dict)):
+            _normalize_formula_defaults_for_save(nested)
+
+
+def _normalize_reference_question_for_save(value: Any, *, ordinal: int) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_QUESTION_SAVE_KEYS)
+    que_id = _coerce_any_int(value.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    if "ordinal" not in payload:
+        payload["ordinal"] = _coerce_nonnegative_int(value.get("ordinal"))
+    if payload.get("ordinal") is None:
+        payload["ordinal"] = ordinal
+    if not any(key in payload for key in ("queId", "queTitle", "queType")):
+        return None
+    return payload
+
+
+def _normalize_reference_fill_rule_for_save(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_FILL_RULE_SAVE_KEYS)
+    que_id = _coerce_nonnegative_int(value.get("queId"))
+    related_que_id = _coerce_nonnegative_int(value.get("relatedQueId", value.get("referQueId")))
+    if que_id is not None:
+        payload["queId"] = que_id
+    if related_que_id is not None:
+        payload["relatedQueId"] = related_que_id
+    if "relatedQueTitle" not in payload and value.get("referQueTitle") is not None:
+        payload["relatedQueTitle"] = str(value.get("referQueTitle") or "")
+    if "queId" not in payload or "relatedQueId" not in payload:
+        return None
+    return payload
+
+
+def _normalize_reference_auth_question_for_save(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_AUTH_QUESTION_SAVE_KEYS)
+    que_id = _coerce_any_int(value.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    que_auth = _coerce_nonnegative_int(value.get("queAuth"))
+    if que_auth is not None:
+        payload["queAuth"] = que_auth
+    sub_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], value.get("subQues") or [])
+        )
+        if item is not None
+    ]
+    inner_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], value.get("innerQues") or [])
+        )
+        if item is not None
+    ]
+    if sub_ques or "subQues" in value:
+        payload["subQues"] = sub_ques
+    if inner_ques or "innerQues" in value:
+        payload["innerQues"] = inner_ques
+    if "queId" not in payload or "queAuth" not in payload:
+        return None
+    return payload
+
+
+def _normalize_reference_config_for_save(
+    reference: Any,
+    *,
+    field: dict[str, Any],
+) -> dict[str, Any]:
+    source = reference if isinstance(reference, dict) else {}
+    payload = _copy_present_keys(source, _REFERENCE_CONFIG_SAVE_KEYS)
+    if str(field.get("target_app_key") or "").strip():
+        payload["referAppKey"] = str(field.get("target_app_key") or "").strip()
+    if field.get("target_field_que_id") is not None:
+        payload["referQueId"] = _coerce_nonnegative_int(field.get("target_field_que_id"))
+    if field.get("field_name_show") is not None:
+        payload["fieldNameShow"] = bool(field.get("field_name_show"))
+
+    refer_questions: list[dict[str, Any]] = []
+    for index, raw_item in enumerate(cast(list[Any], source.get("referQuestions") or []), start=1):
+        normalized_item = _normalize_reference_question_for_save(raw_item, ordinal=index)
+        if normalized_item is not None:
+            refer_questions.append(normalized_item)
+    if refer_questions or "referQuestions" in source:
+        payload["referQuestions"] = refer_questions
+
+    refer_fill_rules = [
+        item
+        for item in (
+            _normalize_reference_fill_rule_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referFillRules") or [])
+        )
+        if item is not None
+    ]
+    if refer_fill_rules or "referFillRules" in source:
+        payload["referFillRules"] = refer_fill_rules
+
+    refer_auth_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referAuthQues") or [])
+        )
+        if item is not None
+    ]
+    if refer_auth_ques or "referAuthQues" in source:
+        payload["referAuthQues"] = refer_auth_ques
+
+    return payload
+
+
+def _normalize_relation_question_for_save(question: dict[str, Any], *, field: dict[str, Any]) -> dict[str, Any]:
+    payload = _copy_present_keys(question, _RELATION_QUESTION_SAVE_KEYS)
+    overlay_keys = _field_question_overlay_keys(field)
+    que_id = _coerce_nonnegative_int(question.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    que_temp_id = _coerce_nonnegative_int(question.get("queTempId"))
+    if que_temp_id is not None and "queId" not in payload:
+        payload["queTempId"] = que_temp_id
+    payload["queType"] = _coerce_positive_int(question.get("queType")) or 25
+    payload["queTitle"] = str(field.get("name") or question.get("queTitle") or "")
+    if "required" in overlay_keys or "required" in question or field.get("required") is not None:
+        payload["required"] = bool(field.get("required", question.get("required", False)))
+    if "description" in overlay_keys:
+        payload["queHint"] = "" if field.get("description") is None else str(field.get("description"))
+    elif "queHint" in question and question.get("queHint") is not None:
+        payload["queHint"] = str(question.get("queHint") or "")
+    if field.get("default_type") is not None:
+        payload["queDefaultType"] = _coerce_positive_int(field.get("default_type")) or 1
+    if "default_value" in field:
+        payload["queDefaultValue"] = field.get("default_value")
+    payload["referenceConfig"] = _normalize_reference_config_for_save(question.get("referenceConfig"), field=field)
+    return payload
+
 
 def _build_form_save_base_payload(current_schema: dict[str, Any], title: str) -> dict[str, Any]:
     payload: dict[str, Any] = {"formTitle": title}
@@ -12863,6 +13137,8 @@ def _normalize_question_relations_for_save(question_relations: list[dict[str, An
             value = relation.get(key)
             if value is None:
                 continue
+            if key == "matchRuleFormula":
+                value = _encode_formula_for_backend_save(value)
             item[key] = deepcopy(value)
         if item:
             normalized.append(item)
@@ -12899,7 +13175,7 @@ def _sync_question_title_references(value: Any, *, by_que_id: dict[int, str], by
     if not isinstance(value, dict):
         return
 
-    title_keys = ("queTitle", "supQueTitle", "_field_id")
+    title_keys = ("queTitle", "_field_id")
     que_id = _coerce_nonnegative_int(value.get("queId"))
     replacement = None
     if que_id is not None and que_id in by_que_id:
@@ -12936,6 +13212,8 @@ def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | N
     if "description" in overlay_keys:
         description = field.get("description")
         template["queHint"] = "" if description is None else str(description)
+    if str(field.get("type") or "") == FieldType.relation.value:
+        return _normalize_relation_question_for_save(template, field=field)
     return template
 
 
@@ -13043,6 +13321,7 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
             if field.get("target_field_que_id") is not None:
                 reference["referQueId"] = field.get("target_field_que_id")
             question["referenceConfig"] = reference
+        question = _normalize_relation_question_for_save(question, field=field)
     if field.get("type") == FieldType.department.value:
         scope_type, scope_payload = _serialize_department_scope_for_question(field.get("department_scope"))
         question["deptSelectScopeType"] = scope_type
@@ -13182,6 +13461,7 @@ def _build_form_payload_from_fields(
     for row in form_rows:
         _apply_row_widths(row)
     payload = default_form_payload(title, form_rows)
+    _normalize_formula_defaults_for_save(payload.get("formQues"))
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     payload["questionRelations"] = _normalize_question_relations_for_save(
         question_relations if question_relations is not None else (current_schema.get("questionRelations") or [])
@@ -13299,6 +13579,7 @@ def _build_form_payload_for_edit_fields(
 
     payload = _build_form_save_base_payload(current_schema, title)
     payload["formQues"] = form_rows
+    _normalize_formula_defaults_for_save(payload.get("formQues"))
     payload["questionRelations"] = normalized_relations
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     return payload
@@ -14715,6 +14996,7 @@ def _build_form_payload_from_existing_schema(
 
     payload = _build_form_save_base_payload(current_schema, str(current_schema.get("formTitle") or "未命名应用"))
     payload["formQues"] = form_rows
+    _normalize_formula_defaults_for_save(payload.get("formQues"))
     payload["questionRelations"] = _normalize_question_relations_for_save(current_schema.get("questionRelations") or [])
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     payload.setdefault("formTitle", current_schema.get("formTitle") or "未命名应用")