@josephyan/qingflow-cli 0.2.0-beta.999 → 1.0.6

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

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import argparse
-import json
 
 from ..context import CliContext
-from ..terminal_ui import SelectionOption, select_option
+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:
@@ -23,7 +24,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
 
     select_parser = workspace_subparsers.add_parser("select", help="切换当前工作区")
     select_parser.add_argument("--ws-id", type=int, default=0, help="不传时在交互终端中选择工作区")
-    select_parser.set_defaults(handler=_handle_select, format_hint="workspace_get")
+    select_parser.set_defaults(handler=_handle_select, format_hint="workspace_select")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
@@ -44,40 +45,27 @@ 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:
-        selected_ws_id = _choose_workspace_interactively(args, context)
-        if selected_ws_id is None:
-            raise RuntimeError(
-                json.dumps(
-                    {
-                        "category": "config",
-                        "message": "workspace select requires --ws-id, or an interactive terminal to choose a workspace",
-                    },
-                    ensure_ascii=False,
-                )
+        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.",
             )
-        args.ws_id = selected_ws_id
+        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) -> int | None:
-    input_stream = getattr(args, "_stdin", None)
-    output_stream = getattr(args, "_stderr_stream", None)
-    if input_stream is None or output_stream is None:
-        return None
-    if not bool(getattr(input_stream, "isatty", lambda: False)()):
-        return None
-    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 []
-    if not items:
-        return None
+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"):
@@ -86,25 +74,36 @@ def _choose_workspace_interactively(args: argparse.Namespace, context: CliContex
         except Exception:
             session_profile = None
         current_ws_id = getattr(session_profile, "selected_ws_id", None) if session_profile is not None else None
-    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 select_option(
+    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="选择工作区",
-        options=options,
-        input_stream=input_stream,
-        output_stream=output_stream,
+        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

@@ -56,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

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import select
 import shutil
+import textwrap
 from dataclasses import dataclass
 from typing import Generic, Sequence, TextIO, TypeVar
 
@@ -15,6 +16,11 @@ except ImportError:  # pragma: no cover - non-POSIX fallback
 
 
 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)
@@ -131,11 +137,13 @@ def _render_options(
     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 = [
-        title,
-        "↑/↓ 或 j/k 选择，Enter 确认，q / Esc 取消",
-        "",
-    ]
+    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 ""
@@ -144,7 +152,7 @@ def _render_options(
         lines.append("")
         lines.append(f"{selected_index + 1}/{total}")
     output_stream.write("\x1b[2J\x1b[H")
-    output_stream.write("\n".join(lines))
+    output_stream.write(RAW_TTY_NEWLINE.join(lines))
     output_stream.flush()
 
 
@@ -156,17 +164,55 @@ def _truncate_line(text: str, *, width: int) -> str:
     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:
-    first = input_stream.read(1)
+    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]
-    fd = input_stream.fileno()
-    while select.select([fd], [], [], 0.02)[0]:
+    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),
+        )

package/src/qingflow_mcp/public_surface.py

@@ -82,6 +82,7 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "record_department_candidates", ("record_department_candidates",), cli_public=False),
     PublicToolSpec(USER_DOMAIN, "record_analyze", ("record_analyze",), ("record", "analyze")),
     PublicToolSpec(USER_DOMAIN, "record_list", ("record_list",), ("record", "list"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_access", ("record_access",), ("record", "access"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_get", ("record_get_public",), ("record", "get"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_insert", ("record_insert_public",), ("record", "insert"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "record_update", ("record_update_public",), ("record", "update"), cli_show_effective_context=True, cli_context_write=True),
@@ -91,6 +92,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),
@@ -130,6 +135,7 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "role_create", ("role_create",), ("builder", "role", "create"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_release_edit_lock_if_mine", ("app_release_edit_lock_if_mine",), ("builder", "app", "release-edit-lock-if-mine"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_resolve", ("app_resolve",), ("builder", "app", "resolve"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "button_style_catalog_get", ("button_style_catalog_get",), ("builder", "button", "catalog"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_list", ("app_custom_button_list",), ("builder", "button", "list"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_get", ("app_custom_button_get",), ("builder", "button", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_create", ("app_custom_button_create",), ("builder", "button", "create"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),