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

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

@@ -1,11 +1,12 @@
 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, load_optional_json_list, load_optional_json_object
+from ..json_io import load_json_list, load_json_object
 
 
 def parse_bool_text(value: str) -> bool:
@@ -17,26 +18,6 @@ def parse_bool_text(value: str) -> bool:
     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()
@@ -45,3 +26,96 @@ def read_secret_arg(value: str | None, *, stdin_enabled: bool, label: str) -> st
     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 add_field_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--field", dest="fields", action="append", default=[], help="字段赋值，格式：字段名=值")
+
+
+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 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 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

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

@@ -10,77 +10,69 @@ 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-key", required=True)
-    template.add_argument("--download-to-path")
-    template.set_defaults(handler=_handle_template, format_hint="")
+    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")
 
     verify = import_subparsers.add_parser("verify", help="校验导入文件")
-    verify.add_argument("--app-key", required=True)
-    verify.add_argument("--file-path", required=True)
+    verify.add_argument("--app", required=True)
+    verify.add_argument("--file", 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 = import_subparsers.add_parser("repair", help="在授权后修复导入文件")
+    repair.add_argument("--verification", required=True)
+    repair.add_argument("--authorize", action="store_true")
+    repair.add_argument("--to")
     repair.add_argument("--repair", dest="selected_repairs", action="append", default=[])
-    repair.set_defaults(handler=_handle_repair, format_hint="")
+    repair.set_defaults(handler=_handle_repair, format_hint="import_repair")
 
     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)
+    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)
     status.add_argument("--import-id")
-    status.add_argument("--process-id-str")
+    status.add_argument("--process-id")
     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,
-    )
+    return context.imports.template(profile=args.profile, app_key=args.app, download_to_path=args.to)
 
 
 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,
