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

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

@@ -3,52 +3,53 @@ from __future__ import annotations
 import argparse
 
 from ..context import CliContext
-from .common import load_object_arg
+from .common import add_file_arg, add_stdin_json_flag, load_object_input
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("task", help="待办与流程上下文")
-    task_subparsers = parser.add_subparsers(dest="task_command", required=True)
+    parser = subparsers.add_parser("tasks", help="待办与流程上下文")
+    task_subparsers = parser.add_subparsers(dest="tasks_command", required=True)
 
     list_parser = task_subparsers.add_parser("list", help="列出待办")
     list_parser.add_argument("--task-box", default="todo")
     list_parser.add_argument("--flow-status", default="all")
-    list_parser.add_argument("--app-key")
-    list_parser.add_argument("--workflow-node-id", type=int)
+    list_parser.add_argument("--app")
+    list_parser.add_argument("--node", dest="workflow_node_id", type=int)
     list_parser.add_argument("--query")
     list_parser.add_argument("--page", type=int, default=1)
     list_parser.add_argument("--page-size", type=int, default=20)
-    list_parser.set_defaults(handler=_handle_list, format_hint="task_list")
-
-    get = task_subparsers.add_parser("get", help="读取待办详情")
-    get.add_argument("--app-key", required=True)
-    get.add_argument("--record-id", required=True, type=int)
-    get.add_argument("--workflow-node-id", required=True, type=int)
-    get.add_argument("--include-candidates", action=argparse.BooleanOptionalAction, default=True)
-    get.add_argument("--include-associated-reports", action=argparse.BooleanOptionalAction, default=True)
-    get.set_defaults(handler=_handle_get, format_hint="")
-
-    action = task_subparsers.add_parser("action", help="执行待办动作")
-    action.add_argument("--app-key", required=True)
-    action.add_argument("--record-id", required=True, type=int)
-    action.add_argument("--workflow-node-id", required=True, type=int)
-    action.add_argument("--action", required=True)
-    action.add_argument("--payload-file")
-    action.set_defaults(handler=_handle_action, format_hint="")
+    list_parser.set_defaults(handler=_handle_list, format_hint="tasks_list")
+
+    show = task_subparsers.add_parser("show", help="读取待办详情")
+    show.add_argument("--app", required=True)
+    show.add_argument("--record", required=True, type=int)
+    show.add_argument("--node", required=True, type=int)
+    show.add_argument("--include-candidates", action=argparse.BooleanOptionalAction, default=True)
+    show.add_argument("--include-associated-reports", action=argparse.BooleanOptionalAction, default=True)
+    show.set_defaults(handler=_handle_show, format_hint="task_show")
+
+    act = task_subparsers.add_parser("act", help="执行待办动作")
+    act.add_argument("--app", required=True)
+    act.add_argument("--record", required=True, type=int)
+    act.add_argument("--node", required=True, type=int)
+    act.add_argument("--action", required=True)
+    add_file_arg(act)
+    add_stdin_json_flag(act)
+    act.set_defaults(handler=_handle_act, format_hint="task_action")
 
     log = task_subparsers.add_parser("log", help="读取流程日志")
