@josephyan/qingflow-app-builder-mcp 0.2.0-beta.1014 → 0.2.0-beta.1016

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.1014",
+  "version": "0.2.0-beta.1016",
   "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.0b1014"
+version = "0.2.0b1016"
 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.0b1014"
+_FALLBACK_VERSION = "0.2.0b1016"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/cli/formatters.py

@@ -407,6 +407,13 @@ def _format_import_status(result: dict[str, Any]) -> str:
         f"Failed Rows: {result.get('failed') or 0}",
         f"Progress: {result.get('progress') or '-'}",
     ]
+    if result.get("process_status") not in (None, ""):
+        lines.append(f"Process Status: {result.get('process_status')}")
+    error_file_urls = result.get("error_file_urls") if isinstance(result.get("error_file_urls"), list) else []
+    if error_file_urls:
+        lines.append("Error Files:")
+        for url in error_file_urls:
+            lines.append(f"- {url}")
     _append_warnings(lines, result.get("warnings"))
     _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"

package/src/qingflow_mcp/errors.py

@@ -54,8 +54,8 @@ class QingflowApiError(Exception):
         )
 
     @classmethod
-    def config_error(cls, message: str) -> "QingflowApiError":
-        return cls(category="config", message=message)
+    def config_error(cls, message: str, *, details: JSONObject | None = None) -> "QingflowApiError":
+        return cls(category="config", message=message, details=details)
 
     @classmethod
     def not_supported(cls, message: str) -> "QingflowApiError":

package/src/qingflow_mcp/response_trim.py

@@ -666,7 +666,6 @@ def _trim_import_status_payload(payload: JSONObject) -> None:
         "total_rows",
         "success_rows",
         "failed_rows",
-        "error_file_urls",
         "operate_time",
         "operate_user",
         "verification",

package/src/qingflow_mcp/tools/export_tools.py

@@ -19,6 +19,7 @@ from .base import ToolBase, tool_cn_name
 from .record_tools import (
     AccessibleViewRoute,
     DEFAULT_LIST_PAGE_SIZE,
+    FormField,
     LAYOUT_ONLY_QUE_TYPES,
     RecordTools,
     _normalize_public_column_selectors,
@@ -191,6 +192,8 @@ class ExportTools(ToolBase):
             filter_bean = self._build_export_filter_bean(
                 resolved_view,
                 selected_record_ids=effective_record_ids,
+                order_by=normalized_order_by,
+                row_scope=row_scope,
                 include_workflow_log=include_workflow_log,
             )
             started_at = _utc_now().replace(microsecond=0).isoformat()
@@ -731,13 +734,31 @@ class ExportTools(ToolBase):
         resolved_view: AccessibleViewRoute,
         *,
         selected_record_ids: list[int],
+        order_by: list[JSONObject],
+        row_scope: str,
         include_workflow_log: bool,
     ) -> JSONObject:
         filter_payload: JSONObject = {}
         if resolved_view.kind == "system" and resolved_view.list_type is not None:
             filter_payload["type"] = resolved_view.list_type
+        elif resolved_view.kind == "custom":
+            # Custom-view native export later flows through shared data-export code that
+            # expects a list semantics integer. Frontend export treats custom views as
+            # creator-all style export, so mirror LIST_CREATOR_ALL here.
+            filter_payload["type"] = DEFAULT_RECORD_LIST_TYPE
         if selected_record_ids:
             filter_payload["applyIds"] = selected_record_ids
+        if row_scope == "queried" and order_by:
+            normalized_sorts = [
+                {
+                    "queId": field_id,
+                    "isAscend": str(item.get("direction") or "asc").strip().lower() != "desc",
+                }
+                for item in order_by
+                if isinstance(item, dict) and (field_id := _coerce_int(item.get("field_id"))) is not None
+            ]
+            if normalized_sorts:
+                filter_payload["sorts"] = normalized_sorts
         return {
             "filter": filter_payload,
             # Backend export code later auto-unboxes this field to primitive boolean.
@@ -763,18 +784,14 @@ class ExportTools(ToolBase):
         )
         index = browse_scope["index"]
         visible_question_ids = cast(set[int], browse_scope.get("visible_question_ids") or set())
