@josephyan/qingflow-cli 0.2.0-beta.57 → 0.2.0-beta.59

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

@@ -1,222 +1,184 @@
 from __future__ import annotations
 
 import argparse
-from typing import Any
 
-from ...errors import QingflowApiError
 from ..context import CliContext
-from .common import add_file_arg, add_stdin_json_flag, load_object_input
+from .common import load_list_arg, load_object_arg, require_list_arg
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("build", help="稳定搭建能力")
-    build_subparsers = parser.add_subparsers(dest="build_command", required=True)
+    parser = subparsers.add_parser("builder", help="稳定 builder 命令")
+    builder_subparsers = parser.add_subparsers(dest="builder_command", required=True)
 
-    package = build_subparsers.add_parser("package", help="应用包")
-    package_subparsers = package.add_subparsers(dest="build_package_command", required=True)
+    package = builder_subparsers.add_parser("package", help="应用包")
+    package_subparsers = package.add_subparsers(dest="builder_package_command", required=True)
     package_resolve = package_subparsers.add_parser("resolve", help="解析应用包")
-    package_resolve.add_argument("--name", required=True)
-    package_resolve.set_defaults(handler=_handle_package_resolve, format_hint="builder_result")
+    package_resolve.add_argument("--package-name", required=True)
+    package_resolve.set_defaults(handler=_handle_package_resolve, format_hint="builder_summary")
+
+    app = builder_subparsers.add_parser("app", help="应用")
+    app_subparsers = app.add_subparsers(dest="builder_app_command", required=True)
 
-    app = build_subparsers.add_parser("app", help="应用")
-    app_subparsers = app.add_subparsers(dest="build_app_command", required=True)
     app_resolve = app_subparsers.add_parser("resolve", help="解析应用")
     app_resolve.add_argument("--app-key", default="")
-    app_resolve.add_argument("--name", default="")
+    app_resolve.add_argument("--app-name", default="")
     app_resolve.add_argument("--package-tag-id", type=int)