-    log.add_argument("--app-key", required=True)
-    log.add_argument("--record-id", required=True, type=int)
-    log.add_argument("--workflow-node-id", required=True, type=int)
-    log.set_defaults(handler=_handle_log, format_hint="")
+    log.add_argument("--app", required=True)
+    log.add_argument("--record", required=True, type=int)
+    log.add_argument("--node", required=True, type=int)
+    log.set_defaults(handler=_handle_log, format_hint="task_log")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.task.task_list(
+    return context.tasks.list(
         profile=args.profile,
         task_box=args.task_box,
         flow_status=args.flow_status,
-        app_key=args.app_key,
+        app_key=args.app,
         workflow_node_id=args.workflow_node_id,
         query=args.query,
         page=args.page,
@@ -56,32 +57,32 @@ def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
-def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.task.task_get(
+def _handle_show(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.tasks.show(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        workflow_node_id=args.workflow_node_id,
+        app_key=args.app,
+        record_id=args.record,
+        workflow_node_id=args.node,
         include_candidates=bool(args.include_candidates),
         include_associated_reports=bool(args.include_associated_reports),
     )
 
 
-def _handle_action(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.task.task_action_execute(
+def _handle_act(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.tasks.act(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        workflow_node_id=args.workflow_node_id,
+        app_key=args.app,
+        record_id=args.record,
+        workflow_node_id=args.node,
         action=args.action,
-        payload=load_object_arg(args.payload_file, option_name="--payload-file") or {},
+        payload=load_object_input(args, required=False),
     )
 
 
 def _handle_log(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.task.task_workflow_log_get(
+    return context.tasks.log(
         profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        workflow_node_id=args.workflow_node_id,
+        app_key=args.app,
+        record_id=args.record,
+        workflow_node_id=args.node,
     )

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

@@ -6,22 +6,22 @@ from ..context import CliContext
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("workspace", help="工作区")
-    workspace_subparsers = parser.add_subparsers(dest="workspace_command", required=True)
+    parser = subparsers.add_parser("ws", help="工作区操作")
+    ws_subparsers = parser.add_subparsers(dest="ws_command", required=True)
 
-    list_parser = workspace_subparsers.add_parser("list", help="列出工作区")
+    list_parser = ws_subparsers.add_parser("list", help="列出工作区")
     list_parser.add_argument("--page", type=int, default=1)
     list_parser.add_argument("--page-size", type=int, default=20)
     list_parser.add_argument("--include-external", action="store_true")
-    list_parser.set_defaults(handler=_handle_list, format_hint="workspace_list")
+    list_parser.set_defaults(handler=_handle_list, format_hint="ws_list")
 
-    select = workspace_subparsers.add_parser("select", help="切换工作区")
-    select.add_argument("--ws-id", type=int, required=True)
-    select.set_defaults(handler=_handle_select, format_hint="")
+    use = ws_subparsers.add_parser("use", help="切换工作区")
+    use.add_argument("--ws-id", type=int, required=True)
+    use.set_defaults(handler=_handle_use, format_hint="ws_use")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.workspace.workspace_list(
+    return context.workspace.list(
         profile=args.profile,
         page_num=args.page,
         page_size=args.page_size,
@@ -29,5 +29,5 @@ def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
-def _handle_select(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.workspace.workspace_select(profile=args.profile, ws_id=args.ws_id)
+def _handle_use(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.workspace.use(profile=args.profile, ws_id=args.ws_id)

package/src/qingflow_mcp/cli/context.py

@@ -2,47 +2,44 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from ..backend_client import BackendClient
-from ..session_store import SessionStore
-from ..tools.ai_builder_tools import AiBuilderTools
-from ..tools.app_tools import AppTools
-from ..tools.auth_tools import AuthTools
-from ..tools.code_block_tools import CodeBlockTools
-from ..tools.import_tools import ImportTools
-from ..tools.record_tools import RecordTools
-from ..tools.task_context_tools import TaskContextTools
-from ..tools.workspace_tools import WorkspaceTools
+from ..ops.context import OperationsRuntime, build_operations_runtime
 
 
 @dataclass(slots=True)
 class CliContext:
-    sessions: SessionStore
-    backend: BackendClient
-    auth: AuthTools
-    workspace: WorkspaceTools
-    app: AppTools
-    record: RecordTools
-    code_block: CodeBlockTools
-    imports: ImportTools
-    task: TaskContextTools
-    builder: AiBuilderTools
+    runtime: OperationsRuntime
+
+    @property
+    def auth(self):
+        return self.runtime.auth
+
+    @property
+    def workspace(self):
+        return self.runtime.workspace
+
+    @property
+    def apps(self):
+        return self.runtime.apps
+
+    @property
+    def records(self):
+        return self.runtime.records
+
+    @property
+    def imports(self):
+        return self.runtime.imports
+
+    @property
+    def tasks(self):
+        return self.runtime.tasks
+
+    @property
+    def build(self):
+        return self.runtime.builder
 
     def close(self) -> None:
-        self.backend.close()
+        self.runtime.close()
 
 
 def build_cli_context() -> CliContext:
-    sessions = SessionStore()
-    backend = BackendClient()
-    return CliContext(
-        sessions=sessions,
-        backend=backend,
-        auth=AuthTools(sessions, backend),
-        workspace=WorkspaceTools(sessions, backend),
-        app=AppTools(sessions, backend),
-        record=RecordTools(sessions, backend),
-        code_block=CodeBlockTools(sessions, backend),
-        imports=ImportTools(sessions, backend),
-        task=TaskContextTools(sessions, backend),
-        builder=AiBuilderTools(sessions, backend),
-    )
+    return CliContext(runtime=build_operations_runtime())

package/src/qingflow_mcp/cli/formatters.py

@@ -3,8 +3,11 @@ 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)
@@ -12,61 +15,65 @@ 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: list[str] = []
-    title = _first_present(result, "status", "message")
-    if title:
-        lines.append(str(title))
+    lines = [f"{result.get('message') or result.get('code') or '完成'}"]
     data = result.get("data")
     if isinstance(data, dict):
-        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))
+        lines.extend(_scalar_lines(data, limit=10))
     _append_warnings(lines, result.get("warnings"))
-    _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
 
 
-def _format_whoami(result: dict[str, Any]) -> str:
+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 {}
     lines = [
-        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')}",
+        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 '-'}",
     ]
     return "\n".join(lines) + "\n"
 
 
 def _format_workspace_list(result: dict[str, Any]) -> str:
-    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 ""),
-            ]
-        )
+    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)
+    ]
     return _render_titled_table("Workspaces", ["ws_id", "name", "remark"], rows)
 
 
-def _format_app_items(result: dict[str, Any]) -> str:
-    items = result.get("items")
-    if not isinstance(items, list):
-        items = result.get("apps")
+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 []
     rows = []
-    for item in items or []:
+    for item in items:
         if not isinstance(item, dict):
             continue
         rows.append(
@@ -79,7 +86,7 @@ def _format_app_items(result: dict[str, Any]) -> str:
     return _render_titled_table("Apps", ["app_key", "app_name", "package"], rows)
 
 
-def _format_app_get(result: dict[str, Any]) -> str:
+def _format_app_show(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     lines = [
         f"App: {data.get('app_name') or '-'}",
@@ -90,8 +97,7 @@ def _format_app_get(result: dict[str, Any]) -> str:
     if isinstance(import_capability, dict):
         lines.append(
             "Import Capability: "
-            f"{import_capability.get('auth_source') or 'unknown'} / "
-            f"can_import={import_capability.get('can_import')}"
+            f"{import_capability.get('auth_source') or 'unknown'} / 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)}")
@@ -102,7 +108,7 @@ def _format_app_get(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
-def _format_record_list(result: dict[str, Any]) -> str:
+def _format_records_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)}"]
@@ -112,40 +118,43 @@ def _format_record_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_task_list(result: dict[str, Any]) -> str:
+def _format_record_show(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 item.get("task_name") or ""),
-            ]
-        )
-    output = _render_titled_table("Tasks", ["app_key", "record_id", "node_id", "title"], rows)
-    lines = output.rstrip("\n").split("\n")
+    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:
+    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'])}")
     _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"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 '-'}",
+        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 '-'}",
     ]
-    issues = result.get("issues") if isinstance(result.get("issues"), list) else []
+    issues = data.get("issues") if isinstance(data.get("issues"), list) else []
     if issues:
         lines.append("Issues:")
         for issue in issues:
@@ -154,48 +163,51 @@ 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: {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 '-'}",
+        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 '-'}",
     ]
     _append_warnings(lines, result.get("warnings"))
