mcp2cli 3.0.3__tar.gz → 3.2.0__tar.gz

{mcp2cli-3.0.3 → mcp2cli-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp2cli
-Version: 3.0.3
+Version: 3.2.0
 Summary: Turn any MCP server or OpenAPI spec into a CLI
 Author: Stephan Fitzpatrick
 Author-email: Stephan Fitzpatrick <stephan@knowsuchagency.com>
@@ -236,6 +236,36 @@ mcp2cli @myapi --list --sort alpha
 
 When usage data exists for a source, `--list` defaults to sorting by call frequency. Otherwise insertion order is preserved. Usage data is stored in `~/.cache/mcp2cli/usage.json`.
 
+### JSON output
+
+`--json` forces **valid JSON on stdout for every command**, in every mode. It is the
+machine-readable counterpart to the human-formatted default output, designed for LLM
+agents and scripts that need to parse results reliably.
+
+```bash
+# --list emits a JSON array of command objects (name, description, parameters, ...)
+mcp2cli --mcp https://mcp.example.com/sse --list --json
+mcp2cli --spec ./openapi.json --list --json
+mcp2cli --graphql https://api.example.com/graphql --list --json
+
+# --list --json --compact emits a JSON array of names only
+mcp2cli --mcp https://mcp.example.com/sse --list --json --compact
+
+# MCP tool calls emit the FULL CallToolResult envelope — including
+# structuredContent and isError, not just the flattened text. This surfaces the
+# machine-readable result that modern MCP tools put in structuredContent.
+mcp2cli --mcp https://mcp.example.com/sse --json search --query "test"
+# { "content": [...], "structuredContent": {...}, "isError": false }
+
+# OpenAPI / GraphQL calls emit the response as JSON (non-JSON bodies become a JSON string)
+mcp2cli --spec ./openapi.json --json list-pets
+mcp2cli --graphql https://api.example.com/graphql --json users
+```
+
+`--json` takes precedence over `--raw` and `--toon` (both of which can produce
+non-JSON), so it always wins — that is what makes it a reliable "force JSON" switch.
+Indentation follows the usual rule: pretty on a TTY or with `--pretty`, compact when piped.
+
 ### Output control
 
 ```bash
@@ -308,6 +338,9 @@ Options:
   --fields FIELDS         Override GraphQL selection set (e.g. "id name email")
   --pretty                Pretty-print JSON output
   --raw                   Print raw response body
+  --json                  Force valid JSON output for every command (--list and tool
+                          calls). MCP calls emit the full result envelope including
+                          structuredContent. Takes precedence over --raw and --toon.
   --toon                  Encode output as TOON (token-efficient for LLMs)
   --head N                Limit output to first N records (arrays)
   --version               Show version

{mcp2cli-3.0.3 → mcp2cli-3.2.0}/README.md

@@ -217,6 +217,36 @@ mcp2cli @myapi --list --sort alpha
 
 When usage data exists for a source, `--list` defaults to sorting by call frequency. Otherwise insertion order is preserved. Usage data is stored in `~/.cache/mcp2cli/usage.json`.
 
+### JSON output
+
+`--json` forces **valid JSON on stdout for every command**, in every mode. It is the
+machine-readable counterpart to the human-formatted default output, designed for LLM
+agents and scripts that need to parse results reliably.
+
+```bash
+# --list emits a JSON array of command objects (name, description, parameters, ...)
+mcp2cli --mcp https://mcp.example.com/sse --list --json
+mcp2cli --spec ./openapi.json --list --json
+mcp2cli --graphql https://api.example.com/graphql --list --json
+
+# --list --json --compact emits a JSON array of names only
+mcp2cli --mcp https://mcp.example.com/sse --list --json --compact
+
+# MCP tool calls emit the FULL CallToolResult envelope — including
+# structuredContent and isError, not just the flattened text. This surfaces the
+# machine-readable result that modern MCP tools put in structuredContent.
+mcp2cli --mcp https://mcp.example.com/sse --json search --query "test"
+# { "content": [...], "structuredContent": {...}, "isError": false }
+
+# OpenAPI / GraphQL calls emit the response as JSON (non-JSON bodies become a JSON string)
+mcp2cli --spec ./openapi.json --json list-pets
+mcp2cli --graphql https://api.example.com/graphql --json users
+```
+
+`--json` takes precedence over `--raw` and `--toon` (both of which can produce
+non-JSON), so it always wins — that is what makes it a reliable "force JSON" switch.
+Indentation follows the usual rule: pretty on a TTY or with `--pretty`, compact when piped.
+
 ### Output control
 
 ```bash
@@ -289,6 +319,9 @@ Options:
   --fields FIELDS         Override GraphQL selection set (e.g. "id name email")
   --pretty                Pretty-print JSON output
   --raw                   Print raw response body
+  --json                  Force valid JSON output for every command (--list and tool
+                          calls). MCP calls emit the full result envelope including
+                          structuredContent. Takes precedence over --raw and --toon.
   --toon                  Encode output as TOON (token-efficient for LLMs)
   --head N                Limit output to first N records (arrays)
   --version               Show version

{mcp2cli-3.0.3 → mcp2cli-3.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp2cli"
-version = "3.0.3"
+version = "3.2.0"
 description = "Turn any MCP server or OpenAPI spec into a CLI"
 readme = "README.md"
 license = "MIT"

{mcp2cli-3.0.3 → mcp2cli-3.2.0}/src/mcp2cli/__init__.py

@@ -277,6 +277,14 @@ def _apply_head(data, n: int):
     return data
 
 
+def _emit_json(data, pretty: bool = False) -> None:
+    """Print *data* as JSON. Indented when *pretty* or stdout is a TTY, else compact."""
+    if pretty or sys.stdout.isatty():
+        print(json.dumps(data, indent=2))
+    else:
+        print(json.dumps(data))
+
+
 def output_result(
     data,
     *,
@@ -284,7 +292,22 @@ def output_result(
     raw: bool = False,
     toon: bool = False,
     head: int | None = None,
+    json_output: bool = False,
 ):
+    # --json forces valid JSON for every command, overriding --raw and --toon
+    # (both of which can produce non-JSON). Strings that contain JSON are
+    # unwrapped; everything else is emitted as a JSON value (e.g. a string
+    # literal for plain prose), guaranteeing parseable stdout.
+    if json_output:
+        if isinstance(data, str):
+            try:
+                data = json.loads(data)
+            except (json.JSONDecodeError, TypeError, ValueError):
+                pass
+        if head is not None:
+            data = _apply_head(data, head)
+        _emit_json(data, pretty)
+        return
     if raw:
         if isinstance(data, str):
             print(data)
@@ -310,10 +333,53 @@ def output_result(
             file=sys.stderr,
         )
         # Fall through to normal output
-    if pretty or sys.stdout.isatty():
-        print(json.dumps(data, indent=2))
+    _emit_json(data, pretty)
+
+
+def _python_type_name(t: type | None) -> str:
+    """Human/JSON-friendly type label for a ParamDef.python_type (None = boolean flag)."""
+    if t is None:
+        return "boolean"
+    return getattr(t, "__name__", str(t))
+
+
+def _param_to_dict(p: "ParamDef") -> dict:
+    d = {
+        "name": p.name,
+        "type": _python_type_name(p.python_type),
+        "required": p.required,
+        "description": p.description,
+        "location": p.location,
+    }
+    if p.choices:
+        d["choices"] = p.choices
+    return d
+
+
+def command_to_dict(cmd: "CommandDef") -> dict:
+    """Serialize a CommandDef to a JSON-friendly dict for `--list --json`."""
+    d: dict = {"name": cmd.name, "description": cmd.description or ""}
+    if cmd.method:
+        d["method"] = cmd.method.upper()
+    if cmd.path:
+        d["path"] = cmd.path
+    if cmd.tool_name:
+        d["toolName"] = cmd.tool_name
+    if cmd.graphql_operation_type:
+        d["operationType"] = cmd.graphql_operation_type
+    d["parameters"] = [_param_to_dict(p) for p in cmd.params]
+    return d
+
+
+def print_commands_json(
+    commands: "list[CommandDef]", compact: bool = False, pretty: bool = False
+) -> None:
+    """Emit a command list as JSON (array of objects, or names when *compact*)."""
+    if compact:
+        payload = [cmd.name for cmd in commands]
     else:
-        print(json.dumps(data))
+        payload = [command_to_dict(cmd) for cmd in commands]
+    _emit_json(payload, pretty)
 
 
 def _build_http_headers(auth_headers: list[tuple[str, str]], multipart: bool = False) -> dict[str, str]:
@@ -469,13 +535,21 @@ OAUTH_DIR = CACHE_DIR / "oauth"
 
 
 class FileTokenStorage:
-    """File-based token storage for OAuth tokens and client info."""
+    """File-based token storage for OAuth tokens and client info.
+
+    Persists an absolute ``expires_at`` timestamp alongside ``tokens.json``
+    (in ``tokens_meta.json``) so that on a fresh process the SDK can tell an
+    access token has expired and trigger a refresh, rather than blindly
+    re-sending the stale Bearer and falling through to a full re-auth that
+    reuses a possibly-forgotten DCR client_id (issue #50).
+    """
 
     def __init__(self, server_url: str):
         key = hashlib.sha256(server_url.encode()).hexdigest()[:16]
         self._dir = OAUTH_DIR / key
         self._dir.mkdir(parents=True, exist_ok=True)
         self._tokens_path = self._dir / "tokens.json"
+        self._tokens_meta_path = self._dir / "tokens_meta.json"
         self._client_path = self._dir / "client.json"
 
     async def get_tokens(self):
@@ -491,6 +565,50 @@ class FileTokenStorage:
 
     async def set_tokens(self, tokens) -> None:
         self._tokens_path.write_text(tokens.model_dump_json())
+        # Persist an absolute expiry timestamp so we can detect on a
+        # later process start that the access token has expired.
+        if tokens.expires_in is not None:
+            try:
+                meta = {"expires_at": time.time() + float(tokens.expires_in)}
+                self._tokens_meta_path.write_text(json.dumps(meta))
+            except Exception:
+                pass
+        else:
+            # No expiry info; drop any stale meta sidecar.
+            try:
+                self._tokens_meta_path.unlink()
+            except FileNotFoundError:
+                pass
+
+    def get_expires_at(self) -> float | None:
+        """Return the absolute expiry timestamp persisted alongside tokens.
+
+        Returns None when no sidecar exists (older caches or tokens without
+        an ``expires_in`` value).
+        """
+        if not self._tokens_meta_path.exists():
+            return None
+        try:
+            data = json.loads(self._tokens_meta_path.read_text())
+            value = data.get("expires_at")
+            return float(value) if value is not None else None
+        except Exception:
+            return None
+
+    def clear_tokens(self) -> None:
+        """Remove persisted tokens and their expiry sidecar."""
+        for path in (self._tokens_path, self._tokens_meta_path):
+            try:
+                path.unlink()
+            except FileNotFoundError:
+                pass
+
+    def clear_client_info(self) -> None:
+        """Remove persisted DCR client info so a fresh registration runs."""
+        try:
+            self._client_path.unlink()
+        except FileNotFoundError:
+            pass
 
     async def get_client_info(self):
         from mcp.shared.auth import OAuthClientInformationFull
@@ -601,6 +719,53 @@ def build_oauth_provider(
     from mcp.client.auth.oauth2 import OAuthClientProvider
     from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata
 
+    class _RobustOAuthClientProvider(OAuthClientProvider):
+        """OAuthClientProvider with cross-process expiry + stale-DCR recovery.
+
+        Fixes for issue #50 — Atlassian "Internal Server Error" on next-day
+        OAuth calls. The upstream SDK has two gaps when state is reloaded
+        from disk in a new process:
+
+        1. ``_initialize`` reloads ``current_tokens`` from storage but never
+           recomputes ``token_expiry_time`` from the bare ``OAuthToken``
+           dump (which only carries ``expires_in``). An expired access
+           token therefore looks valid, is sent, and only the 401 fallback
+           runs — skipping the refresh-token grant entirely.
+
+        2. The 401 fallback re-uses the cached DCR ``client_id`` because
+           ``client_info`` was reloaded from disk; if the auth server has
+           since forgotten that registration, ``/authorize`` returns an
+           opaque 500 page rather than a clean ``invalid_client`` redirect
+           and the CLI hangs on the callback.
+
+        We patch both by restoring ``token_expiry_time`` from a sidecar
+        we persist in :class:`FileTokenStorage`, and by wiping the cached
+        ``client_info`` from disk and memory whenever a refresh fails so
+        the subsequent re-auth performs fresh Dynamic Client Registration.
+        """
+
+        async def _initialize(self) -> None:
+            await super()._initialize()
+            storage = self.context.storage
+            if isinstance(storage, FileTokenStorage) and self.context.current_tokens:
+                expires_at = storage.get_expires_at()
+                if expires_at is not None:
+                    self.context.token_expiry_time = expires_at
+
+        async def _handle_refresh_response(self, response) -> bool:
+            ok = await super()._handle_refresh_response(response)
+            if not ok:
+                # Refresh failed. The cached DCR client_id may have been
+                # forgotten by the auth server too; clear it so the
+                # subsequent 401 fallback performs a fresh registration
+                # instead of /authorize?client_id=<stale> → opaque 500.
+                self.context.client_info = None
+                storage = self.context.storage
+                if isinstance(storage, FileTokenStorage):
+                    storage.clear_client_info()
+                    storage.clear_tokens()
+            return ok
+
     _LOOPBACK_HOSTS = {"localhost", "127.0.0.1", "::1"}
 
     if redirect_uri is not None:
@@ -700,7 +865,7 @@ def build_oauth_provider(
             raise RuntimeError("No authorization code received")
         return (_CallbackHandler.auth_code, _CallbackHandler.state)
 
-    return OAuthClientProvider(
+    return _RobustOAuthClientProvider(
         server_url=server_url,
         client_metadata=client_metadata,
         storage=storage,
@@ -1308,10 +1473,16 @@ def list_graphql_commands(
     source_hash: str = "",
     sort_mode: str | None = None,
     top: int | None = None,
+    json_output: bool = False,
+    pretty: bool = False,
 ):
     """Group commands by operation type and print."""
     commands = _apply_list_options(commands, source_hash, sort_mode, top)
 
+    if json_output:
+        print_commands_json(commands, compact=compact, pretty=pretty)
+        return
+
     if compact:
         print(" ".join(cmd.name for cmd in commands))
         return
@@ -1403,6 +1574,7 @@ def execute_graphql(
     fields_override: str | None = None,
     oauth_provider: "httpx.Auth | None" = None,
     head: int | None = None,
+    json_output: bool = False,
 ):
     """Build and execute a GraphQL query/mutation."""
     document, variables, field_name = _build_graphql_document(
@@ -1426,13 +1598,13 @@ def execute_graphql(
             print(f"GraphQL error: {msgs}", file=sys.stderr)
             sys.exit(1)
         # Partial errors — include them in output
-        output_result(result, pretty=pretty, raw=raw, toon=toon, head=head)
+        output_result(result, pretty=pretty, raw=raw, toon=toon, head=head, json_output=json_output)
         return
 
     data = result.get("data", {})
     # Extract the specific field's data
     field_data = data.get(field_name, data)
-    output_result(field_data, pretty=pretty, raw=raw, toon=toon, head=head)
+    output_result(field_data, pretty=pretty, raw=raw, toon=toon, head=head, json_output=json_output)
 
 
 def handle_graphql(
@@ -1453,6 +1625,7 @@ def handle_graphql(
     sort_mode: str | None = None,
     top: int | None = None,
     compact: bool = False,
+    json_output: bool = False,
 ):
     """Top-level handler for --graphql mode."""
     src_hash = _source_hash_for(url)
@@ -1462,6 +1635,7 @@ def handle_graphql(
     list_kwargs = dict(
         verbose=verbose, compact=compact,
         source_hash=src_hash, sort_mode=sort_mode, top=top,
+        json_output=json_output, pretty=pretty,
     )
 
     if list_mode:
@@ -1469,10 +1643,10 @@ def handle_graphql(
         return
 
     if not remaining:
-        if not compact:
+        if not compact and not json_output:
             print("Available operations:")
         list_graphql_commands(commands, **list_kwargs)
-        if not compact:
+        if not compact and not json_output:
             print("\nUse --list for the same output, or provide a subcommand.")
         return
 
@@ -1488,6 +1662,7 @@ def handle_graphql(
     execute_graphql(
         args, cmd, url, schema, auth_headers, pretty, raw, toon=toon,
         fields_override=fields_override, oauth_provider=oauth_provider,
+        json_output=json_output,
     )
 
     # Record usage after successful execution
@@ -1941,9 +2116,15 @@ def list_openapi_commands(
     source_hash: str = "",
     sort_mode: str | None = None,
     top: int | None = None,
+    json_output: bool = False,
+    pretty: bool = False,
 ):
     commands = _apply_list_options(commands, source_hash, sort_mode, top)
 
+    if json_output:
+        print_commands_json(commands, compact=compact, pretty=pretty)
+        return
+
     if compact:
         print(" ".join(cmd.name for cmd in commands))
         return
@@ -1974,9 +2155,15 @@ def list_mcp_commands(
     source_hash: str = "",
     sort_mode: str | None = None,
     top: int | None = None,
+    json_output: bool = False,
+    pretty: bool = False,
 ):
     commands = _apply_list_options(commands, source_hash, sort_mode, top)
 
+    if json_output:
+        print_commands_json(commands, compact=compact, pretty=pretty)
+        return
+
     if compact:
         print(" ".join(cmd.name for cmd in commands))
         return
@@ -2087,6 +2274,7 @@ def execute_openapi(
     toon: bool = False,
     oauth_provider: "httpx.Auth | None" = None,
     head: int | None = None,
+    json_output: bool = False,
 ):
     path, query_params, extra_headers, body, files = _collect_openapi_params(cmd, args)
     url = base_url.rstrip("/") + path
@@ -2128,6 +2316,14 @@ def execute_openapi(
             for _, file_tuple in files.items():
                 file_tuple[1].close()
 
+    if json_output:
+        try:
+            data = resp.json()
+        except Exception:
+            data = resp.text
+        output_result(data, pretty=pretty, head=head, json_output=True)
+        return
+
     if raw:
         sys.stdout.buffer.write(resp.content)
         return
@@ -2172,6 +2368,7 @@ def run_mcp_http(
     top: int | None = None,
     compact: bool = False,
     source_hash: str = "",
+    json_output: bool = False,
 ):
     extra = dict(
         resource_action=resource_action,
@@ -2186,6 +2383,7 @@ def run_mcp_http(
         top=top,
         compact=compact,
         source_hash=source_hash,
+        json_output=json_output,
     )
 
     async def _run():
@@ -2275,6 +2473,7 @@ def run_mcp_stdio(
     top: int | None = None,
     compact: bool = False,
     source_hash: str = "",
+    json_output: bool = False,
 ):
     extra = dict(
         resource_action=resource_action,
@@ -2289,6 +2488,7 @@ def run_mcp_stdio(
         top=top,
         compact=compact,
         source_hash=source_hash,
+        json_output=json_output,
     )
 
     import anyio
@@ -2344,11 +2544,13 @@ async def _mcp_session(
     top: int | None = None,
     compact: bool = False,
     source_hash: str = "",
+    json_output: bool = False,
 ):
     # Handle resource operations
     if resource_action:
         await _handle_resources(
             session, resource_action, resource_uri, pretty, raw, toon, head=head,
+            json_output=json_output,
         )
         return
 
@@ -2356,13 +2558,14 @@ async def _mcp_session(
     if prompt_action:
         await _handle_prompts(
             session, prompt_action, prompt_name, prompt_arguments,
-            pretty, raw, toon, head=head,
+            pretty, raw, toon, head=head, json_output=json_output,
         )
         return
 
     list_kwargs = dict(
         verbose=verbose, compact=compact,
         source_hash=source_hash, sort_mode=sort_mode, top=top,
+        json_output=json_output, pretty=pretty,
     )
 
     if list_mode:
@@ -2379,12 +2582,15 @@ async def _mcp_session(
         if search_pattern:
             commands = _filter_commands(commands, search_pattern)
             if not commands:
-                print(f"\nNo tools matching '{search_pattern}'.")
+                if json_output:
+                    list_mcp_commands(commands, **list_kwargs)
+                else:
+                    print(f"\nNo tools matching '{search_pattern}'.")
                 return
-            if not compact:
+            if not compact and not json_output:
                 print(f"\nTools matching '{search_pattern}':")
         else:
-            if not compact:
+            if not compact and not json_output:
                 print("\nAvailable tools:")
         list_mcp_commands(commands, **list_kwargs)
         return
@@ -2398,6 +2604,12 @@ async def _mcp_session(
 
     result = await session.call_tool(tool_name, arguments or {})
 
+    if json_output:
+        # Emit the full MCP CallToolResult envelope (content, structuredContent,
+        # isError) using the SDK's own serializer — 100% MCP-compatible.
+        output_result(result.model_dump(mode="json"), pretty=pretty, head=head, json_output=True)
+        return
+
     text = _extract_content_parts(result.content)
     output_result(text, pretty=pretty, raw=raw, toon=toon, head=head)
 
@@ -2415,8 +2627,9 @@ async def _handle_resources(
     raw: bool,
     toon: bool,
     head: int | None = None,
+    json_output: bool = False,
 ):
-    _out = dict(pretty=pretty, raw=raw, toon=toon, head=head)
+    _out = dict(pretty=pretty, raw=raw, toon=toon, head=head, json_output=json_output)
     if action == "list":
         result = await session.list_resources()
         data = [
@@ -2469,8 +2682,9 @@ async def _handle_prompts(
     raw: bool,
     toon: bool,
     head: int | None = None,
+    json_output: bool = False,
 ):
-    _out = dict(pretty=pretty, raw=raw, toon=toon, head=head)
+    _out = dict(pretty=pretty, raw=raw, toon=toon, head=head, json_output=json_output)
     if action == "list":
         result = await session.list_prompts()
         data = [
@@ -3011,6 +3225,7 @@ def handle_mcp(
     sort_mode: str | None = None,
     top: int | None = None,
     compact: bool = False,
+    json_output: bool = False,
 ):
     # Build a config dict for cache key generation (future-proof)
     config_for_cache = {
@@ -3033,6 +3248,7 @@ def handle_mcp(
             prompt_name=prompt_name,
             prompt_arguments=prompt_arguments,
             head=head,
+            json_output=json_output,
         )
         _dispatch_mcp_call(
             source, is_stdio, auth_headers, env_vars,
@@ -3045,6 +3261,7 @@ def handle_mcp(
     list_kwargs = dict(
         verbose=verbose, compact=compact,
         source_hash=src_hash, sort_mode=sort_mode, top=top,
+        json_output=json_output, pretty=pretty,
     )
 
     if list_mode:
@@ -3058,7 +3275,7 @@ def handle_mcp(
             commands = filter_commands(
                 commands, bake_config.include, bake_config.exclude, bake_config.methods,
             )
-            if not compact:
+            if not compact and not json_output:
                 print("\nAvailable tools:")
             list_mcp_commands(commands, **list_kwargs)
             return
@@ -3070,6 +3287,7 @@ def handle_mcp(
             verbose=verbose,
             sort_mode=sort_mode, top=top, compact=compact,
             source_hash=src_hash,
+            json_output=json_output,
         )
         return
 
@@ -3086,10 +3304,10 @@ def handle_mcp(
         )
 
     if not remaining:
-        if not compact:
+        if not compact and not json_output:
             print("Available tools:")
         list_mcp_commands(commands, **list_kwargs)
-        if not compact:
+        if not compact and not json_output:
             print("\nUse --list for the same output, or provide a subcommand.")
         return
 
@@ -3116,6 +3334,7 @@ def handle_mcp(
         source, is_stdio, auth_headers, env_vars,
         cmd.tool_name, arguments, False, pretty, raw, key, ttl, refresh,
         toon=toon, transport=transport, oauth_provider=oauth_provider,
+        json_output=json_output,
     )
 
     # Record usage after successful execution
@@ -3333,6 +3552,16 @@ def _build_main_parser() -> argparse.ArgumentParser:
     )
     pre.add_argument("--pretty", action="store_true", help="Pretty-print JSON output")
     pre.add_argument("--raw", action="store_true", help="Print raw response body")
+    pre.add_argument(
+        "--json",
+        action="store_true",
+        dest="json_output",
+        help=(
+            "Force valid JSON output for every command. --list emits a JSON array of "
+            "commands; MCP tool calls emit the full result envelope including "
+            "structuredContent and isError. Takes precedence over --raw and --toon."
+        ),
+    )
     pre.add_argument(
         "--toon",
         action="store_true",
@@ -3594,32 +3823,28 @@ def _handle_session_operations(
 
     # --- Session client mode ---
     sess_name = pre_args.session
+    _sess_out = dict(
+        pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon,
+        json_output=pre_args.json_output,
+    )
 
     if pre_args.list_resources:
         result = _session_request(sess_name, "list_resources")
-        output_result(
-            result, pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon,
-        )
+        output_result(result, **_sess_out)
         return True
     if pre_args.list_resource_templates:
         result = _session_request(sess_name, "list_resource_templates")
-        output_result(
-            result, pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon,
-        )
+        output_result(result, **_sess_out)
         return True
     if pre_args.read_resource:
         result = _session_request(
             sess_name, "read_resource", {"uri": pre_args.read_resource}
         )
-        output_result(
-            result, pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon,
-        )
+        output_result(result, **_sess_out)
         return True
     if pre_args.list_prompts:
         result = _session_request(sess_name, "list_prompts")
-        output_result(
-            result, pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon,
-        )
+        output_result(result, **_sess_out)
         return True
     if pre_args.get_prompt:
         p_args = {}
@@ -3632,9 +3857,7 @@ def _handle_session_operations(
             "get_prompt",
             {"name": pre_args.get_prompt, "arguments": p_args},
         )
-        output_result(
-            result, pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon,
-        )
+        output_result(result, **_sess_out)
         return True
     if pre_args.list_commands:
         result = _session_request(sess_name, "list_tools")
@@ -3642,21 +3865,36 @@ def _handle_session_operations(
         if search_pattern:
             commands = _filter_commands(commands, search_pattern)
             if not commands:
-                print(f"\nNo tools matching '{search_pattern}'.")
+                if pre_args.json_output:
+                    list_mcp_commands(
+                        commands, verbose=pre_args.verbose,
+                        json_output=True, pretty=pre_args.pretty,
+                    )
+                else:
+                    print(f"\nNo tools matching '{search_pattern}'.")
                 return True
-            print(f"\nTools matching '{search_pattern}':")
-        else:
+            if not pre_args.json_output:
+                print(f"\nTools matching '{search_pattern}':")
+        elif not pre_args.json_output:
             print("\nAvailable tools:")
-        list_mcp_commands(commands, verbose=pre_args.verbose)
+        list_mcp_commands(
+            commands, verbose=pre_args.verbose,
+            json_output=pre_args.json_output, pretty=pre_args.pretty,
+        )
         return True
 
     # Tool call via session
     if not remaining:
         result = _session_request(sess_name, "list_tools")
         commands = extract_mcp_commands(result)
-        print("Available tools:")
-        list_mcp_commands(commands, verbose=pre_args.verbose)
-        print("\nUse --list for the same output, or provide a subcommand.")
+        if not pre_args.json_output:
+            print("Available tools:")
+        list_mcp_commands(
+            commands, verbose=pre_args.verbose,
+            json_output=pre_args.json_output, pretty=pre_args.pretty,
+        )
+        if not pre_args.json_output:
+            print("\nUse --list for the same output, or provide a subcommand.")
         return True
 
     tools = _session_request(sess_name, "list_tools")
@@ -3682,9 +3920,7 @@ def _handle_session_operations(
     result = _session_request(
         sess_name, "call_tool", {"name": cmd.tool_name, "arguments": arguments}
     )
-    output_result(
-        result, pretty=pre_args.pretty, raw=pre_args.raw, toon=pre_args.toon
-    )
+    output_result(result, **_sess_out)
     return True
 
 
@@ -3749,15 +3985,19 @@ def _handle_openapi_mode(
     list_kwargs = dict(
         verbose=pre_args.verbose, compact=pre_args.compact,
         source_hash=src_hash, sort_mode=pre_args.sort_mode, top=pre_args.top,
+        json_output=pre_args.json_output, pretty=pre_args.pretty,
     )
 
     if pre_args.list_commands:
         if search_pattern:
             commands = _filter_commands(commands, search_pattern)
             if not commands:
-                print(f"\nNo tools matching '{search_pattern}'.")
+                if not pre_args.json_output:
+                    print(f"\nNo tools matching '{search_pattern}'.")
+                else:
+                    list_openapi_commands(commands, **list_kwargs)
                 return
-            if not pre_args.compact:
+            if not pre_args.compact and not pre_args.json_output:
                 print(f"\nTools matching '{search_pattern}':")
         list_openapi_commands(commands, **list_kwargs)
         return
@@ -3801,7 +4041,7 @@ def _handle_openapi_mode(
     execute_openapi(
         args, cmd, base_url, auth_headers,
         pre_args.pretty, pre_args.raw, toon=pre_args.toon,
-        oauth_provider=oauth_provider,
+        oauth_provider=oauth_provider, json_output=pre_args.json_output,
     )
 
     # Record usage after successful execution
@@ -3861,6 +4101,7 @@ def _main_impl(argv: list[str], bake_config: BakeConfig | None = None):
             sort_mode=pre_args.sort_mode,
             top=pre_args.top,
             compact=pre_args.compact,
+            json_output=pre_args.json_output,
         )
         return
 
@@ -3895,6 +4136,7 @@ def _main_impl(argv: list[str], bake_config: BakeConfig | None = None):
             sort_mode=pre_args.sort_mode,
             top=pre_args.top,
             compact=pre_args.compact,
+            json_output=pre_args.json_output,
         )
         return