-    app_resolve.set_defaults(handler=_handle_app_resolve, format_hint="builder_result")
-
-    app_show = app_subparsers.add_parser("show", help="读取应用摘要")
-    app_show.add_argument("--app", required=True)
-    app_show.set_defaults(handler=_handle_app_show, format_hint="builder_result")
-
-    fields = build_subparsers.add_parser("fields", help="字段")
-    fields_subparsers = fields.add_subparsers(dest="build_fields_command", required=True)
-    fields_show = fields_subparsers.add_parser("show", help="读取字段摘要")
-    fields_show.add_argument("--app", required=True)
-    fields_show.set_defaults(handler=_handle_fields_show, format_hint="builder_result")
-    fields_apply = fields_subparsers.add_parser("apply", help="执行字段变更")
-    fields_apply.add_argument("--app", default="")
-    fields_apply.add_argument("--package-tag-id", type=int)
-    fields_apply.add_argument("--name", dest="app_name", default="")
-    fields_apply.add_argument("--title", dest="app_title", default="")
-    fields_apply.add_argument("--create-if-missing", action="store_true")
-    fields_apply.add_argument("--publish", action=argparse.BooleanOptionalAction, default=True)
-    add_file_arg(fields_apply, required=False, help_text="读取字段变更 JSON，支持 add_fields/update_fields/remove_fields")
-    add_stdin_json_flag(fields_apply)
-    fields_apply.set_defaults(handler=_handle_fields_apply, format_hint="builder_result")
-
-    layout = build_subparsers.add_parser("layout", help="布局")
-    layout_subparsers = layout.add_subparsers(dest="build_layout_command", required=True)
-    layout_show = layout_subparsers.add_parser("show", help="读取布局摘要")
-    layout_show.add_argument("--app", required=True)
-    layout_show.set_defaults(handler=_handle_layout_show, format_hint="builder_result")
-
-    views = build_subparsers.add_parser("views", help="视图")
-    views_subparsers = views.add_subparsers(dest="build_views_command", required=True)
-    views_show = views_subparsers.add_parser("show", help="读取视图摘要")
-    views_show.add_argument("--app", required=True)
-    views_show.set_defaults(handler=_handle_views_show, format_hint="builder_result")
-
-    flow = build_subparsers.add_parser("flow", help="流程")
-    flow_subparsers = flow.add_subparsers(dest="build_flow_command", required=True)
-    flow_show = flow_subparsers.add_parser("show", help="读取流程摘要")
-    flow_show.add_argument("--app", required=True)
-    flow_show.set_defaults(handler=_handle_flow_show, format_hint="builder_result")
-
-    charts = build_subparsers.add_parser("charts", help="报表")
-    charts_subparsers = charts.add_subparsers(dest="build_charts_command", required=True)
-    charts_show = charts_subparsers.add_parser("show", help="读取报表摘要")
-    charts_show.add_argument("--app", required=True)
-    charts_show.set_defaults(handler=_handle_charts_show, format_hint="builder_result")
-    charts_apply = charts_subparsers.add_parser("apply", help="执行报表变更")
-    charts_apply.add_argument("--app", required=True)
-    add_file_arg(charts_apply, required=False, help_text="读取报表变更 JSON，支持 upsert_charts/remove_chart_ids/reorder_chart_ids")
-    add_stdin_json_flag(charts_apply)
-    charts_apply.set_defaults(handler=_handle_charts_apply, format_hint="builder_result")
-
-    portal = build_subparsers.add_parser("portal", help="门户")
-    portal_subparsers = portal.add_subparsers(dest="build_portal_command", required=True)
-    portal_show = portal_subparsers.add_parser("show", help="读取门户摘要")
-    portal_show.add_argument("--dash", required=True)
-    portal_show.add_argument("--draft", action=argparse.BooleanOptionalAction, default=True)
-    portal_show.set_defaults(handler=_handle_portal_show, format_hint="builder_result")
-    portal_apply = portal_subparsers.add_parser("apply", help="执行门户变更")
-    portal_apply.add_argument("--dash", default="")
-    portal_apply.add_argument("--name", dest="dash_name", default="")
+    app_resolve.set_defaults(handler=_handle_app_resolve, format_hint="builder_summary")
+
+    for name, help_text, handler in [
+        ("read-summary", "读取应用摘要", _handle_app_read_summary),
+        ("read-fields", "读取字段摘要", _handle_app_read_fields),
+        ("read-layout", "读取布局摘要", _handle_app_read_layout),
+        ("read-views", "读取视图摘要", _handle_app_read_views),
+        ("read-flow", "读取流程摘要", _handle_app_read_flow),
+        ("read-charts", "读取报表摘要", _handle_app_read_charts),
+    ]:
+        sub = app_subparsers.add_parser(name, help=help_text)
+        sub.add_argument("--app-key", required=True)
+        sub.set_defaults(handler=handler, format_hint="builder_summary")
+
+    portal = builder_subparsers.add_parser("portal", help="门户")
+    portal_subparsers = portal.add_subparsers(dest="builder_portal_command", required=True)
+    portal_read = portal_subparsers.add_parser("read-summary", help="读取门户摘要")
+    portal_read.add_argument("--dash-key", required=True)
+    portal_read.add_argument("--being-draft", action=argparse.BooleanOptionalAction, default=True)
+    portal_read.set_defaults(handler=_handle_portal_read_summary, format_hint="builder_summary")
+
+    portal_apply = portal_subparsers.add_parser("apply", help="更新门户")
+    portal_apply.add_argument("--dash-key", default="")
+    portal_apply.add_argument("--dash-name", default="")
     portal_apply.add_argument("--package-tag-id", type=int)
     portal_apply.add_argument("--publish", action=argparse.BooleanOptionalAction, default=True)