-        ordered_visible_fields = [
-            field
-            for field in self._record_tools._schema_fields_for_mode(
-                profile,
-                context,
-                app_key,
-                index,
-                schema_mode="browse",
-                resolved_view=resolved_view,
-            )
-            if field.que_id in visible_question_ids and field.que_type not in LAYOUT_ONLY_QUE_TYPES
-        ]
+        ordered_visible_fields, warnings = self._resolve_exportable_fields(
+            profile=profile,
+            context=context,
+            app_key=app_key,
+            resolved_view=resolved_view,
+            index=index,
+            visible_question_ids=visible_question_ids,
+        )
         if not ordered_visible_fields:
             ordered_visible_fields = [
                 field
@@ -805,7 +822,6 @@ class ExportTools(ToolBase):
         else:
             selected_fields = ordered_visible_fields
         question_export_config_list: list[JSONObject] = []
-        warnings: list[JSONObject] = []
         for field in selected_fields:
             if field.que_type is None:
                 warnings.append(
@@ -830,6 +846,79 @@ class ExportTools(ToolBase):
             )
         return {"questionExportConfigList": question_export_config_list}, warnings
 
+    def _resolve_exportable_fields(
+        self,
+        *,
+        profile: str,
+        context,
+        app_key: str,
+        resolved_view: AccessibleViewRoute,
+        index,
+        visible_question_ids: set[int],
+    ) -> tuple[list[FormField], list[JSONObject]]:  # type: ignore[no-untyped-def]
+        warnings: list[JSONObject] = []
+        if resolved_view.kind == "custom" and resolved_view.view_selection is not None:
+            custom_fields = self._resolve_custom_view_exportable_fields(
+                profile=profile,
+                context=context,
+                app_key=app_key,
+                view_key=resolved_view.view_selection.view_key,
+                index=index,
+                visible_question_ids=visible_question_ids,
+            )
+            if custom_fields is not None:
+                return custom_fields, warnings
+            warnings.append(
+                {
+                    "code": "EXPORT_VIEW_CONFIG_PARTIAL",
+                    "message": "custom view export fields fell back to schema order because viewConfig could not provide exportable field entries",
+                }
+            )
+        ordered_visible_fields = [
+            field
+            for field in self._record_tools._schema_fields_for_mode(
+                profile,
+                context,
+                app_key,
+                index,
+                schema_mode="browse",
+                resolved_view=resolved_view,
+            )
+            if field.que_id in visible_question_ids and field.que_type not in LAYOUT_ONLY_QUE_TYPES
+        ]
+        return ordered_visible_fields, warnings
+
+    def _resolve_custom_view_exportable_fields(
+        self,
+        *,
+        profile: str,
+        context,
+        app_key: str,
+        view_key: str,
+        index,
+        visible_question_ids: set[int],
+    ) -> list[FormField] | None:  # type: ignore[no-untyped-def]
+        view_config = self._record_tools._get_view_config(profile, context, view_key)
+        if not isinstance(view_config, dict):
+            return None
+        entries = _extract_export_view_question_entries(view_config.get("viewgraphQuestions"))
+        if not entries:
+            return []
+        ordered_fields: list[FormField] = []
+        seen: set[int] = set()
+        for entry in entries:
+            if not bool(entry.get("downloadable", True)):
+                continue
+            field_id = _coerce_int(entry.get("field_id"))
+            if field_id is None or field_id in seen:
+                continue
+            field = cast(FormField | None, cast(Any, index).by_id.get(str(field_id)))
+            if field is None or field.que_type in LAYOUT_ONLY_QUE_TYPES:
+                continue
+            ordered_fields.append(field)
+            seen.add(field_id)
+        return ordered_fields
+
     def _estimate_export_result_amount(
         self,
         context,
@@ -1241,6 +1330,58 @@ def _coerce_int(value: Any) -> int | None:
         return None
 
 
+def _coerce_positive_int(value: Any) -> int | None:
+    parsed = _coerce_int(value)
+    if parsed is None or parsed <= 0:
+        return None
+    return parsed
+
+
+def _extract_export_view_question_entries(questions: Any) -> list[JSONObject]:
+    if not isinstance(questions, list):
+        return []
+    entries: list[JSONObject] = []
+    fallback_order = 0
+
+    def walk(nodes: Any) -> None:
+        nonlocal fallback_order
+        if not isinstance(nodes, list):
+            return
+        for item in nodes:
+            if not isinstance(item, dict):
+                continue
+            children: list[Any] = []
+            for child_key in ("innerQues", "subQues", "innerQuestions", "subQuestions"):
+                child_value = item.get(child_key)
+                if isinstance(child_value, list) and child_value:
+                    children.extend(child_value)
+            if children:
+                walk(children)
+                continue
+            field_id = _coerce_int(item.get("queId"))
+            if field_id is None:
+                continue
+            fallback_order += 1
+            downloadable_raw = item.get("beingDownload")
+            entries.append(
+                {
+                    "field_id": field_id,
+                    "name": str(item.get("queTitle") or "").strip(),
+                    "display_order": _coerce_positive_int(item.get("displayOrdinal")) or fallback_order,
+                    "downloadable": bool(downloadable_raw) if downloadable_raw is not None else True,
+                }
+            )
+
+    walk(questions)
+    return sorted(
+        entries,
+        key=lambda entry: (
+            _coerce_positive_int(entry.get("display_order")) if _coerce_positive_int(entry.get("display_order")) is not None else 10**9,
+            str(entry.get("name") or ""),
+        ),
+    )
+
+
 def _normalize_export_columns(columns: list[JSONObject | int]) -> list[int]:
     normalized: list[int] = []
     for field_id in _normalize_public_column_selectors(columns):

package/src/qingflow_mcp/tools/import_tools.py

@@ -37,6 +37,13 @@ SAFE_REPAIRS = {
     "normalize_url_cells",
 }
 EMAIL_PATTERN = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+IMPORT_STATUS_BY_PROCESS_STATUS = {
+    1: "queued",
+    2: "running",
+    3: "succeeded",
+    4: "failed",
+    5: "partially_failed",
+}
 
 
 class ImportTools(ToolBase):
@@ -866,13 +873,26 @@ class ImportTools(ToolBase):
                         "process_id_str": normalized_process,
                     },
                 )
