@josephyan/qingflow-cli 0.2.0-beta.55

package/src/qingflow_mcp/cli/__init__.py

@@ -0,0 +1 @@
+__all__: list[str] = []

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

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import argparse
+
+from . import app, auth, builder, imports, record, task, workspace
+
+
+def register_all_commands(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    auth.register(subparsers)
+    workspace.register(subparsers)
+    app.register(subparsers)
+    record.register(subparsers)
+    imports.register(subparsers)
+    task.register(subparsers)
+    builder.register(subparsers)

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

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import argparse
+
+from ..context import CliContext
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser("app", help="应用发现")
+    app_subparsers = parser.add_subparsers(dest="app_command", required=True)
+
+    list_parser = app_subparsers.add_parser("list", help="列出可见应用")
+    list_parser.set_defaults(handler=_handle_list, format_hint="app_list")
+
+    search = app_subparsers.add_parser("search", help="搜索应用")
+    search.add_argument("--keyword", default="")
+    search.add_argument("--page", type=int, default=1)
+    search.add_argument("--page-size", type=int, default=50)
+    search.set_defaults(handler=_handle_search, format_hint="app_search")
+
+    get = app_subparsers.add_parser("get", help="读取应用可访问视图与导入能力")
+    get.add_argument("--app-key", required=True)
+    get.set_defaults(handler=_handle_get, format_hint="app_get")
+
+
+def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.app.app_list(profile=args.profile)
+
+
+def _handle_search(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.app.app_search(
+        profile=args.profile,
+        keyword=args.keyword,
+        page_num=args.page,
+        page_size=args.page_size,
+    )
+
+
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.app.app_get(profile=args.profile, app_key=args.app_key)

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

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import argparse
+import getpass
+import sys
+
+from ...errors import QingflowApiError
+from ..context import CliContext
+from .common import read_secret_arg
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser("auth", help="认证与会话")
+    auth_subparsers = parser.add_subparsers(dest="auth_command", required=True)
+
+    login = auth_subparsers.add_parser("login", help="邮箱密码登录")
+    login.add_argument("--base-url")
+    login.add_argument("--qf-version")
+    login.add_argument("--email", required=True)
+    login.add_argument("--password")
+    login.add_argument("--password-stdin", action="store_true")
+    login.add_argument("--persist", action=argparse.BooleanOptionalAction, default=True)
+    login.set_defaults(handler=_handle_login, format_hint="auth_whoami")
+
+    use_token = auth_subparsers.add_parser("use-token", help="直接注入 token")
+    use_token.add_argument("--base-url")
+    use_token.add_argument("--qf-version")
+    use_token.add_argument("--token")
+    use_token.add_argument("--token-stdin", action="store_true")
+    use_token.add_argument("--ws-id", type=int)
+    use_token.add_argument("--persist", action=argparse.BooleanOptionalAction, default=False)
+    use_token.set_defaults(handler=_handle_use_token, format_hint="auth_whoami")
+
+    whoami = auth_subparsers.add_parser("whoami", help="查看当前登录态")
+    whoami.set_defaults(handler=_handle_whoami, format_hint="auth_whoami")
+
+    logout = auth_subparsers.add_parser("logout", help="退出登录")
+    logout.add_argument("--forget-persisted", action="store_true")
+    logout.set_defaults(handler=_handle_logout, format_hint="")
+
+
+def _handle_login(args: argparse.Namespace, context: CliContext) -> dict:
+    password = args.password
+    if args.password_stdin:
+        password = read_secret_arg(args.password, stdin_enabled=True, label="password")
+    elif not password:
+        if sys.stdin.isatty():
+            password = getpass.getpass("Password: ")
+        else:
+            raise QingflowApiError.config_error("password is required; use --password or --password-stdin")
+    return context.auth.auth_login(
+        profile=args.profile,
+        base_url=args.base_url,
+        qf_version=args.qf_version,
+        email=args.email,
+        password=password,
+        persist=bool(args.persist),
+    )
+
+
+def _handle_use_token(args: argparse.Namespace, context: CliContext) -> dict:
+    token = read_secret_arg(args.token, stdin_enabled=bool(args.token_stdin), label="token")
+    return context.auth.auth_use_token(
+        profile=args.profile,
+        base_url=args.base_url,
+        qf_version=args.qf_version,
+        token=token,
+        ws_id=args.ws_id,
+        persist=bool(args.persist),
+    )
+
+
+def _handle_whoami(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.auth.auth_whoami(profile=args.profile)
+
+
+def _handle_logout(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.auth.auth_logout(profile=args.profile, forget_persisted=bool(args.forget_persisted))

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

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import argparse
+
+from ..context import CliContext
+from .common import load_list_arg, load_object_arg, require_list_arg
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser("builder", help="稳定 builder 命令")
+    builder_subparsers = parser.add_subparsers(dest="builder_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("--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_resolve = app_subparsers.add_parser("resolve", help="解析应用")
+    app_resolve.add_argument("--app-key", 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_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)
+    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.builder.package_resolve(profile=args.profile, package_name=args.package_name)
+
+
+def _handle_app_resolve(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_resolve(
+        profile=args.profile,
+        app_key=args.app_key,
+        app_name=args.app_name,
+        package_tag_id=args.package_tag_id,
+    )
+
+
+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_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_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_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_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_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_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_schema_apply(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_schema_apply(
+        profile=args.profile,
+        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_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:
+    return context.builder.portal_apply(
+        profile=args.profile,
+        dash_key=args.dash_key,
+        dash_name=args.dash_name,
+        package_tag_id=args.package_tag_id,
+        publish=bool(args.publish),
+        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.builder.app_publish_verify(
+        profile=args.profile,
+        app_key=args.app_key,
+        expected_package_tag_id=args.expected_package_tag_id,
+    )

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+from ...errors import QingflowApiError
+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:
+    normalized = value.strip().lower()
+    if normalized in {"true", "1", "yes", "y", "on"}:
+        return True
+    if normalized in {"false", "0", "no", "n", "off"}:
+        return False
+    raise argparse.ArgumentTypeError("expected one of: true, false, 1, 0, yes, no")
+
+
+def load_list_arg(path: str | None, *, option_name: str) -> list[Any]:
+    return load_optional_json_list(path, option_name=option_name)
+
+
+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 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 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 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

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import argparse
+
+from ..context import CliContext
+from .common import parse_bool_text
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    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-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-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-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="")
+
+    start = import_subparsers.add_parser("start", help="启动导入")
+    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-str")
+    status.set_defaults(handler=_handle_status, format_hint="import_status")
+
+
+def _handle_template(args: argparse.Namespace, context: CliContext) -> dict:
+    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.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.record_import_repair_local(
+        profile=args.profile,
+        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.record_import_start(
+        profile=args.profile,
+        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.record_import_status_get(
+        profile=args.profile,
+        app_key=args.app_key,
+        import_id=args.import_id,
+        process_id_str=args.process_id_str,
+    )

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

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+from ...errors import QingflowApiError
+from ..context import CliContext
+from .common import load_list_arg, load_object_arg, require_list_arg, require_object_arg
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser("record", help="记录与表结构")
+    record_subparsers = parser.add_subparsers(dest="record_command", required=True)
+
+    schema = record_subparsers.add_parser("schema", help="读取记录相关表结构")
+    schema.add_argument("--app-key", required=True)
+    schema.add_argument("--mode", choices=["applicant", "browse", "insert", "update", "import", "code-block"], default="applicant")
+    schema.add_argument("--view-id")
+    schema.add_argument("--record-id", type=int)
+    schema.set_defaults(handler=_handle_schema, format_hint="")
+
+    list_parser = record_subparsers.add_parser("list", help="列出记录")
+    list_parser.add_argument("--app-key", required=True)
+    list_parser.add_argument("--column", dest="columns", action="append", type=int, default=[])
+    list_parser.add_argument("--columns-file")
+    list_parser.add_argument("--where-file")
+    list_parser.add_argument("--order-by-file")
+    list_parser.add_argument("--limit", type=int, default=20)
+    list_parser.add_argument("--page", type=int, default=1)
+    list_parser.add_argument("--view-id")
+    list_parser.set_defaults(handler=_handle_list, format_hint="record_list")
+
+    get = record_subparsers.add_parser("get", help="读取单条记录")
+    get.add_argument("--app-key", required=True)
+    get.add_argument("--record-id", required=True, type=int)
+    get.add_argument("--column", dest="columns", action="append", type=int, default=[])
+    get.add_argument("--columns-file")
+    get.add_argument("--view-id")
+    get.set_defaults(handler=_handle_get, format_hint="")
+
+    insert = record_subparsers.add_parser("insert", help="新增记录")
+    insert.add_argument("--app-key", required=True)
+    insert.add_argument("--fields-file", required=True)
+    insert.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
+    insert.set_defaults(handler=_handle_insert, format_hint="")
+
+    update = record_subparsers.add_parser("update", help="更新记录")
+    update.add_argument("--app-key", required=True)
+    update.add_argument("--record-id", required=True, type=int)
+    update.add_argument("--fields-file", required=True)
+    update.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
+    update.set_defaults(handler=_handle_update, format_hint="")
+
+    delete = record_subparsers.add_parser("delete", help="删除记录")
+    delete.add_argument("--app-key", required=True)
+    delete.add_argument("--record-id", type=int)
+    delete.add_argument("--record-ids-file")
+    delete.set_defaults(handler=_handle_delete, format_hint="")
+
+    analyze = record_subparsers.add_parser("analyze", help="分析记录数据")
+    analyze.add_argument("--app-key", required=True)
+    analyze.add_argument("--dimensions-file")
+    analyze.add_argument("--metrics-file")
+    analyze.add_argument("--filters-file")
+    analyze.add_argument("--sort-file")
+    analyze.add_argument("--limit", type=int, default=20)
+    analyze.add_argument("--strict-full", action=argparse.BooleanOptionalAction, default=False)
+    analyze.add_argument("--view-id")
+    analyze.set_defaults(handler=_handle_analyze, format_hint="")
+
+    code_block = record_subparsers.add_parser("code-block-run", help="执行代码块字段")
+    code_block.add_argument("--app-key", required=True)
+    code_block.add_argument("--record-id", required=True, type=int)
+    code_block.add_argument("--code-block-field", required=True)
+    code_block.add_argument("--role", type=int, default=1)
+    code_block.add_argument("--workflow-node-id", type=int)
+    code_block.add_argument("--answers-file")
+    code_block.add_argument("--fields-file")
+    code_block.add_argument("--manual", action=argparse.BooleanOptionalAction, default=True)
+    code_block.add_argument("--verify-writeback", action=argparse.BooleanOptionalAction, default=True)
+    code_block.add_argument("--force-refresh-form", action="store_true")
+    code_block.set_defaults(handler=_handle_code_block_run, format_hint="")
+
+
+def _columns(args: argparse.Namespace) -> list[Any]:
+    columns: list[Any] = list(args.columns or [])
+    if args.columns_file:
+        columns.extend(require_list_arg(args.columns_file, option_name="--columns-file"))
+    return columns
+
+
+def _handle_schema(args: argparse.Namespace, context: CliContext) -> dict:
+    mode = args.mode
+    if mode == "applicant":
+        return context.record.record_schema_get(
+            profile=args.profile,
+            app_key=args.app_key,
+            schema_mode="applicant",
+        )
+    if mode == "browse":
+        if not args.view_id:
+            raise QingflowApiError.config_error("--view-id is required when --mode browse")
+        return context.record.record_browse_schema_get_public(
+            profile=args.profile,
+            app_key=args.app_key,
+            view_id=args.view_id,
+        )
+    if mode == "insert":
+        return context.record.record_insert_schema_get_public(profile=args.profile, app_key=args.app_key)
+    if mode == "update":
+        if not args.record_id:
+            raise QingflowApiError.config_error("--record-id is required when --mode update")
+        return context.record.record_update_schema_get_public(
+            profile=args.profile,
+            app_key=args.app_key,
+            record_id=args.record_id,
+        )
+    if mode == "import":
+        return context.imports.record_import_schema_get(profile=args.profile, app_key=args.app_key)
+    return context.code_block.record_code_block_schema_get_public(profile=args.profile, app_key=args.app_key)
+
+
+def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_list(
+        profile=args.profile,
+        app_key=args.app_key,
+        columns=_columns(args),
+        where=load_list_arg(args.where_file, option_name="--where-file"),
+        order_by=load_list_arg(args.order_by_file, option_name="--order-by-file"),
+        limit=args.limit,
+        page=args.page,
+        view_id=args.view_id,
+    )
+
+
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_get_public(
+        profile=args.profile,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        columns=_columns(args),
+        view_id=args.view_id,
+    )
+
+
+def _handle_insert(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_insert_public(
+        profile=args.profile,
+        app_key=args.app_key,
+        fields=require_object_arg(args.fields_file, option_name="--fields-file"),
+        verify_write=bool(args.verify_write),
+    )
+
+
+def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_update_public(
+        profile=args.profile,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        fields=require_object_arg(args.fields_file, option_name="--fields-file"),
+        verify_write=bool(args.verify_write),
+    )
+
+
+def _handle_delete(args: argparse.Namespace, context: CliContext) -> dict:
+    record_ids = load_list_arg(args.record_ids_file, option_name="--record-ids-file")
+    return context.record.record_delete_public(
+        profile=args.profile,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        record_ids=record_ids,
+    )
+
+
+def _handle_analyze(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_analyze(
+        profile=args.profile,
+        app_key=args.app_key,
+        dimensions=load_list_arg(args.dimensions_file, option_name="--dimensions-file"),
+        metrics=load_list_arg(args.metrics_file, option_name="--metrics-file"),
+        filters=load_list_arg(args.filters_file, option_name="--filters-file"),
+        sort=load_list_arg(args.sort_file, option_name="--sort-file"),
+        limit=args.limit,
+        strict_full=bool(args.strict_full),
+        view_id=args.view_id,
+    )
+
+
+def _handle_code_block_run(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.code_block.record_code_block_run(
+        profile=args.profile,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        code_block_field=args.code_block_field,
+        role=args.role,
+        workflow_node_id=args.workflow_node_id,
+        answers=load_list_arg(args.answers_file, option_name="--answers-file"),
+        fields=load_object_arg(args.fields_file, option_name="--fields-file") or {},
+        manual=bool(args.manual),
+        verify_writeback=bool(args.verify_writeback),
+        force_refresh_form=bool(args.force_refresh_form),
+    )