@josephyan/qingflow-cli 0.2.0-beta.998 → 1.0.5

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

@@ -3,6 +3,9 @@ from __future__ import annotations
 import argparse
 
 from ..context import CliContext
+from ..interaction import cancelled_result, resolve_interactive_selection
+from ..terminal_ui import SelectionOption
+from .common import raise_config_error
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -20,8 +23,8 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     get_parser.set_defaults(handler=_handle_get, format_hint="workspace_get")
 
     select_parser = workspace_subparsers.add_parser("select", help="切换当前工作区")
-    select_parser.add_argument("--ws-id", type=int, required=True)
-    select_parser.set_defaults(handler=_handle_select, format_hint="workspace_get")
+    select_parser.add_argument("--ws-id", type=int, default=0, help="不传时在交互终端中选择工作区")
+    select_parser.set_defaults(handler=_handle_select, format_hint="workspace_select")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
@@ -41,7 +44,66 @@ def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
 
 
 def _handle_select(args: argparse.Namespace, context: CliContext) -> dict:
+    if int(args.ws_id or 0) <= 0:
+        selection = _choose_workspace_interactively(args, context)
+        if selection.status == "unavailable":
+            raise_config_error(
+                "workspace select requires --ws-id, or an interactive terminal to choose a workspace",
+                fix_hint="Retry in an interactive terminal, or pass `--ws-id WS_ID` explicitly.",
+            )
+        if selection.status == "empty":
+            raise_config_error(
+                selection.message or "workspace select could not open a selector because no workspaces are available.",
+                fix_hint="Run `workspace list` to confirm visible workspaces, or retry with `--ws-id WS_ID`.",
+            )
+        if selection.status == "cancelled":
+            return cancelled_result(selection.message or "已取消")
+        args.ws_id = int(selection.value or 0)
     return context.workspace.workspace_select(
         profile=args.profile,
         ws_id=int(args.ws_id),
     )
+
+
+def _choose_workspace_interactively(args: argparse.Namespace, context: CliContext):
+    current_ws_id = None
+    sessions = getattr(context, "sessions", None)
+    if sessions is not None and hasattr(sessions, "get_profile"):
+        try:
+            session_profile = sessions.get_profile(args.profile)
+        except Exception:
+            session_profile = None
+        current_ws_id = getattr(session_profile, "selected_ws_id", None) if session_profile is not None else None
+    def load_options() -> list[SelectionOption[int]]:
+        page = context.workspace.workspace_list(
+            profile=args.profile,
+            page_num=1,
+            page_size=100,
+            include_external=False,
+        ).get("page")
+        items = page.get("list") if isinstance(page, dict) and isinstance(page.get("list"), list) else []
+        options: list[SelectionOption[int]] = []
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            ws_id = int(item.get("wsId") or 0)
+            if ws_id <= 0:
+                continue
+            workspace_name = str(item.get("workspaceName") or item.get("wsName") or f"Workspace {ws_id}")
+            remark = str(item.get("remark") or "").strip()
+            label = workspace_name
+            if remark:
+                label = f"{workspace_name} - {remark}"
+            hint = f"ws_id={ws_id}"
+            if current_ws_id == ws_id:
+                hint += " · 当前"
+            options.append(SelectionOption(value=ws_id, label=label, hint=hint))
+        return options
+
+    return resolve_interactive_selection(
+        args,
+        title="选择工作区",
+        unavailable_message="workspace select requires --ws-id, or an interactive terminal to choose a workspace",
+        empty_message="workspace select could not open a selector because no visible workspaces were returned.",
+        load_options=load_options,
+    )

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

@@ -1,17 +1,26 @@
 from __future__ import annotations
 
 import json
+import textwrap
 from typing import Any, TextIO
 
 
 def emit_text_result(result: dict[str, Any], *, hint: str, stream: TextIO) -> None:
-    formatter = _FORMATTERS.get(hint, _format_generic)
-    text = formatter(result)
+    text = _format_cancelled_result(result)
+    if text is None:
+        formatter = _FORMATTERS.get(hint, _format_generic)
+        text = formatter(result)
     stream.write(text)
     if not text.endswith("\n"):
         stream.write("\n")
 
 
+def _format_cancelled_result(result: dict[str, Any]) -> str | None:
+    if str(result.get("status") or "").lower() != "cancelled":
+        return None
+    return str(result.get("message") or "已取消") + "\n"
+
+
 def _format_generic(result: dict[str, Any]) -> str:
     lines: list[str] = []
     title = _first_present(result, "status", "message")