-    )
+    return context.imports.verify(profile=args.profile, app_key=args.app, file_path=args.file)
 
 
 def _handle_repair(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.record_import_repair_local(
+    return context.imports.repair(
         profile=args.profile,
-        verification_id=args.verification_id,
-        authorized_file_modification=bool(args.authorized_file_modification),
-        output_path=args.output_path,
+        verification_id=args.verification,
+        authorized_file_modification=bool(args.authorize),
+        output_path=args.to,
         selected_repairs=list(args.selected_repairs or []),
     )
 
 
 def _handle_start(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.record_import_start(
+    return context.imports.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,
+        app_key=args.app,
+        verification_id=args.verification,
+        being_enter_auditing=bool(args.enter_auditing),
+        view_key=args.view,
     )
 
 
 def _handle_status(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.record_import_status_get(
+    return context.imports.status(
         profile=args.profile,
-        app_key=args.app_key,
+        app_key=args.app,
         import_id=args.import_id,
-        process_id_str=args.process_id_str,
+        process_id_str=args.process_id,
     )

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

@@ -5,198 +5,200 @@ 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
+from .common import add_field_args, add_file_arg, add_stdin_json_flag, load_list_input, load_object_input, merge_object_inputs
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("record", help="记录与表结构")
-    record_subparsers = parser.add_subparsers(dest="record_command", required=True)
+    parser = subparsers.add_parser("records", help="记录与表结构")
+    record_subparsers = parser.add_subparsers(dest="records_command", required=True)
 
-    schema = record_subparsers.add_parser("schema", help="读取记录相关表结构")
-    schema.add_argument("--app-key", required=True)
+    schema = record_subparsers.add_parser("schema", help="读取记录表结构")
+    schema.add_argument("--app", 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="")
+    schema.add_argument("--view")
+    schema.add_argument("--record", type=int)
+    schema.set_defaults(handler=_handle_schema, format_hint="record_schema")
 
     list_parser = record_subparsers.add_parser("list", help="列出记录")
-    list_parser.add_argument("--app-key", required=True)
+    list_parser.add_argument("--app", required=True)
+    list_parser.add_argument("--view")
     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")
+    add_file_arg(list_parser)
+    add_stdin_json_flag(list_parser)
+    list_parser.set_defaults(handler=_handle_list, format_hint="records_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("--app", required=True)
+    get.add_argument("--record", required=True, type=int)
+    get.add_argument("--view")
     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="")
+    get.set_defaults(handler=_handle_get, format_hint="record_show")
 
-    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="")
+    create = record_subparsers.add_parser("create", help="新增记录")
+    create.add_argument("--app", required=True)
+    add_field_args(create)
+    add_file_arg(create)
+    add_stdin_json_flag(create)
+    create.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
+    create.set_defaults(handler=_handle_create, format_hint="record_write")
 
     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("--app", required=True)
+    update.add_argument("--record", required=True, type=int)
+    add_field_args(update)
+    add_file_arg(update)
+    add_stdin_json_flag(update)
     update.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
-    update.set_defaults(handler=_handle_update, format_hint="")
+    update.set_defaults(handler=_handle_update, format_hint="record_write")
 
     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="")
+    delete.add_argument("--app", required=True)
+    delete.add_argument("--record", type=int)
+    add_file_arg(delete)
+    add_stdin_json_flag(delete)
+    delete.set_defaults(handler=_handle_delete, format_hint="record_write")
 
     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("--app", required=True)
+    analyze.add_argument("--view")
     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
+    add_file_arg(analyze, required=False, help_text="读取分析 JSON，支持 dimensions/metrics/filters/sort")
+    add_stdin_json_flag(analyze)
+    analyze.set_defaults(handler=_handle_analyze, format_hint="record_analyze")
+
+    run_code = record_subparsers.add_parser("run-code", help="执行代码块字段")
+    run_code.add_argument("--app", required=True)
+    run_code.add_argument("--record", required=True, type=int)
+    run_code.add_argument("--field-selector", required=True)
+    run_code.add_argument("--role", type=int, default=1)
+    run_code.add_argument("--node", dest="workflow_node_id", type=int)
+    add_file_arg(run_code, required=False, help_text="读取执行 JSON，支持 answers/fields")
+    add_stdin_json_flag(run_code)
+    run_code.add_argument("--manual", action=argparse.BooleanOptionalAction, default=True)
+    run_code.add_argument("--verify-writeback", action=argparse.BooleanOptionalAction, default=True)
+    run_code.add_argument("--force-refresh-form", action="store_true")
+    run_code.set_defaults(handler=_handle_run_code, format_hint="record_run_code")
 
 
 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)
+    if args.mode == "browse" and not args.view:
+        raise QingflowApiError.config_error("--view is required when --mode browse")
+    if args.mode == "update" and not args.record:
+        raise QingflowApiError.config_error("--record is required when --mode update")
+    return context.records.schema(
+        profile=args.profile,
+        app_key=args.app,
+        mode=args.mode,
+        view_id=args.view,
+        record_id=args.record,
+    )
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.record.record_list(
+    query = _load_query_payload(args)
+    return context.records.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,
+        app_key=args.app,
+        columns=list(args.columns or []) + _coerce_list(query.get("columns")),
+        where=_coerce_list(query.get("where")),
+        order_by=_coerce_list(query.get("order_by")),
+        limit=int(query.get("limit") or args.limit),
+        page=int(query.get("page") or args.page),
+        view_id=str(query.get("view_id") or args.view or "") or None,
+        list_type=None,
+        view_key=None,
+        view_name=None,
     )
 
 
 def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.record.record_get_public(
+    return context.records.get(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        columns=_columns(args),
-        view_id=args.view_id,
+        app_key=args.app,
+        record_id=args.record,
+        columns=list(args.columns or []),
+        view_id=args.view,
+        workflow_node_id=None,
     )
 
 
-def _handle_insert(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.record.record_insert_public(
+def _handle_create(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.records.create(
         profile=args.profile,
-        app_key=args.app_key,
-        fields=require_object_arg(args.fields_file, option_name="--fields-file"),
+        app_key=args.app,
+        fields=merge_object_inputs(args),
         verify_write=bool(args.verify_write),
     )
 
 
 def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.record.record_update_public(
+    return context.records.update(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        fields=require_object_arg(args.fields_file, option_name="--fields-file"),
+        app_key=args.app,
+        record_id=args.record,
+        fields=merge_object_inputs(args),
         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(
+    record_ids = []
+    if args.stdin_json or args.file:
+        payload = load_list_input(args, required=False)
+        record_ids = [item for item in payload if isinstance(item, int)]
+    return context.records.delete(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
+        app_key=args.app,
+        record_id=args.record,
         record_ids=record_ids,
     )
 
 
 def _handle_analyze(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.record.record_analyze(
+    payload = load_object_input(args, required=False)
+    return context.records.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,
+        app_key=args.app,
+        dimensions=_coerce_list(payload.get("dimensions")),
+        metrics=_coerce_list(payload.get("metrics")),
+        filters=_coerce_list(payload.get("filters")),
+        sort=_coerce_list(payload.get("sort")),
+        limit=int(payload.get("limit") or args.limit),
+        strict_full=bool(payload.get("strict_full", args.strict_full)),
+        view_id=str(payload.get("view_id") or args.view or "") or None,
+        list_type=None,
+        view_key=None,
+        view_name=None,
     )
 
 
-def _handle_code_block_run(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.code_block.record_code_block_run(
+def _handle_run_code(args: argparse.Namespace, context: CliContext) -> dict:
+    payload = load_object_input(args, required=False)
+    return context.records.run_code(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        code_block_field=args.code_block_field,
+        app_key=args.app,
+        record_id=args.record,
+        code_block_field=args.field_selector,
         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),
+        answers=_coerce_list(payload.get("answers")),
+        fields=payload.get("fields") if isinstance(payload.get("fields"), dict) else {},
+        manual=bool(payload.get("manual", args.manual)),
+        verify_writeback=bool(payload.get("verify_writeback", args.verify_writeback)),
+        force_refresh_form=bool(payload.get("force_refresh_form", args.force_refresh_form)),
     )
+
+
+def _load_query_payload(args: argparse.Namespace) -> dict[str, Any]:
+    if args.stdin_json or args.file:
+        payload = load_object_input(args, required=False)
+        if payload:
+            return payload
+    return {}
+
+
+def _coerce_list(value: Any) -> list[Any]:
+    return value if isinstance(value, list) else []