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

package/src/qingflow_mcp/cli/formatters.py

@@ -3,11 +3,8 @@ from __future__ import annotations
 import json
 from typing import Any, TextIO
 
-from ..ops.base import public_result
-
 
 def emit_text_result(result: dict[str, Any], *, hint: str, stream: TextIO) -> None:
-    result = public_result(result)
     formatter = _FORMATTERS.get(hint, _format_generic)
     text = formatter(result)
     stream.write(text)
@@ -15,65 +12,61 @@ def emit_text_result(result: dict[str, Any], *, hint: str, stream: TextIO) -> No
         stream.write("\n")
 
 
-def emit_json_result(result: dict[str, Any], *, stream: TextIO) -> None:
-    json.dump(public_result(result), stream, ensure_ascii=False, indent=2)
-    stream.write("\n")
-
-
 def _format_generic(result: dict[str, Any]) -> str:
-    lines = [f"{result.get('message') or result.get('code') or '完成'}"]
+    lines: list[str] = []
+    title = _first_present(result, "status", "message")
+    if title:
+        lines.append(str(title))
     data = result.get("data")
     if isinstance(data, dict):
-        lines.extend(_scalar_lines(data, limit=10))
+        scalar_lines = _dict_scalar_lines(data)
+        if scalar_lines:
+            lines.extend(scalar_lines)
+    elif result:
+        scalar_lines = _dict_scalar_lines(result)
+        if scalar_lines:
+            lines.extend(scalar_lines)
+    if not lines:
+        lines.append(json.dumps(result, ensure_ascii=False, indent=2))
     _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
 
 