@@ -106,6 +115,21 @@ def _format_workspace_get(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_workspace_select(result: dict[str, Any]) -> str:
+    status = str(result.get("status") or "").lower()
+    if status == "cancelled":
+        return str(result.get("message") or "已取消") + "\n"
+
+    workspace = result.get("workspace") if isinstance(result.get("workspace"), dict) else {}
+    workspace_name = workspace.get("workspaceName") or workspace.get("wsName") or result.get("selected", {}).get("workspace_name") if isinstance(result.get("selected"), dict) else None
+    lines = [
+        f"已切换到: {workspace_name or '-'} ({workspace.get('wsId') or result.get('ws_id') or '-'})",
+        f"QF Version: {result.get('qf_version') or workspace.get('systemVersion') or '-'}",
+    ]
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
+
+
 def _format_app_items(result: dict[str, Any]) -> str:
     items = result.get("items")
     if not isinstance(items, list):
@@ -214,15 +238,22 @@ def _format_task_get(result: dict[str, Any]) -> str:
             f"App: {task.get('app_name') or '-'}",
             f"Initiator: {initiator_label}",
             f"Apply Status: {record_summary.get('apply_status')}",
+            f"Apply Number: {record_summary.get('custom_apply_num') or record_summary.get('apply_num') or '-'}",
+            f"Apply Time: {record_summary.get('apply_time') or '-'}",
             f"Available Actions: {', '.join(str(item) for item in available_actions) or '-'}",
             f"Editable Fields: {len(editable_fields)}",
         ]
     )
+    all_fields = record_summary.get("all_fields") if isinstance(record_summary.get("all_fields"), dict) else {}
     core_fields = record_summary.get("core_fields") if isinstance(record_summary.get("core_fields"), dict) else {}
-    if core_fields:
+    if all_fields:
+        lines.append("Fields:")
+        for key, value in all_fields.items():
+            lines.extend(_format_field_line(key, value))
+    elif core_fields:
         lines.append("Core Fields:")
         for key, value in list(core_fields.items())[:12]:
-            lines.append(f"- {key}: {value}")
+            lines.extend(_format_field_line(key, value))
     if editable_fields:
         lines.append("Editable Fields:")
         for item in editable_fields[:10]:
@@ -273,6 +304,30 @@ def _format_task_action(result: dict[str, Any]) -> str:
     return _task_action_success_label(action) + "\n"
 
 