-    _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
 
 
-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):
-        scalar_lines = _dict_scalar_lines(data)
-        lines.extend(scalar_lines[:8])
+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"))
-    _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 _format_builder_result(result: dict[str, Any]) -> str:
+    lines = [f"Code: {result.get('code')}", f"Message: {result.get('message')}"]
+    data = result.get("data")
+    if isinstance(data, dict):
+        lines.extend(_scalar_lines(data, limit=10))
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
 
 
 def _render_titled_table(title: str, headers: list[str], rows: list[list[str]]) -> str:
@@ -207,19 +219,20 @@ 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))
-    header_line = "  ".join(header.ljust(widths[index]) for index, header in enumerate(headers))
-    lines.append(header_line)
+    lines.append("  ".join(header.ljust(widths[index]) for index, header in enumerate(headers)))
     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 _dict_scalar_lines(payload: dict[str, Any]) -> list[str]:
+def _scalar_lines(payload: dict[str, Any], *, limit: int) -> 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
 
 
@@ -231,39 +244,23 @@ def _append_warnings(lines: list[str], warnings: Any) -> None:
         if isinstance(warning, dict):
             code = warning.get("code")
             message = warning.get("message")
-            if code or message:
-                lines.append(f"- {code or 'WARNING'}: {message or ''}".rstrip())
-            else:
-                lines.append(f"- {json.dumps(warning, ensure_ascii=False)}")
+            lines.append(f"- {code or 'WARNING'}: {message or ''}".rstrip())
         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 = {
-    "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,
+    "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,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,
-    "builder_summary": _format_builder_summary,
+    "tasks_list": _format_tasks_list,
+    "builder_result": _format_builder_result,
 }