-    add_file_arg(portal_apply, required=True, help_text="读取门户变更 JSON，至少包含 sections")
-    add_stdin_json_flag(portal_apply)
-    portal_apply.set_defaults(handler=_handle_portal_apply, format_hint="builder_result")
-
-    publish = build_subparsers.add_parser("publish", help="发布校验")
-    publish_subparsers = publish.add_subparsers(dest="build_publish_command", required=True)
-    publish_verify = publish_subparsers.add_parser("verify", help="校验应用发布")
-    publish_verify.add_argument("--app", required=True)
-    publish_verify.add_argument("--expected-package-tag-id", type=int)
-    publish_verify.set_defaults(handler=_handle_publish_verify, format_hint="builder_result")
+    portal_apply.add_argument("--sections-file", required=True)
+    portal_apply.add_argument("--auth-file")
+    portal_apply.add_argument("--icon")
+    portal_apply.add_argument("--color")
+    portal_apply.add_argument("--hide-copyright", action=argparse.BooleanOptionalAction, default=None)
+    portal_apply.add_argument("--dash-global-config-file")
+    portal_apply.add_argument("--config-file")
+    portal_apply.set_defaults(handler=_handle_portal_apply, format_hint="builder_summary")
+
+    schema_apply = builder_subparsers.add_parser("schema", help="字段搭建")
+    schema_apply_subparsers = schema_apply.add_subparsers(dest="builder_schema_command", required=True)
+    schema_apply_apply = schema_apply_subparsers.add_parser("apply", help="执行字段变更")
+    schema_apply_apply.add_argument("--app-key", default="")
+    schema_apply_apply.add_argument("--package-tag-id", type=int)
+    schema_apply_apply.add_argument("--app-name", default="")
+    schema_apply_apply.add_argument("--app-title", default="")
+    schema_apply_apply.add_argument("--create-if-missing", action="store_true")
+    schema_apply_apply.add_argument("--publish", action=argparse.BooleanOptionalAction, default=True)
+    schema_apply_apply.add_argument("--add-fields-file")
+    schema_apply_apply.add_argument("--update-fields-file")
+    schema_apply_apply.add_argument("--remove-fields-file")
+    schema_apply_apply.set_defaults(handler=_handle_schema_apply, format_hint="builder_summary")
+
+    charts_apply = builder_subparsers.add_parser("charts", help="报表")
+    charts_apply_subparsers = charts_apply.add_subparsers(dest="builder_charts_command", required=True)
+    charts_apply_apply = charts_apply_subparsers.add_parser("apply", help="执行报表变更")
+    charts_apply_apply.add_argument("--app-key", required=True)
+    charts_apply_apply.add_argument("--upsert-file")
+    charts_apply_apply.add_argument("--remove-chart-ids-file")
+    charts_apply_apply.add_argument("--reorder-chart-ids-file")
+    charts_apply_apply.set_defaults(handler=_handle_charts_apply, format_hint="builder_summary")
+
+    publish_verify = builder_subparsers.add_parser("publish", help="发布校验")
+    publish_verify_subparsers = publish_verify.add_subparsers(dest="builder_publish_command", required=True)
+    publish_verify_verify = publish_verify_subparsers.add_parser("verify", help="校验应用发布")
+    publish_verify_verify.add_argument("--app-key", required=True)
+    publish_verify_verify.add_argument("--expected-package-tag-id", type=int)
+    publish_verify_verify.set_defaults(handler=_handle_publish_verify, format_hint="builder_summary")
 
 
 def _handle_package_resolve(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.package_resolve(profile=args.profile, package_name=args.name)
+    return context.builder.package_resolve(profile=args.profile, package_name=args.package_name)
 
 
 def _handle_app_resolve(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.app_resolve(
+    return context.builder.app_resolve(
         profile=args.profile,
         app_key=args.app_key,
-        app_name=args.name,
+        app_name=args.app_name,
         package_tag_id=args.package_tag_id,
     )
 
 
-def _handle_app_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.app_show(profile=args.profile, app_key=args.app)
+def _handle_app_read_summary(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_read_summary(profile=args.profile, app_key=args.app_key)
 
 
-def _handle_fields_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.fields_show(profile=args.profile, app_key=args.app)
+def _handle_app_read_fields(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_read_fields(profile=args.profile, app_key=args.app_key)
 
 
-def _handle_fields_apply(args: argparse.Namespace, context: CliContext) -> dict:
-    payload = load_object_input(args, required=False)
-    return context.build.fields_apply(
-        profile=args.profile,
-        app_key=args.app,
-        package_tag_id=args.package_tag_id,
-        app_name=args.app_name,
-        app_title=args.app_title,
-        create_if_missing=bool(args.create_if_missing),
-        publish=bool(args.publish),
-        add_fields=[_normalize_field_spec(item) for item in _coerce_list(payload.get("add_fields"))],
-        update_fields=_coerce_list(payload.get("update_fields")),
-        remove_fields=[_normalize_field_selector(item) for item in _coerce_list(payload.get("remove_fields"))],
-    )
+def _handle_app_read_layout(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_read_layout_summary(profile=args.profile, app_key=args.app_key)
 
 
-def _handle_layout_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.layout_show(profile=args.profile, app_key=args.app)
+def _handle_app_read_views(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_read_views_summary(profile=args.profile, app_key=args.app_key)
 
 
-def _handle_views_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.views_show(profile=args.profile, app_key=args.app)
+def _handle_app_read_flow(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_read_flow_summary(profile=args.profile, app_key=args.app_key)
 
 
-def _handle_flow_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.flow_show(profile=args.profile, app_key=args.app)
+def _handle_app_read_charts(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_read_charts_summary(profile=args.profile, app_key=args.app_key)
 
 
-def _handle_charts_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.charts_show(profile=args.profile, app_key=args.app)
+def _handle_portal_read_summary(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.portal_read_summary(
+        profile=args.profile,
+        dash_key=args.dash_key,
+        being_draft=bool(args.being_draft),
+    )
 
 
-def _handle_charts_apply(args: argparse.Namespace, context: CliContext) -> dict:
-    payload = load_object_input(args, required=False)
-    return context.build.charts_apply(
+def _handle_schema_apply(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_schema_apply(
         profile=args.profile,
-        app_key=args.app,
-        upsert_charts=_coerce_list(payload.get("upsert_charts")),
-        remove_chart_ids=_coerce_list(payload.get("remove_chart_ids")),
-        reorder_chart_ids=_coerce_list(payload.get("reorder_chart_ids")),
+        app_key=args.app_key,
+        package_tag_id=args.package_tag_id,
+        app_name=args.app_name,
+        app_title=args.app_title,
+        create_if_missing=bool(args.create_if_missing),
+        publish=bool(args.publish),
+        add_fields=load_list_arg(args.add_fields_file, option_name="--add-fields-file"),
+        update_fields=load_list_arg(args.update_fields_file, option_name="--update-fields-file"),
+        remove_fields=load_list_arg(args.remove_fields_file, option_name="--remove-fields-file"),
     )
 
 
-def _handle_portal_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.portal_show(profile=args.profile, dash_key=args.dash, being_draft=bool(args.draft))
+def _handle_charts_apply(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_charts_apply(
+        profile=args.profile,
+        app_key=args.app_key,
+        upsert_charts=load_list_arg(args.upsert_file, option_name="--upsert-file"),
+        remove_chart_ids=load_list_arg(args.remove_chart_ids_file, option_name="--remove-chart-ids-file"),
+        reorder_chart_ids=load_list_arg(args.reorder_chart_ids_file, option_name="--reorder-chart-ids-file"),
+    )
 
 
 def _handle_portal_apply(args: argparse.Namespace, context: CliContext) -> dict:
-    payload = load_object_input(args, required=True)
-    sections = payload.get("sections")
-    if not isinstance(sections, list) or not sections:
-        raise QingflowApiError.config_error("sections must be a non-empty list")
-    return context.build.portal_apply(
+    return context.builder.portal_apply(
         profile=args.profile,
-        dash_key=args.dash,
+        dash_key=args.dash_key,
         dash_name=args.dash_name,
         package_tag_id=args.package_tag_id,
         publish=bool(args.publish),
-        sections=sections,
-        auth=payload.get("auth") if isinstance(payload.get("auth"), dict) else None,
-        icon=payload.get("icon") if isinstance(payload.get("icon"), str) else None,
-        color=payload.get("color") if isinstance(payload.get("color"), str) else None,
-        hide_copyright=payload.get("hide_copyright") if isinstance(payload.get("hide_copyright"), bool) else None,
-        dash_global_config=payload.get("dash_global_config") if isinstance(payload.get("dash_global_config"), dict) else None,
-        config=payload.get("config") if isinstance(payload.get("config"), dict) else None,
+        sections=require_list_arg(args.sections_file, option_name="--sections-file"),
+        auth=load_object_arg(args.auth_file, option_name="--auth-file"),
+        icon=args.icon,
+        color=args.color,
+        hide_copyright=args.hide_copyright,
+        dash_global_config=load_object_arg(args.dash_global_config_file, option_name="--dash-global-config-file"),
+        config=load_object_arg(args.config_file, option_name="--config-file"),
     )
 
 
 def _handle_publish_verify(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.build.publish_verify(
+    return context.builder.app_publish_verify(
         profile=args.profile,
-        app_key=args.app,
+        app_key=args.app_key,
         expected_package_tag_id=args.expected_package_tag_id,
     )
-
-
-def _coerce_list(value: Any) -> list[Any]:
-    return value if isinstance(value, list) else []
-
-
-def _normalize_field_spec(value: Any) -> Any:
-    if not isinstance(value, dict):
-        return value
-    normalized = dict(value)
-    if "name" not in normalized and isinstance(normalized.get("field_name"), str):
-        normalized["name"] = normalized["field_name"]
-    if "type" not in normalized and isinstance(normalized.get("field_type"), str):
-        normalized["type"] = normalized["field_type"]
-    normalized.pop("field_name", None)
-    normalized.pop("field_type", None)
-    return normalized
-
-
-def _normalize_field_selector(value: Any) -> Any:
-    if not isinstance(value, dict):
-        return value
-    normalized = dict(value)
-    if "name" not in normalized and isinstance(normalized.get("field_name"), str):
-        normalized["name"] = normalized["field_name"]
-    normalized.pop("field_name", None)
-    return normalized

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

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import argparse
-import json
 import sys
 from typing import Any
 
 from ...errors import QingflowApiError
-from ..json_io import load_json_list, load_json_object
+from ..json_io import load_json_list, load_json_object, load_optional_json_list, load_optional_json_object
 
 
 def parse_bool_text(value: str) -> bool:
@@ -18,104 +17,31 @@ def parse_bool_text(value: str) -> bool:
     raise argparse.ArgumentTypeError("expected one of: true, false, 1, 0, yes, no")
 
 
-def read_secret_arg(value: str | None, *, stdin_enabled: bool, label: str) -> str:
-    if stdin_enabled:
-        secret = sys.stdin.read().strip()
-        if secret:
-            return secret
-    if value:
-        return value
-    raise QingflowApiError.config_error(f"{label} is required")
-
-
-def add_stdin_json_flag(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("--stdin-json", action="store_true", help="从标准输入读取 JSON")
-
-
-def add_file_arg(parser: argparse.ArgumentParser, *, required: bool = False, help_text: str = "从文件读取 JSON") -> None:
-    parser.add_argument("--file", required=required, help=help_text)
-
+def load_list_arg(path: str | None, *, option_name: str) -> list[Any]:
+    return load_optional_json_list(path, option_name=option_name)
 
-def add_field_args(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("--field", dest="fields", action="append", default=[], help="字段赋值，格式：字段名=值")
 
+def load_object_arg(path: str | None, *, option_name: str) -> dict[str, Any] | None:
+    return load_optional_json_object(path, option_name=option_name)
 
-def load_object_input(args: argparse.Namespace, *, required: bool = False) -> dict[str, Any]:
-    if getattr(args, "stdin_json", False):
-        payload = _read_stdin_json()
-        if not isinstance(payload, dict):
-            raise QingflowApiError.config_error("stdin JSON must be an object")
-        return payload
-    file_path = getattr(args, "file", None)
-    if file_path:
-        return load_json_object(file_path, option_name="--file")
-    if required:
-        raise QingflowApiError.config_error("either --stdin-json or --file is required")
-    return {}
 
+def require_list_arg(path: str | None, *, option_name: str) -> list[Any]:
+    if not path:
+        raise QingflowApiError.config_error(f"{option_name} is required")
+    return load_json_list(path, option_name=option_name)
 
-def load_list_input(args: argparse.Namespace, *, required: bool = False) -> list[Any]:
-    if getattr(args, "stdin_json", False):
-        payload = _read_stdin_json()
-        if not isinstance(payload, list):
-            raise QingflowApiError.config_error("stdin JSON must be a list")
-        return payload
-    file_path = getattr(args, "file", None)
-    if file_path:
-        return load_json_list(file_path, option_name="--file")
-    if required:
-        raise QingflowApiError.config_error("either --stdin-json or --file is required")
-    return []
 
+def require_object_arg(path: str | None, *, option_name: str) -> dict[str, Any]:
+    if not path:
+        raise QingflowApiError.config_error(f"{option_name} is required")
+    return load_json_object(path, option_name=option_name)
 
-def parse_field_assignments(items: list[str]) -> dict[str, Any]:
-    payload: dict[str, Any] = {}
-    for item in items:
-        if "=" not in item:
-            raise QingflowApiError.config_error("field assignments must use name=value format")
-        key, raw_value = item.split("=", 1)
-        name = key.strip()
-        if not name:
-            raise QingflowApiError.config_error("field name cannot be empty")
-        payload[name] = _coerce_value(raw_value)
-    return payload
 
-
-def merge_object_inputs(args: argparse.Namespace, *, allow_empty: bool = False) -> dict[str, Any]:
-    payload = parse_field_assignments(list(getattr(args, "fields", []) or []))
-    if getattr(args, "stdin_json", False) or getattr(args, "file", None):
-        loaded = load_object_input(args, required=False)
-        payload.update(loaded)
-    if not payload and not allow_empty:
-        raise QingflowApiError.config_error("provide at least one --field or pass --stdin-json/--file")
-    return payload
-
-
-def _read_stdin_json() -> Any:
-    raw = sys.stdin.read()
-    if not raw.strip():
-        raise QingflowApiError.config_error("stdin JSON is empty")
-    try:
-        return json.loads(raw)
-    except json.JSONDecodeError as error:
-        raise QingflowApiError.config_error(f"stdin JSON is invalid: {error.msg}") from error
-
-
-def _coerce_value(raw: str) -> Any:
-    text = raw.strip()
-    if not text:
-        return ""
-    if text.startswith("{") or text.startswith("[") or text.startswith('"'):
-        try:
-            return json.loads(text)
-        except json.JSONDecodeError:
-            return raw
-    normalized = text.lower()
-    if normalized in {"true", "false", "null"}:
-        return json.loads(normalized)
-    try:
-        if "." in text:
-            return float(text)
-        return int(text)
-    except ValueError:
-        return raw
+def read_secret_arg(value: str | None, *, stdin_enabled: bool, label: str) -> str:
+    if stdin_enabled:
+        secret = sys.stdin.read().strip()
+        if secret:
+            return secret
+    if value:
+        return value
+    raise QingflowApiError.config_error(f"{label} is required")

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

@@ -10,69 +10,77 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     parser = subparsers.add_parser("import", help="导入")
     import_subparsers = parser.add_subparsers(dest="import_command", required=True)
 
-    template = import_subparsers.add_parser("template", help="获取导入模板")
-    template.add_argument("--app", required=True)
-    template.add_argument("--to")
-    template.set_defaults(handler=_handle_template, format_hint="import_template")
+    template = import_subparsers.add_parser("template", help="下载导入模板")
+    template.add_argument("--app-key", required=True)
+    template.add_argument("--download-to-path")
+    template.set_defaults(handler=_handle_template, format_hint="")
 
     verify = import_subparsers.add_parser("verify", help="校验导入文件")
-    verify.add_argument("--app", required=True)
-    verify.add_argument("--file", required=True)
+    verify.add_argument("--app-key", required=True)
+    verify.add_argument("--file-path", required=True)
     verify.set_defaults(handler=_handle_verify, format_hint="import_verify")
 
-    repair = import_subparsers.add_parser("repair", help="在授权后修复导入文件")
-    repair.add_argument("--verification", required=True)
-    repair.add_argument("--authorize", action="store_true")
-    repair.add_argument("--to")
+    repair = import_subparsers.add_parser("repair", help="授权后修复导入文件")
+    repair.add_argument("--verification-id", required=True)
+    repair.add_argument("--authorized-file-modification", action="store_true")
+    repair.add_argument("--output-path")
     repair.add_argument("--repair", dest="selected_repairs", action="append", default=[])
-    repair.set_defaults(handler=_handle_repair, format_hint="import_repair")
+    repair.set_defaults(handler=_handle_repair, format_hint="")
 
     start = import_subparsers.add_parser("start", help="启动导入")
-    start.add_argument("--app", required=True)
-    start.add_argument("--verification", required=True)
-    start.add_argument("--enter-auditing", type=parse_bool_text, required=True)
-    start.add_argument("--view")
-    start.set_defaults(handler=_handle_start, format_hint="import_start")
-
-    status = import_subparsers.add_parser("status", help="查看导入状态")
-    status.add_argument("--app", required=True)
+    start.add_argument("--app-key", required=True)
+    start.add_argument("--verification-id", required=True)
+    start.add_argument("--being-enter-auditing", type=parse_bool_text, required=True)
+    start.add_argument("--view-key")
+    start.set_defaults(handler=_handle_start, format_hint="")
+
+    status = import_subparsers.add_parser("status", help="查询导入状态")
+    status.add_argument("--app-key", required=True)
     status.add_argument("--import-id")
-    status.add_argument("--process-id")
+    status.add_argument("--process-id-str")
     status.set_defaults(handler=_handle_status, format_hint="import_status")
 
 
 def _handle_template(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.template(profile=args.profile, app_key=args.app, download_to_path=args.to)
+    return context.imports.record_import_template_get(
+        profile=args.profile,
+        app_key=args.app_key,
+        download_to_path=args.download_to_path,
+    )
 
 
 def _handle_verify(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.verify(profile=args.profile, app_key=args.app, file_path=args.file)
+    return context.imports.record_import_verify(
+        profile=args.profile,
+        app_key=args.app_key,
+        file_path=args.file_path,
+    )
 
 
 def _handle_repair(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.repair(
+    return context.imports.record_import_repair_local(
         profile=args.profile,
-        verification_id=args.verification,
-        authorized_file_modification=bool(args.authorize),
-        output_path=args.to,
+        verification_id=args.verification_id,
+        authorized_file_modification=bool(args.authorized_file_modification),
+        output_path=args.output_path,
         selected_repairs=list(args.selected_repairs or []),
     )
 
 
 def _handle_start(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.start(
+    return context.imports.record_import_start(
         profile=args.profile,
-        app_key=args.app,
-        verification_id=args.verification,
-        being_enter_auditing=bool(args.enter_auditing),
-        view_key=args.view,
+        app_key=args.app_key,
+        verification_id=args.verification_id,
+        being_enter_auditing=bool(args.being_enter_auditing),
+        view_key=args.view_key,
     )
 
 
 def _handle_status(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.status(
+    return context.imports.record_import_status_get(
         profile=args.profile,
-        app_key=args.app,
+        app_key=args.app_key,
         import_id=args.import_id,
-        process_id_str=args.process_id,
+        process_id_str=args.process_id_str,
     )