+def _format_task_workbench(result: dict[str, Any]) -> str:
+    message = str(result.get("message") or "").strip()
+    if message:
+        return message + "\n"
+    return ""
+
+
+def _format_field_line(key: Any, value: Any) -> list[str]:
+    if isinstance(value, list):
+        text = " / ".join(str(item) for item in value if item not in (None, ""))
+    else:
+        text = str(value if value not in (None, "") else "-")
+    wrapped = textwrap.wrap(
+        text,
+        width=120,
+        initial_indent=f"- {key}: ",
+        subsequent_indent="  ",
+        replace_whitespace=False,
+        drop_whitespace=False,
+        break_long_words=True,
+    )
+    return wrapped or [f"- {key}: -"]
+
+
 def _format_task_associated_report_detail(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     selection = data.get("selection") if isinstance(data.get("selection"), dict) else {}
@@ -352,11 +407,85 @@ 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"
+
+
+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 '-'}",
+        ]
+    )
+    row_scope = result.get("row_scope")
+    if row_scope not in (None, ""):
+        lines.append(f"Row Scope: {row_scope}")
+    selected_record_count = result.get("selected_record_count")
+    if selected_record_count not in (None, ""):
+        lines.append(f"Selected Rows: {selected_record_count}")
+    field_scope = result.get("field_scope")
+    if field_scope not in (None, ""):
+        lines.append(f"Field Scope: {field_scope}")
+    selected_field_count = result.get("selected_field_count")
+    if selected_field_count not in (None, ""):
+        lines.append(f"Selected Fields: {selected_field_count}")
+    include_workflow_log = result.get("include_workflow_log")
+    if include_workflow_log not in (None, ""):
+        lines.append(f"Include Workflow Log: {include_workflow_log}")
+    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:
@@ -559,15 +688,21 @@ _FORMATTERS = {
     "auth_whoami": _format_whoami,
     "workspace_list": _format_workspace_list,
     "workspace_get": _format_workspace_get,
+    "workspace_select": _format_workspace_select,
     "app_list": _format_app_items,
     "app_search": _format_app_items,
     "app_get": _format_app_get,
     "record_list": _format_record_list,
     "task_list": _format_task_list,
+    "task_workbench": _format_task_workbench,
     "task_get": _format_task_get,
     "task_action_execute": _format_task_action,
     "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/cli/interaction.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Generic, TypeVar
+
+from .terminal_ui import SelectionOption, select_option
+
+
+T = TypeVar("T")
+
+
+@dataclass(slots=True)
+class InteractiveSelectionResult(Generic[T]):
+    status: str
+    value: T | None = None
+    message: str | None = None
+
+
+def cancelled_result(message: str = "已取消") -> dict[str, str]:
+    return {"status": "cancelled", "message": message}
+
+
+def resolve_interactive_selection(
+    args: object,
+    *,
+    title: str,
+    unavailable_message: str,
+    empty_message: str,
+    load_options: Callable[[], list[SelectionOption[T]]],
+) -> InteractiveSelectionResult[T]:
+    input_stream = getattr(args, "_stdin", None)
+    output_stream = getattr(args, "_stderr_stream", None)
+    if input_stream is None or output_stream is None:
+        return InteractiveSelectionResult(status="unavailable", message=unavailable_message)
+    if not bool(getattr(input_stream, "isatty", lambda: False)()):
+        return InteractiveSelectionResult(status="unavailable", message=unavailable_message)
+
+    options = list(load_options())
+    if not options:
+        return InteractiveSelectionResult(status="empty", message=empty_message)
+
+    value = select_option(
+        title=title,
+        options=options,
+        input_stream=input_stream,
+        output_stream=output_stream,
+    )
+    if value is None:
+        return InteractiveSelectionResult(status="cancelled", message="已取消")
+    return InteractiveSelectionResult(status="selected", value=value)
+
+
+def resolve_interactive_text_input(
+    args: object,
+    *,
+    prompt: str,
+    unavailable_message: str,
+) -> InteractiveSelectionResult[str]:
+    input_stream = getattr(args, "_stdin", None)
+    output_stream = getattr(args, "_stderr_stream", None)
+    if input_stream is None or output_stream is None:
+        return InteractiveSelectionResult(status="unavailable", message=unavailable_message)
+    if not bool(getattr(input_stream, "isatty", lambda: False)()):
+        return InteractiveSelectionResult(status="unavailable", message=unavailable_message)
+
+    output_stream.write(prompt)
+    output_stream.flush()
+    line = input_stream.readline()
+    text = str(line or "").strip()
+    if not text:
+        return InteractiveSelectionResult(status="cancelled", message="已取消")
+    return InteractiveSelectionResult(status="selected", value=text)

package/src/qingflow_mcp/cli/main.py

@@ -44,6 +44,9 @@ def run(
         args = parser.parse_args(normalized_argv)
     except SystemExit as exc:
         return int(exc.code or 0)
+    setattr(args, "_stdin", sys.stdin)
+    setattr(args, "_stdout_stream", out)
+    setattr(args, "_stderr_stream", err)
     handler = getattr(args, "handler", None)
     if handler is None:
         parser.print_help(out)
@@ -53,6 +56,8 @@ def run(
         if not bool(args.json):
             _emit_cli_effective_context_notice(args, context, stream=err)
         result = handler(args, context)
+    except SystemExit as exc:
+        return int(exc.code or 0)
     except RuntimeError as exc:
         payload = trim_error_response(_parse_error_payload(exc))
         return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)

package/src/qingflow_mcp/cli/terminal_ui.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import os
+import select
+import shutil
+import textwrap
+from dataclasses import dataclass
+from typing import Generic, Sequence, TextIO, TypeVar
+
+try:
+    import termios
+    import tty
+except ImportError:  # pragma: no cover - non-POSIX fallback
+    termios = None
+    tty = None
+
+
+T = TypeVar("T")
+RAW_TTY_NEWLINE = "\r\n"
+# Give terminal escape sequences a slightly roomier window so arrow keys
+# still parse correctly when an outer Node/npm launcher adds a bit of PTY lag.
+ESCAPE_SEQUENCE_TIMEOUT_SECONDS = 0.2
+ESCAPE_SEQUENCE_FOLLOWUP_TIMEOUT_SECONDS = 0.02
+
+
+@dataclass(slots=True)
+class SelectionOption(Generic[T]):
+    value: T
+    label: str
+    hint: str | None = None
+
+
+def select_option(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+    page_size: int = 8,
+) -> T | None:
+    if not options:
+        return None
+    if len(options) == 1:
+        return options[0].value
+    if not _supports_raw_selection(input_stream=input_stream, output_stream=output_stream):
+        return _select_option_via_prompt(title=title, options=options, input_stream=input_stream, output_stream=output_stream)
+    return _select_option_via_raw_terminal(
+        title=title,
+        options=options,
+        input_stream=input_stream,
+        output_stream=output_stream,
+        page_size=max(3, page_size),
+    )
+
+
+def _supports_raw_selection(*, input_stream: TextIO, output_stream: TextIO) -> bool:
+    if termios is None or tty is None:
+        return False
+    if not bool(getattr(input_stream, "isatty", lambda: False)()) or not bool(getattr(output_stream, "isatty", lambda: False)()):
+        return False
+    return hasattr(input_stream, "fileno")
+
+
+def _select_option_via_prompt(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+) -> T | None:
+    output_stream.write(title + "\n")
+    for index, option in enumerate(options, start=1):
+        suffix = f" ({option.hint})" if option.hint else ""
+        output_stream.write(f"{index}. {option.label}{suffix}\n")
+    output_stream.write("请输入编号并回车，留空取消: ")
+    output_stream.flush()
+    line = input_stream.readline()
+    selected = str(line or "").strip()
+    if not selected:
+        return None
+    if not selected.isdigit():
+        return None
+    index = int(selected) - 1
+    if index < 0 or index >= len(options):
+        return None
+    return options[index].value
+
+
+def _select_option_via_raw_terminal(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+    page_size: int,
+) -> T | None:
+    fd = input_stream.fileno()
+    original_mode = termios.tcgetattr(fd)
+    selected_index = 0
+    output_stream.write("\x1b[?1049h\x1b[?25l")
+    output_stream.flush()
+    try:
+        tty.setraw(fd)
+        while True:
+            _render_options(
+                title=title,
+                options=options,
+                selected_index=selected_index,
+                output_stream=output_stream,
+                page_size=page_size,
+            )
+            key = _read_key(input_stream)
+            if key in ("\r", "\n"):
+                return options[selected_index].value
+            if key in ("\x03", "\x1b", "q", "Q"):
+                return None
+            if key in ("\x1b[A", "k", "K"):
+                selected_index = (selected_index - 1) % len(options)
+                continue
+            if key in ("\x1b[B", "j", "J"):
+                selected_index = (selected_index + 1) % len(options)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, original_mode)
+        output_stream.write("\x1b[?25h\x1b[?1049l")
+        output_stream.flush()
+
+
+def _render_options(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[object]],
+    selected_index: int,
+    output_stream: TextIO,
+    page_size: int,
+) -> None:
+    terminal_width = shutil.get_terminal_size((100, 20)).columns
+    total = len(options)
+    page_start = max(0, min(selected_index - page_size // 2, max(total - page_size, 0)))
+    visible = options[page_start: page_start + page_size]
+    lines = _render_multiline_text(title, width=terminal_width)
+    lines.extend(
+        [
+            "↑/↓ 或 j/k 选择，Enter 确认，q / Esc 取消",
+            "",
+        ]
+    )
+    for offset, option in enumerate(visible, start=page_start):
+        marker = ">" if offset == selected_index else " "
+        suffix = f"  [{option.hint}]" if option.hint else ""
+        lines.append(_truncate_line(f"{marker} {option.label}{suffix}", width=terminal_width))
+    if total > page_size:
+        lines.append("")
+        lines.append(f"{selected_index + 1}/{total}")
+    output_stream.write("\x1b[2J\x1b[H")
+    output_stream.write(RAW_TTY_NEWLINE.join(lines))
+    output_stream.flush()
+
+
+def _truncate_line(text: str, *, width: int) -> str:
+    if width <= 0 or len(text) <= width:
+        return text
+    if width <= 1:
+        return text[:width]
+    return text[: width - 1] + "…"
+
+
+def _render_multiline_text(text: str, *, width: int) -> list[str]:
+    parts = text.splitlines() or [text]
+    rendered: list[str] = []
+    wrap_width = max(1, width)
+    for part in parts:
+        if not part:
+            rendered.append("")
+            continue
+        initial_indent = ""
+        subsequent_indent = ""
+        stripped = part.lstrip()
+        if stripped.startswith("- "):
+            leading_spaces = len(part) - len(stripped)
+            initial_indent = part[:leading_spaces] + "- "
+            subsequent_indent = part[:leading_spaces] + "  "
+            content = stripped[2:]
+        else:
+            content = part
+        wrapped = textwrap.wrap(
+            content,
+            width=wrap_width,
+            initial_indent=initial_indent,
+            subsequent_indent=subsequent_indent,
+            replace_whitespace=False,
+            drop_whitespace=False,
+            break_long_words=True,
+        )
+        rendered.extend(wrapped or [""])
+    return rendered
+
+
+def _read_key(input_stream: TextIO) -> str:
+    fd = input_stream.fileno()
+    first_bytes = os.read(fd, 1)
+    if not first_bytes:
+        return ""
+    first = first_bytes.decode("utf-8", errors="ignore")
+    if first != "\x1b":
+        return first
+    chunks = [first]
+    if not select.select([fd], [], [], ESCAPE_SEQUENCE_TIMEOUT_SECONDS)[0]:
+        return first
+    while True:
+        chunk = os.read(fd, 1).decode("utf-8", errors="ignore")
+        if not chunk:
+            break
+        chunks.append(chunk)
+        if len(chunks) >= 3:
+            break
+        if not select.select([fd], [], [], ESCAPE_SEQUENCE_FOLLOWUP_TIMEOUT_SECONDS)[0]:
+            break
+    return "".join(chunks)

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/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),
+        )