-def _format_me(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
-    user = data.get("user") if isinstance(data.get("user"), dict) else {}
-    workspace = data.get("workspace") if isinstance(data.get("workspace"), dict) else {}
+def _format_whoami(result: dict[str, Any]) -> str:
     lines = [
-        f"Profile: {data.get('profile') or result.get('meta', {}).get('profile') or '-'}",
-        f"User: {user.get('nick_name') or '-'} ({user.get('email') or '-'})",
-        f"UID: {user.get('uid') or '-'}",
-        f"Workspace: {workspace.get('name') or '-'} ({workspace.get('ws_id') or '-'})",
-        f"Base URL: {data.get('base_url') or '-'}",
+        f"Profile: {result.get('profile')}",
+        f"User: {result.get('nick_name') or '-'} ({result.get('email') or '-'})",
+        f"UID: {result.get('uid')}",
+        f"Workspace: {result.get('selected_ws_name') or '-'} ({result.get('selected_ws_id') or '-'})",
+        f"Base URL: {result.get('base_url')}",
     ]
     return "\n".join(lines) + "\n"
 
 
 def _format_workspace_list(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
-    items = data.get("items") if isinstance(data.get("items"), list) else []
-    rows = [
-        [
-            str(item.get("ws_id") or ""),
-            str(item.get("name") or ""),
-            str(item.get("remark") or ""),
-        ]
-        for item in items
-        if isinstance(item, dict)
-    ]
+    page = result.get("page") if isinstance(result.get("page"), dict) else {}
+    items = page.get("list") if isinstance(page.get("list"), list) else []
+    rows = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        rows.append(
+            [
+                str(item.get("wsId") or ""),
+                str(item.get("workspaceName") or item.get("wsName") or ""),
+                str(item.get("remark") or ""),
+            ]
+        )
     return _render_titled_table("Workspaces", ["ws_id", "name", "remark"], rows)
 
 
-def _format_workspace_use(result: dict[str, Any]) -> str:
-    workspace = result.get("data", {}).get("workspace") if isinstance(result.get("data"), dict) else {}
-    lines = [
-        f"Workspace: {workspace.get('name') or '-'}",
-        f"WS ID: {workspace.get('ws_id') or '-'}",
-        f"QF Version: {result.get('data', {}).get('qf_version') or '-'}",
-        f"QF Version Source: {result.get('data', {}).get('qf_version_source') or '-'}",
-    ]
-    return "\n".join(lines) + "\n"
-
-
-def _format_apps_list(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
-    items = data.get("items") if isinstance(data.get("items"), list) else []
+def _format_app_items(result: dict[str, Any]) -> str:
+    items = result.get("items")
+    if not isinstance(items, list):
+        items = result.get("apps")
     rows = []
-    for item in items:
+    for item in items or []:
         if not isinstance(item, dict):
             continue
         rows.append(
@@ -86,7 +79,7 @@ def _format_apps_list(result: dict[str, Any]) -> str:
     return _render_titled_table("Apps", ["app_key", "app_name", "package"], rows)
 
 
-def _format_app_show(result: dict[str, Any]) -> str:
+def _format_app_get(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     lines = [
         f"App: {data.get('app_name') or '-'}",
@@ -97,7 +90,8 @@ def _format_app_show(result: dict[str, Any]) -> str:
     if isinstance(import_capability, dict):
         lines.append(
             "Import Capability: "
-            f"{import_capability.get('auth_source') or 'unknown'} / can_import={import_capability.get('can_import')}"
+            f"{import_capability.get('auth_source') or 'unknown'} / "
+            f"can_import={import_capability.get('can_import')}"
         )
     views = data.get("accessible_views") if isinstance(data.get("accessible_views"), list) else []
     lines.append(f"Accessible Views: {len(views)}")
@@ -108,7 +102,7 @@ def _format_app_show(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
-def _format_records_list(result: dict[str, Any]) -> str:
+def _format_record_list(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     items = data.get("items") if isinstance(data.get("items"), list) else []
     lines = [f"Returned Records: {len(items)}"]
@@ -118,43 +112,40 @@ def _format_records_list(result: dict[str, Any]) -> str:
     if len(items) > 10:
         lines.append(f"... {len(items) - 10} more")
     _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
 
 
-def _format_record_show(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
-    record = data.get("record")
-    if isinstance(record, dict):
-        lines = [f"Record ID: {data.get('record_id') or '-'}"]
-        lines.extend(_scalar_lines(record, limit=12))
-        _append_warnings(lines, result.get("warnings"))
-        return "\n".join(lines) + "\n"
-    return _format_generic(result)
-
-
-def _format_record_write(result: dict[str, Any]) -> str:
+def _format_task_list(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
-    lines = [
-        f"Code: {result.get('code')}",
-        f"Message: {result.get('message')}",
-    ]
-    if data.get("record_id") is not None:
-        lines.append(f"Record ID: {data.get('record_id')}")
-    if isinstance(data.get("record_ids"), list):
-        lines.append(f"Record IDs: {', '.join(str(item) for item in data['record_ids'])}")
+    items = data.get("items") if isinstance(data.get("items"), list) else []
+    rows = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        rows.append(
+            [
+                str(item.get("app_key") or ""),
+                str(item.get("record_id") or ""),
+                str(item.get("workflow_node_id") or ""),
+                str(item.get("title") or item.get("task_name") or ""),
+            ]
+        )
+    output = _render_titled_table("Tasks", ["app_key", "record_id", "node_id", "title"], rows)
+    lines = output.rstrip("\n").split("\n")
     _append_warnings(lines, result.get("warnings"))
     return "\n".join(lines) + "\n"
 
 
 def _format_import_verify(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
     lines = [
-        f"File: {data.get('file_name') or data.get('file_path') or '-'}",
-        f"Can Import: {data.get('can_import')}",
-        f"Apply Rows: {data.get('apply_rows')}",
-        f"Verification ID: {data.get('verification_id') or '-'}",
+        f"App Key: {result.get('app_key') or '-'}",
+        f"File: {result.get('file_name') or result.get('file_path') or '-'}",
+        f"Can Import: {result.get('can_import')}",
+        f"Apply Rows: {result.get('apply_rows')}",
+        f"Verification ID: {result.get('verification_id') or '-'}",
     ]
-    issues = data.get("issues") if isinstance(data.get("issues"), list) else []
+    issues = result.get("issues") if isinstance(result.get("issues"), list) else []
     if issues:
         lines.append("Issues:")
         for issue in issues:
@@ -163,53 +154,50 @@ def _format_import_verify(result: dict[str, Any]) -> str:
             else:
                 lines.append(f"- {issue}")
     _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
 
 
 def _format_import_status(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
     lines = [
-        f"Status: {data.get('status') or '-'}",
-        f"Import ID: {data.get('import_id') or '-'}",
-        f"Process ID: {data.get('process_id_str') or '-'}",
-        f"Success Rows: {data.get('success_rows') or 0}",
-        f"Failed Rows: {data.get('failed_rows') or 0}",
-        f"Progress: {data.get('progress') or '-'}",
+        f"Status: {result.get('status') or '-'}",
+        f"Import ID: {result.get('import_id') or '-'}",
+        f"Process ID: {result.get('process_id_str') or '-'}",
+        f"Success Rows: {result.get('success_rows') or 0}",
+        f"Failed Rows: {result.get('failed_rows') or 0}",
+        f"Progress: {result.get('progress') or '-'}",
     ]
     _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
 
 
-def _format_tasks_list(result: dict[str, Any]) -> str:
-    data = result.get("data") if isinstance(result.get("data"), dict) else {}
-    items = data.get("items") if isinstance(data.get("items"), list) else []
-    rows = []
-    for item in items:
-        if not isinstance(item, dict):
-            continue
-        rows.append(
-            [
-                str(item.get("app_key") or ""),
-                str(item.get("record_id") or ""),
-                str(item.get("workflow_node_id") or ""),
-                str(item.get("title") or ""),
-            ]
-        )
-    output = _render_titled_table("Tasks", ["app_key", "record_id", "node_id", "title"], rows)
-    lines = output.rstrip("\n").split("\n")
-    _append_warnings(lines, result.get("warnings"))
-    return "\n".join(lines) + "\n"
-
-
-def _format_builder_result(result: dict[str, Any]) -> str:
-    lines = [f"Code: {result.get('code')}", f"Message: {result.get('message')}"]
+def _format_builder_summary(result: dict[str, Any]) -> str:
+    lines = []
+    if "status" in result:
+        lines.append(f"Status: {result.get('status')}")
+    if "app_key" in result:
+        lines.append(f"App Key: {result.get('app_key')}")
+    if "dash_key" in result:
+        lines.append(f"Dash Key: {result.get('dash_key')}")
+    if "verified" in result:
+        lines.append(f"Verified: {result.get('verified')}")
     data = result.get("data")
     if isinstance(data, dict):
-        lines.extend(_scalar_lines(data, limit=10))
+        scalar_lines = _dict_scalar_lines(data)
+        lines.extend(scalar_lines[:8])
     _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
+    if not lines:
+        return _format_generic(result)
     return "\n".join(lines) + "\n"
 
 
+def emit_json_result(result: dict[str, Any], *, stream: TextIO) -> None:
+    json.dump(result, stream, ensure_ascii=False, indent=2)
+    stream.write("\n")
+
+
 def _render_titled_table(title: str, headers: list[str], rows: list[list[str]]) -> str:
     lines = [title]
     if not rows:
@@ -219,20 +207,19 @@ def _render_titled_table(title: str, headers: list[str], rows: list[list[str]])
     for row in rows:
         for index, cell in enumerate(row):
             widths[index] = max(widths[index], len(cell))
-    lines.append("  ".join(header.ljust(widths[index]) for index, header in enumerate(headers)))
+    header_line = "  ".join(header.ljust(widths[index]) for index, header in enumerate(headers))
+    lines.append(header_line)
     lines.append("  ".join("-" * width for width in widths))
     for row in rows:
         lines.append("  ".join(cell.ljust(widths[index]) for index, cell in enumerate(row)))
     return "\n".join(lines) + "\n"
 
 
-def _scalar_lines(payload: dict[str, Any], *, limit: int) -> list[str]:
+def _dict_scalar_lines(payload: dict[str, Any]) -> list[str]:
     lines: list[str] = []
     for key, value in payload.items():
         if isinstance(value, (str, int, float, bool)) or value is None:
             lines.append(f"{key}: {value}")
-            if len(lines) >= limit:
-                break
     return lines
 
 
@@ -244,23 +231,39 @@ def _append_warnings(lines: list[str], warnings: Any) -> None:
         if isinstance(warning, dict):
             code = warning.get("code")
             message = warning.get("message")
-            lines.append(f"- {code or 'WARNING'}: {message or ''}".rstrip())
+            if code or message:
+                lines.append(f"- {code or 'WARNING'}: {message or ''}".rstrip())
+            else:
+                lines.append(f"- {json.dumps(warning, ensure_ascii=False)}")
         else:
             lines.append(f"- {warning}")
 
 
+def _append_verification(lines: list[str], verification: Any) -> None:
+    if not isinstance(verification, dict) or not verification:
+        return
+    lines.append("Verification:")
+    for key, value in verification.items():
+        if isinstance(value, (str, int, float, bool)) or value is None:
+            lines.append(f"- {key}: {value}")
+
+
+def _first_present(payload: dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        if key in payload and payload.get(key) is not None:
+            return payload.get(key)
+    return None
+
+
 _FORMATTERS = {
-    "me": _format_me,
-    "session": _format_me,
-    "ws_list": _format_workspace_list,
-    "ws_use": _format_workspace_use,
-    "apps_list": _format_apps_list,
-    "app_show": _format_app_show,
-    "records_list": _format_records_list,
-    "record_show": _format_record_show,
-    "record_write": _format_record_write,
+    "auth_whoami": _format_whoami,
+    "workspace_list": _format_workspace_list,
+    "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,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,
-    "tasks_list": _format_tasks_list,
-    "builder_result": _format_builder_result,
+    "builder_summary": _format_builder_summary,
 }

package/src/qingflow_mcp/cli/main.py

@@ -1,23 +1,23 @@
 from __future__ import annotations
 
 import argparse
+import json
 import sys
 from typing import Any, Callable, TextIO
 
 from ..errors import QingflowApiError
-from ..ops.base import normalize_exception
-from .commands import register_all_commands
 from .context import CliContext, build_cli_context
 from .formatters import emit_json_result, emit_text_result
+from .commands import register_all_commands
 
 
 Handler = Callable[[argparse.Namespace, CliContext], dict[str, Any]]
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="qingflow", description="Qingflow CLI 2.0")
+    parser = argparse.ArgumentParser(prog="qingflow", description="Qingflow CLI")
     parser.add_argument("--profile", default="default", help="会话 profile，默认 default")
-    parser.add_argument("--json", action="store_true", help="输出结构化 JSON")
+    parser.add_argument("--json", action="store_true", help="输出原始 JSON")
     subparsers = parser.add_subparsers(dest="command", required=True)
     register_all_commands(subparsers)
     return parser
@@ -46,16 +46,15 @@ def run(
     if handler is None:
         parser.print_help(out)
         return 2
-
     context = context_factory()
     try:
         result = handler(args, context)
     except RuntimeError as exc:
-        result = normalize_exception(exc)
+        payload = _parse_error_payload(exc)
+        return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)
     except QingflowApiError as exc:
-        result = normalize_exception(exc)
-    except Exception as exc:  # noqa: BLE001
-        result = normalize_exception(exc)
+        payload = exc.to_dict()
+        return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)
     finally:
         context.close()
 
@@ -95,17 +94,53 @@ def _normalize_global_args(argv: list[str]) -> list[str]:
     return global_args + remaining
 
 
+def _parse_error_payload(exc: RuntimeError) -> dict[str, Any]:
+    raw = str(exc)
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return {"category": "runtime", "message": raw}
+    return payload if isinstance(payload, dict) else {"category": "runtime", "message": raw}
+
+
+def _emit_error(payload: dict[str, Any], *, json_mode: bool, stdout: TextIO, stderr: TextIO) -> int:
+    exit_code = _error_exit_code(payload)
+    if json_mode:
+        emit_json_result(payload, stream=stdout)
+        return exit_code
+    lines = [
+        f"Category: {payload.get('category') or 'error'}",
+        f"Message: {payload.get('message') or 'Unknown error'}",
+    ]
+    if payload.get("backend_code") is not None:
+        lines.append(f"Backend Code: {payload.get('backend_code')}")
+    if payload.get("request_id"):
+        lines.append(f"Request ID: {payload.get('request_id')}")
+    details = payload.get("details")
+    if isinstance(details, dict):
+        for key, value in details.items():
+            if isinstance(value, (str, int, float, bool)) or value is None:
+                lines.append(f"{key}: {value}")
+    stderr.write("\n".join(lines) + "\n")
+    return exit_code
+
+
+def _error_exit_code(payload: dict[str, Any]) -> int:
+    category = str(payload.get("category") or "").lower()
+    if category in {"auth", "workspace"}:
+        return 3
+    return 4
+
+
 def _result_exit_code(result: dict[str, Any]) -> int:
     if not isinstance(result, dict):
         return 0
-    if result.get("ok") is not False:
-        return 0
-    code = str(result.get("code") or "").upper()
-    if code in {"AUTH_REQUIRED", "WORKSPACE_NOT_SELECTED"}:
-        return 3
-    if code in {"INVALID_ARGUMENT", "CONFIG"}:
-        return 2
-    return 4
+    if result.get("ok") is False:
+        return 4
+    status = str(result.get("status") or "").lower()
+    if status in {"failed", "blocked"}:
+        return 4
+    return 0
 
 
 if __name__ == "__main__":