+            raw_process_status = matched_record.get("processStatus")
             total_rows = _coerce_int(matched_record.get("totalNumber") or matched_record.get("total_rows"))
             success_rows = _coerce_int(matched_record.get("successNum") or matched_record.get("success_rows"))
             failed_rows = _coerce_int(matched_record.get("errorNum") or matched_record.get("failed_rows"))
             progress = _coerce_int(matched_record.get("importPercentage") or matched_record.get("progress"))
+            normalized_status = _normalize_import_status(raw_process_status)
+            warnings: list[dict[str, str]] = []
+            if normalized_status in {"succeeded", "failed", "partially_failed"} and all(
+                value is None for value in (total_rows, success_rows, failed_rows)
+            ):
+                warnings.append(
+                    {
+                        "code": "IMPORT_STATUS_COUNTERS_MISSING",
+                        "message": "backend import history returned a terminal process status without row counters",
+                    }
+                )
             return {
                 "ok": True,
-                "status": _normalize_optional_text(matched_record.get("processStatus")) or "unknown",
+                "status": normalized_status,
+                "process_status": _coerce_int(raw_process_status),
                 "app_key": resolved_app_key,
                 "import_id": normalized_import_id or (local_job.get("import_id") if isinstance(local_job, dict) else None),
                 "process_id_str": normalized_process,
@@ -885,7 +905,7 @@ class ImportTools(ToolBase):
                 "error_file_urls": _normalize_error_file_urls(matched_record.get("errorFileUrls")),
                 "operate_time": matched_record.get("operateTime"),
                 "operate_user": matched_record.get("operateUser"),
-                "warnings": [],
+                "warnings": warnings,
                 "verification": {
                     "status_lookup_completed": True,
                     "matched_by": matched_by,
@@ -2217,6 +2237,26 @@ def _coerce_int(value: Any) -> int | None:
         return None
 
 
+def _normalize_import_status(value: Any) -> str:
+    status_code = _coerce_int(value)
+    if status_code is not None:
+        return IMPORT_STATUS_BY_PROCESS_STATUS.get(status_code, "unknown")
+    text = str(value or "").strip().lower()
+    if text in {"queued", "running", "succeeded", "failed", "partially_failed", "unknown"}:
+        return text
+    if text in {"line_up", "lineup"}:
+        return "queued"
+    if text in {"execute", "executing", "processing"}:
+        return "running"
+    if text in {"success", "completed"}:
+        return "succeeded"
+    if text in {"partly_fail", "partial_fail", "partially_fail", "partial_failed"}:
+        return "partially_failed"
+    if text in {"fail", "error"}:
+        return "failed"
+    return "unknown"
+
+
 def _normalize_error_file_urls(value: Any) -> list[str]:
     if isinstance(value, list):
         return [str(item).strip() for item in value if str(item).strip()]

package/src/qingflow_mcp/tools/record_tools.py

@@ -6890,6 +6890,8 @@ class RecordTools(ToolBase):
             isinstance(payload.get("viewgraphLimit"), list)
             or isinstance(payload.get("viewConfig"), dict)
             or isinstance(payload.get("viewgraphConfig"), dict)
+            or isinstance(payload.get("viewgraphQuestions"), list)
+            or isinstance(payload.get("viewgraphQueIds"), list)
         ):
             config = payload
         else: