@josephyan/qingflow-app-user-mcp 0.2.0-beta.1007 → 0.2.0-beta.1010

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.1007",
+  "version": "0.2.0-beta.1010",
   "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.0b1007"
+version = "0.2.0b1010"
 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.0b1007"
+_FALLBACK_VERSION = "0.2.0b1010"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/backend_client.py

@@ -474,6 +474,115 @@ class BackendClient:
                 pass
         return import_result
 
+    def start_socket_record_export(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        view_id: str,
+        filter_bean: JSONObject,
+        export_config: JSONObject,
+        view_key: str | None = None,
+        result_amount: int = 0,
+        ack_timeout_seconds: float = 8.0,
+    ) -> dict[str, Any]:
+        try:
+            import socketio  # type: ignore[import-not-found]
+        except ImportError as exc:
+            raise QingflowApiError(
+                category="config",
+                message=f"socket.io client dependency is missing: {exc}",
+            )
+
+        socket_base_url = self._build_socket_base_url(context.base_url)
+        export_result: dict[str, Any] = {
+            "backend_export_id": None,
+            "warnings": [],
+        }
+        sio = socketio.Client(reconnection=False, logger=False, engineio_logger=False)
+        event_name = "excelViewgraph" if view_key else "excel"
+        event_args: tuple[Any, ...]
+        if view_key:
+            event_args = (
+                context.token,
+                None,
+                view_key,
+                filter_bean,
+                export_config,
+                int(result_amount),
+            )
+        else:
+            event_args = (
+                context.token,
+                app_key,
+                filter_bean,
+                export_config,
+                int(result_amount),
+            )
+        try:
+            sio.connect(
+                socket_base_url,
+                transports=["websocket"],
+                socketio_path="socket.io",
+                headers=self._base_headers(
+                    context.token,
+                    context.ws_id,
+                    qf_version=context.qf_version,
+                ),
+                wait_timeout=ack_timeout_seconds,
+            )
+            sio.emit("token", context.token)
+            sleep(0.2)
+            ack = sio.call(
+                event_name,
+                event_args,
+                timeout=ack_timeout_seconds,
+            )
+            ack_payload = ack[0] if isinstance(ack, list) and ack else ack
+            export_id: Any = ack_payload
+            if isinstance(ack_payload, dict):
+                error_code = ack_payload.get("error")
+                ack_message = ack_payload.get("message")
+                export_id = ack_payload.get("data")
+                if isinstance(export_id, dict):
+                    export_id = (
+                        export_id.get("exportId")
+                        or export_id.get("export_id")
+                        or export_id.get("id")
+                    )
+                if error_code not in (None, 0):
+                    raise QingflowApiError(
+                        category="backend",
+                        message=str(ack_message or f"socket export rejected with error {error_code}"),
+                        details={
+                            "socket_error_code": error_code,
+                            "app_key": app_key,
+                            "view_id": view_id,
+                            "view_key": view_key,
+                        },
+                    )
+            if not export_id:
+                raise QingflowApiError(category="backend", message="socket export ack did not return export_id")
+            export_result["backend_export_id"] = str(export_id)
+        except Exception as exc:
+            message = str(exc)
+            if "timeout" in message.lower():
+                raise QingflowApiError(
+                    category="network",
+                    message="socket export ack timed out",
+                    details={"error_code": "EXPORT_SOCKET_ACK_TIMEOUT"},
+                )
+            if isinstance(exc, QingflowApiError):
+                raise
+            raise QingflowApiError(category="network", message=message or "socket export failed")
+        finally:
+            try:
+                if sio.connected:
+                    sio.disconnect()
+            except Exception:
+                pass
+        return export_result
+
     def _request_with_meta(
         self,
         method: str,

package/src/qingflow_mcp/cli/commands/__init__.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import argparse
 
-from . import app, auth, builder, chart, imports, portal, record, task, view, workspace
+from . import app, auth, builder, chart, exports, imports, portal, record, task, view, workspace
 
 
 def register_all_commands(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -14,5 +14,6 @@ def register_all_commands(subparsers: argparse._SubParsersAction[argparse.Argume
     chart.register(subparsers)
     record.register(subparsers)
     imports.register(subparsers)
+    exports.register(subparsers)
     task.register(subparsers)
     builder.register(subparsers)

package/src/qingflow_mcp/cli/commands/exports.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import argparse
+
+from ..context import CliContext
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser("export", help="导出")
+    export_subparsers = parser.add_subparsers(dest="export_command", required=True)
+
+    start = export_subparsers.add_parser("start", help="启动导出")
+    start.add_argument("--app-key", required=True)
+    start.add_argument("--view-id", default="system:all")
+    start.set_defaults(handler=_handle_start, format_hint="export_start")
+
+    status = export_subparsers.add_parser("status", help="查询导出状态")
+    status.add_argument("--export-handle", required=True)
+    status.set_defaults(handler=_handle_status, format_hint="export_status")
+
+    get = export_subparsers.add_parser("get", help="获取导出结果")
+    get.add_argument("--export-handle", required=True)
+    get.add_argument("--download-to-path")
+    get.set_defaults(handler=_handle_get, format_hint="export_get")
+
+    direct = export_subparsers.add_parser("direct", help="直接导出并下载")
+    direct.add_argument("--app-key", required=True)
+    direct.add_argument("--view-id", default="system:all")
+    direct.add_argument("--download-to-path")
+    direct.add_argument("--wait-timeout-seconds", type=float)
+    direct.set_defaults(handler=_handle_direct, format_hint="export_direct")
+
+
+def _handle_start(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_start(
+        profile=args.profile,
+        app_key=args.app_key,
+        view_id=args.view_id,
+    )
+
+
+def _handle_status(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_status_get(
+        profile=args.profile,
+        export_handle=args.export_handle,
+    )
+
+
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_get(
+        profile=args.profile,
+        export_handle=args.export_handle,
+        download_to_path=args.download_to_path,
+    )
+
+
+def _handle_direct(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_direct(
+        profile=args.profile,
+        app_key=args.app_key,
+        view_id=args.view_id,
+        download_to_path=args.download_to_path,
+        wait_timeout_seconds=args.wait_timeout_seconds,
+    )

package/src/qingflow_mcp/cli/commands/task.py

@@ -212,25 +212,15 @@ def _run_task_workbench_task_loop(args: argparse.Namespace, context: CliContext)
         detail_selection = _show_task_workbench_detail(args, task_context)
         if detail_selection.status == "cancelled":
             return "back", ""
-        if str(detail_selection.value or "") == "exit":
+        selected_value = str(detail_selection.value or "").strip()
+        if selected_value == "exit":
             return "result", cancelled_result("已退出")
-        if str(detail_selection.value or "") != "action":
+        if selected_value == "back":
             return "back", ""
-
-        action_selection = _choose_task_action_interactively(
-            args,
-            task_context,
-            fields={},
-            title=_build_task_action_title(task_context),
-        )
-        if action_selection.status == "cancelled":
-            continue
-        if action_selection.status == "empty":
+        if not selected_value:
             continue
-        if action_selection.status != "selected":
-            return "result", cancelled_result("已退出")
 
-        args.action = str(action_selection.value or "").strip()
+        args.action = selected_value
         payload_selection = _resolve_action_payload_or_select(args, task_context, payload={})
         if _is_cancelled_result(payload_selection):
             continue
@@ -421,35 +411,8 @@ def _choose_task_action_interactively(
     fields: dict[str, Any],
     title: str = "选择操作",
 ):
-    data = task_context.get("data") if isinstance(task_context.get("data"), dict) else {}
-    available_actions = [str(item).strip() for item in (data.get("available_actions") or []) if str(item).strip()]
-    extras = data.get("extras") if isinstance(data.get("extras"), dict) else {}
-    action_metadata = data.get("action_metadata") if isinstance(data.get("action_metadata"), dict) else {}
-    feedback_required = {
-        str(item).strip()
-        for item in (action_metadata.get("feedback_required_for") or [])
-        if str(item).strip()
-    }
-    rollback_count = _count_candidate_items(extras.get("rollback_candidates"))
-    transfer_count = _count_candidate_items(extras.get("transfer_candidates"))
-
     def load_options() -> list[SelectionOption[str]]:
-        options: list[SelectionOption[str]] = []
-        for action in available_actions:
-            if action == "save_only" and not fields:
-                continue
-            label = TASK_ACTION_LABELS.get(action, action)
-            hint_parts = [action]
-            if action in feedback_required:
-                hint_parts.append("需要理由")
-            if action == "rollback":
-                hint_parts.append(f"可退回节点 {rollback_count}")
-            if action == "transfer":
-                hint_parts.append(f"可转交成员 {transfer_count}")
-            if action == "save_only":
-                hint_parts.append("仅保存字段，不推进流程")
-            options.append(SelectionOption(value=action, label=label, hint=" · ".join(hint_parts)))
-        return options
+        return _task_interactive_action_options(task_context, fields=fields)
 
     return resolve_interactive_selection(
         args,
@@ -461,14 +424,11 @@ def _choose_task_action_interactively(
 
 
 def _show_task_workbench_detail(args: argparse.Namespace, task_context: dict[str, Any]):
-    has_actions = _task_has_interactive_actions(task_context)
-
     def load_options() -> list[SelectionOption[str]]:
-        if has_actions:
-            return [
-                SelectionOption(value="action", label="执行操作", hint="查看当前节点可执行动作"),
-                SelectionOption(value="back", label="返回列表", hint="回到待办列表"),
-            ]
+        options = _task_interactive_action_options(task_context, fields={})
+        if options:
+            options.append(SelectionOption(value="back", label="返回列表", hint="回到待办列表"))
+            return options
         return [
             SelectionOption(value="back", label="返回列表", hint="当前节点没有可执行动作"),
             SelectionOption(value="exit", label="退出工作台", hint="结束当前待办工作台"),
@@ -697,10 +657,6 @@ def _build_task_detail_title(task_context: dict[str, Any]) -> str:
     return "\n".join(lines)
 
 
-def _build_task_action_title(task_context: dict[str, Any]) -> str:
-    return _build_task_detail_title(task_context) + "\n\n选择操作"
-
-
 def _task_initiator_label(initiator: dict[str, Any]) -> str:
     for key in ("display_name", "displayName", "name", "email", "uid"):
         value = initiator.get(key)
@@ -709,10 +665,35 @@ def _task_initiator_label(initiator: dict[str, Any]) -> str:
     return "-"
 
 
-def _task_has_interactive_actions(task_context: dict[str, Any]) -> bool:
+def _task_interactive_action_options(task_context: dict[str, Any], *, fields: dict[str, Any]) -> list[SelectionOption[str]]:
     data = task_context.get("data") if isinstance(task_context.get("data"), dict) else {}
     available_actions = [str(item).strip() for item in (data.get("available_actions") or []) if str(item).strip()]
-    return any(action != "save_only" for action in available_actions)
+    action_metadata = data.get("action_metadata") if isinstance(data.get("action_metadata"), dict) else {}
+    extras = data.get("extras") if isinstance(data.get("extras"), dict) else {}
+    feedback_required = {
+        str(item).strip()
+        for item in (action_metadata.get("feedback_required_for") or [])
+        if str(item).strip()
+    }
+    rollback_count = _count_candidate_items(extras.get("rollback_candidates"))
+    transfer_count = _count_candidate_items(extras.get("transfer_candidates"))
+
+    options: list[SelectionOption[str]] = []
+    for action in available_actions:
+        if action == "save_only" and not fields:
+            continue
+        label = TASK_ACTION_LABELS.get(action, action)
+        hint_parts = [action]
+        if action in feedback_required:
+            hint_parts.append("需要理由")
+        if action == "rollback":
+            hint_parts.append(f"可退回节点 {rollback_count}")
+        if action == "transfer":
+            hint_parts.append(f"可转交成员 {transfer_count}")
+        if action == "save_only":
+            hint_parts.append("仅保存字段，不推进流程")
+        options.append(SelectionOption(value=action, label=label, hint=" · ".join(hint_parts)))
+    return options
 
 
 def _full_display(value: Any) -> str:

package/src/qingflow_mcp/cli/context.py

@@ -8,6 +8,7 @@ from ..tools.ai_builder_tools import AiBuilderTools
 from ..tools.app_tools import AppTools
 from ..tools.auth_tools import AuthTools
 from ..tools.code_block_tools import CodeBlockTools
+from ..tools.export_tools import ExportTools
 from ..tools.feedback_tools import FeedbackTools
 from ..tools.file_tools import FileTools
 from ..tools.import_tools import ImportTools
@@ -29,6 +30,7 @@ class CliContext:
     record: RecordTools
     code_block: CodeBlockTools
     imports: ImportTools
+    exports: ExportTools
     task: TaskContextTools
     files: FileTools
     builder_feedback: FeedbackTools
@@ -52,6 +54,7 @@ def build_cli_context() -> CliContext:
         record=RecordTools(sessions, backend),
         code_block=CodeBlockTools(sessions, backend),
         imports=ImportTools(sessions, backend),
+        exports=ExportTools(sessions, backend),
         task=TaskContextTools(sessions, backend),
         files=FileTools(sessions, backend),
         builder_feedback=FeedbackTools(backend, mcp_side="App Builder MCP"),

package/src/qingflow_mcp/cli/formatters.py

@@ -412,6 +412,58 @@ def _format_import_status(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_export_common(result: dict[str, Any], *, title: str | None = None) -> str:
+    lines: list[str] = []
+    if title:
+        lines.append(title)
+    lines.extend(
+        [
+            f"Status: {result.get('status') or '-'}",
+            f"Export Handle: {result.get('export_handle') or '-'}",
+            f"App Key: {result.get('app_key') or '-'}",
+            f"View ID: {result.get('view_id') or '-'}",
+            f"Process Status: {result.get('process_status') or '-'}",
+            f"Rows: {result.get('num') if result.get('num') is not None else '-'}",
+        ]
+    )
+    file_names = result.get("file_names") if isinstance(result.get("file_names"), list) else []
+    file_urls = result.get("file_urls") if isinstance(result.get("file_urls"), list) else []
+    if file_names or file_urls:
+        lines.append("Remote Files:")
+        max_items = max(len(file_names), len(file_urls))
+        for index in range(max_items):
+            name = file_names[index] if index < len(file_names) else "-"
+            url = file_urls[index] if index < len(file_urls) else "-"
+            lines.append(f"- {name}: {url}")
+    downloaded_files = result.get("downloaded_files") if isinstance(result.get("downloaded_files"), list) else []
+    if downloaded_files:
+        lines.append("Downloaded Files:")
+        for item in downloaded_files:
+            if isinstance(item, dict):
+                lines.append(f"- {item.get('file_name') or '-'}: {item.get('path') or '-'}")
+            else:
+                lines.append(f"- {item}")
+    _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
+    return "\n".join(lines) + "\n"
+
+
+def _format_export_start(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Accepted")
+
+
+def _format_export_status(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Status")
+
+
+def _format_export_get(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Result")
+
+
+def _format_export_direct(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Direct")
+
+
 def _format_builder_summary(result: dict[str, Any]) -> str:
     lines = []
     if "status" in result:
@@ -626,5 +678,9 @@ _FORMATTERS = {
     "task_associated_report_detail_get": _format_task_associated_report_detail,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,
+    "export_start": _format_export_start,
+    "export_status": _format_export_status,
+    "export_get": _format_export_get,
+    "export_direct": _format_export_direct,
     "builder_summary": _format_builder_summary,
 }

package/src/qingflow_mcp/export_store.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from pathlib import Path
+
+from .import_store import _JsonEntryStore, _store_dir
+
+
+class ExportJobStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 24 * 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_EXPORT_JOB_HOME", "export-jobs"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )

package/src/qingflow_mcp/public_surface.py

@@ -91,6 +91,10 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "record_import_repair_local", ("record_import_repair_local",), ("import", "repair")),
     PublicToolSpec(USER_DOMAIN, "record_import_start", ("record_import_start",), ("import", "start")),
     PublicToolSpec(USER_DOMAIN, "record_import_status_get", ("record_import_status_get",), ("import", "status")),
+    PublicToolSpec(USER_DOMAIN, "record_export_start", ("record_export_start",), ("export", "start"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_status_get", ("record_export_status_get",), ("export", "status"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_get", ("record_export_get",), ("export", "get"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_direct", ("record_export_direct",), ("export", "direct"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_code_block_run", ("record_code_block_run",), ("record", "code-block-run"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "task_list", ("task_list",), ("task", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "task_get", ("task_get",), ("task", "get"), cli_show_effective_context=True),

package/src/qingflow_mcp/response_trim.py

@@ -674,6 +674,10 @@ def _trim_import_status_payload(payload: JSONObject) -> None:
         payload.pop(key, None)
 
 
+def _trim_export_payload(payload: JSONObject) -> None:
+    payload.pop("backend_export_id", None)
+
+
 def _summarize_import_issues(issues: list[Any]) -> dict[str, Any]:
     total = 0
     error_count = 0
@@ -756,6 +760,16 @@ _register_policy(
     ),
     _trim_import_schema,
 )
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "record_export_start",
+        "record_export_status_get",
+        "record_export_get",
+        "record_export_direct",
+    ),
+    _trim_export_payload,
+)
 _register_policy(
     (USER_DOMAIN,),
     (

package/src/qingflow_mcp/server.py

@@ -10,6 +10,7 @@ from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
 from .tools.code_block_tools import CodeBlockTools
 from .tools.feedback_tools import FeedbackTools
+from .tools.export_tools import ExportTools
 from .tools.file_tools import FileTools
 from .tools.import_tools import ImportTools
 from .tools.package_tools import PackageTools
@@ -50,6 +51,7 @@ All resource tools operate with the logged-in user's Qingflow permissions.
 If `app_key` is unknown, use `app_list` or `app_search` first.
 If the app is known but the data range is not, use `app_get` first and choose from `accessible_views`.
 If an accessible view has `analysis_supported=false`, do not use it for `record_list` or `record_analyze`. `boardView` and `ganttView` are special UI views, not list/analyze targets.
+`view_get(view_id=...)` also returns `export_capability`; it only means there is a supported export route, not that export permission has been verified.
 
 ## Schema-First Rule
 
@@ -147,6 +149,13 @@ Use `record_code_block_run` when the user wants to execute a form code-block fie
 - Do not modify user-uploaded files unless the user explicitly authorizes repair.
 - If repair is authorized, keep the original file and repair a copy, then run `record_import_verify` again before `record_import_start`.
 
+## Export Path
+
+`view_get -> record_export_start -> record_export_status_get -> record_export_get`
+
+- `record_export_direct` is the one-shot export path that starts the export, waits for completion, downloads locally, and still returns remote download links.
+- Export v1 supports record views only and follows the same public `view_id` semantics as `record_list` (`system:*` and `custom:*`).
+
 ## Task Workflow Path
 
 `task_list -> task_get -> task_action_execute`
@@ -190,6 +199,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     WorkspaceTools(sessions, backend).register(server)
     FileTools(sessions, backend).register(server)
     ImportTools(sessions, backend).register(server)
+    ExportTools(sessions, backend).register(server)
     CodeBlockTools(sessions, backend).register(server)
     TaskContextTools(sessions, backend).register(server)
     RoleTools(sessions, backend).register(server)

package/src/qingflow_mcp/server_app_user.py

@@ -13,6 +13,7 @@ from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
 from .tools.code_block_tools import CodeBlockTools
 from .tools.directory_tools import DirectoryTools
+from .tools.export_tools import ExportTools
 from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
 from .tools.import_tools import ImportTools
@@ -33,6 +34,7 @@ def build_user_server() -> FastMCP:
 If `app_key` is unknown, use `app_list` or `app_search` first.
 If the app is known but the data range is not, use `app_get` first and choose from `accessible_views`.
 If an accessible view has `analysis_supported=false`, do not use it for `record_list` or `record_analyze`. `boardView` and `ganttView` are special UI views, not list/analyze targets.
+`view_get(view_id=...)` also returns `export_capability`; it only means there is a supported export route, not that export permission has been verified.
 
 ## Shared Helper
 
@@ -142,6 +144,13 @@ Use `record_code_block_run` when the user wants to execute a form code-block fie
 - Do not modify user-uploaded files unless the user explicitly authorizes repair.
 - If repair is authorized, keep the original file and repair a copy, then run `record_import_verify` again before `record_import_start`.
 
+## Export Path
+
+`view_get -> record_export_start -> record_export_status_get -> record_export_get`
+
+- `record_export_direct` is the one-shot path that starts export, waits, downloads locally, and still returns remote download links.
+- Export v1 supports record views only and follows the same public `view_id` semantics as `record_list`.
+
 ## Task Workflow Path
 
 `task_list -> task_get -> task_action_execute`
@@ -188,6 +197,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     workspace = wrap_trimmed_methods(WorkspaceTools(sessions, backend), USER_SERVER_METHOD_MAP)
     file_tools = wrap_trimmed_methods(FileTools(sessions, backend), USER_SERVER_METHOD_MAP)
     imports = wrap_trimmed_methods(ImportTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    exports = wrap_trimmed_methods(ExportTools(sessions, backend), USER_SERVER_METHOD_MAP)
     resources = wrap_trimmed_methods(ResourceReadTools(sessions, backend), USER_SERVER_METHOD_MAP)
     feedback = FeedbackTools(backend, mcp_side="App User MCP")
     code_block_tools = wrap_trimmed_methods(CodeBlockTools(sessions, backend), USER_SERVER_METHOD_MAP)
@@ -218,6 +228,49 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     def auth_logout(profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict:
         return auth.auth_logout(profile=profile, forget_persisted=forget_persisted)
 
+    @server.tool()
+    def record_export_start(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        view_id: str = "system:all",
+    ) -> dict:
+        return exports.record_export_start(profile=profile, app_key=app_key, view_id=view_id)
+
+    @server.tool()
+    def record_export_status_get(
+        profile: str = DEFAULT_PROFILE,
+        export_handle: str = "",
+    ) -> dict:
+        return exports.record_export_status_get(profile=profile, export_handle=export_handle)
+
+    @server.tool()
+    def record_export_get(
+        profile: str = DEFAULT_PROFILE,
+        export_handle: str = "",
+        download_to_path: str | None = None,
+    ) -> dict:
+        return exports.record_export_get(
+            profile=profile,
+            export_handle=export_handle,
+            download_to_path=download_to_path,
+        )
+
+    @server.tool()
+    def record_export_direct(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        view_id: str = "system:all",
+        download_to_path: str | None = None,
+        wait_timeout_seconds: float | None = None,
+    ) -> dict:
+        return exports.record_export_direct(
+            profile=profile,
+            app_key=app_key,
+            view_id=view_id,
+            download_to_path=download_to_path,
+            wait_timeout_seconds=wait_timeout_seconds,
+        )
+
     @server.tool()
     def workspace_list(
         profile: str = DEFAULT_PROFILE,