globus-cli 3.41.0__tar.gz → 3.43.0__tar.gz

{globus_cli-3.41.0 → globus_cli-3.43.0}/PKG-INFO

@@ -1,29 +1,30 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: globus-cli
-Version: 3.41.0
+Version: 3.43.0
 Summary: Globus CLI
 Keywords: globus,cli,command line
 Author-email: Stephen Rosen <sirosen@globus.org>
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-Expression: Apache-2.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 License-File: LICENSE
-Requires-Dist: globus-sdk==4.3.0
-Requires-Dist: click>=8.1.4,<8.4
-Requires-Dist: jmespath==1.0.1
+Requires-Dist: globus-sdk==4.9.0
+Requires-Dist: click>=8.4,<8.5
+Requires-Dist: jmespath==1.1.0
 Requires-Dist: packaging>=17.0
 Requires-Dist: typing_extensions>=4.0;python_version<'3.11'
-Requires-Dist: requests>=2.32.3,<3.0.0
+Requires-Dist: requests>=2.34.2,<3.0.0
 Project-URL: homepage, https://github.com/globus/globus-cli
+Import-Name: globus_cli
 
 Globus CLI
 ==========

{globus_cli-3.41.0 → globus_cli-3.43.0}/changelog.adoc

@@ -2,6 +2,52 @@
 
 // scriv-insert-here
 
+== 3.43.0 (2026-08-12)
+
+Bugfixes:
+
+* Fixed a bug in which terminal device (TTY) detection ran even when
+  `GLOBUS_CLI_FOLD_TABLES=1` is set.
+  Setting the variable to true now forces use of folded tables.
+  Non-TTY output devices will be detected as having a fixed width of 80
+  characters.
+
+* Fixed `globus get-identities` to lowercase usernames and IDs before
+  comparisons for normal text output.
+
+Enhancements:
+
+* Folded table output will now have bolded headers in interactive terminals.
+
+* Add `globus flows web-input` subcommands to interact with Web Inputs.
+
+== 3.42.0 (2026-06-10)
+
+Bugfixes:
+
+* `globus api transfer` no longer prepends `/v0.10/` to `/v2/` paths
+
+Enhancements:
+
+* Added Domain field to default output of `globus endpoint search` and `globus endpoint show`
+
+* Added `globus streams tunnel events` command to show tunnel events
+
+* When using table output on narrow terminals, the Globus CLI will now stack
+  table elements in a new "folded table" layout. This behavior is only used
+  when the output device is a TTY. To disable the new output altogether, users
+  can set `GLOBUS_CLI_FOLD_TABLES=0`.
+
+* Added Subscription ID to the text output of `globus group list`
+
+* Added `globus flows registered-api show` command to display details of a registered API
+
+* Added `globus flows registered-api list` command to list registered APIs
+
+Other:
+
+* Removed support for Python 3.9 .
+
 == 3.41.0 (2026-01-14)
 
 Bugfixes:

{globus_cli-3.41.0 → globus_cli-3.43.0}/pyproject.toml

@@ -20,22 +20,24 @@ classifiers = [
     "Intended Audience :: Developers",
     "Operating System :: POSIX",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
-    "globus-sdk==4.3.0",
-    "click>=8.1.4,<8.4",
-    "jmespath==1.0.1",
+    "globus-sdk==4.9.0",
+    # NOTE: `click` does not use semver; minor releases are expected to contain
+    #       minor breaking changes
+    "click>=8.4,<8.5",
+    "jmespath==1.1.0",
     "packaging>=17.0",
     "typing_extensions>=4.0;python_version<'3.11'",
     # these are dependencies of the SDK, but they are used directly in the CLI
     # declare them here in case the underlying lib ever changes
-    "requests>=2.32.3,<3.0.0",
+    "requests>=2.34.2,<3.0.0",
 ]
 dynamic = ["version"]
 
@@ -61,21 +63,21 @@ test = [
 ]
 test-mindeps = [
     {include-group = "test"},
-    "click==8.1.8",
-    "requests==2.32.4",
+    "click==8.4.0",
+    "requests==2.34.2",
     "pyjwt==2.0.0",
     "cryptography==3.3.1",
     "packaging==17.0",
     "typing_extensions==4.0",
 ]
 typing = [
-    "mypy==1.19.1",
+    "mypy==2.1.0",
     "types-jwt",
     "types-requests",
     "types-jmespath",
 ]
 check-project-metadata = [
-    "mddj==0.4.2",
+    "mddj==0.6.0",
     {include-group = "yaml"},
     "build",
     "twine",

{globus_cli-3.41.0 → globus_cli-3.43.0}/src/globus_cli/commands/api.py

@@ -10,7 +10,6 @@ import globus_sdk
 from globus_sdk.scopes import ScopeParser
 
 from globus_cli import termio, version
-from globus_cli._click_compat import shim_get_metavar
 from globus_cli.login_manager import LoginManager, is_client_login
 from globus_cli.login_manager.scopes import CLI_SCOPE_REQUIREMENTS
 from globus_cli.parsing import command, endpoint_id_arg, group, mutex_option_group
@@ -20,8 +19,7 @@ from globus_cli.types import AnyCommand, ServiceNameLiteral
 C = t.TypeVar("C", bound=AnyCommand)
 
 
-class QueryParamType(click.ParamType):
-    @shim_get_metavar
+class QueryParamType(click.ParamType[tuple[str, str] | None]):
     def get_metavar(self, param: click.Parameter, ctx: click.Context) -> str:
         return "Key=Value"
 
@@ -33,21 +31,17 @@ class QueryParamType(click.ParamType):
 
     def convert(
         self,
-        value: str | None,
+        value: str,
         param: click.Parameter | None,
         ctx: click.Context | None,
     ) -> tuple[str, str] | None:
-        value = super().convert(value, param, ctx)
-        if value is None:
-            return None
         if "=" not in value:
             self.fail("invalid query param", param=param, ctx=ctx)
         left, right = value.split("=", 1)
         return (left, right)
 
 
-class HeaderParamType(click.ParamType):
-    @shim_get_metavar
+class HeaderParamType(click.ParamType[tuple[str, str] | None]):
     def get_metavar(self, param: click.Parameter, ctx: click.Context) -> str:
         return "Key:Value"
 
@@ -59,13 +53,10 @@ class HeaderParamType(click.ParamType):
 
     def convert(
         self,
-        value: str | None,
+        value: str,
         param: click.Parameter | None,
         ctx: click.Context | None,
     ) -> tuple[str, str] | None:
-        value = super().convert(value, param, ctx)
-        if value is None:
-            return None
         if ":" not in value:
             self.fail("invalid header param", param=param, ctx=ctx)
         left, right = value.split(":", 1)
@@ -172,7 +163,7 @@ def _get_url(service_name: str) -> str:
         "search": "https://search.api.globus.org/",
         "transfer": "https://transfer.api.globus.org/v0.10/",
         "timers": "https://timer.automate.globus.org/",
-        "gcs": "https://$GCS_MANAGER/",
+        "gcs": "https://GCS_MANAGER/",
     }[service_name]
 
 
@@ -324,7 +315,9 @@ def _execute_service_command(
         if path.startswith("/"):
             path = path[1:]
         path = f"/v2/{path}"
-    if isinstance(client, globus_sdk.TransferClient) and not path.startswith("/v0.10/"):
+    if isinstance(client, globus_sdk.TransferClient) and not (
+        path.startswith(("/v0.10/", "/v2/"))
+    ):
         if path.startswith("/"):
             path = path[1:]
         path = f"/v0.10/{path}"
@@ -379,16 +372,26 @@ def build_command(
     )
     hidden: bool = command_name == "timer"
 
+    example_command_name: str = command_name
+    helptext_epilog: str = ""
+    service_title: str = service_name.title()
+
+    if command_name == "gcs":
+        service_title = "GCS"
+        example_command_name = "gcs ENDPOINT_ID"
+        helptext_epilog = "\nWhere GCS_MANAGER is looked up from ENDPOINT_ID."
+
     helptext = f"""\
-Make API calls to Globus {service_name.title()}
+Make API calls to Globus {service_title}
 
 The arguments are an HTTP method name and a path within the service to which the request
 should be made. The path will be joined with the known service URL.
 For example, a call of
 
-    globus api {command_name} GET /foo/bar
+    globus api {example_command_name} GET /foo/bar
 
 sends a 'GET' request to `{_get_url(service_name)}foo/bar`
+{helptext_epilog}
 """
 
     if service_name != "gcs":

{globus_cli-3.41.0 → globus_cli-3.43.0}/src/globus_cli/commands/collection/list.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import sys
 import typing as t
 import uuid
 
@@ -12,22 +11,8 @@ from globus_cli.parsing import command, endpoint_id_arg
 from globus_cli.termio import Field, display, formatters
 from globus_cli.utils import PagingWrapper
 
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
 
-# until our minimum click version is 8.2.0+ , we need to handle the fact that
-# click.Choice became a generic in 8.2.0
-# we cannot leave it without a defined type parameter, as we have
-# "no-any-generics" set for mypy
-if t.TYPE_CHECKING:
-    ChoiceType: TypeAlias = click.Choice[str]
-else:
-    ChoiceType = click.Choice
-
-
-class ChoiceSlugified(ChoiceType):
+class ChoiceSlugified(click.Choice[str]):
     """
     Allow either hyphens or underscores, e.g. both 'mapped-collections' or
     'mapped_collections'
@@ -37,10 +22,8 @@ class ChoiceSlugified(ChoiceType):
         return t.cast(type, t.Literal[tuple(self._slugify(c) for c in self.choices)])
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self, value: str, param: click.Parameter | None, ctx: click.Context | None
     ) -> t.Any:
-        if value is None:
-            return None
         return self._slugify(super().convert(value.replace("_", "-"), param, ctx))
 
     def _slugify(self, value: str) -> str:

{globus_cli-3.41.0 → globus_cli-3.43.0}/src/globus_cli/commands/endpoint/set_subscription_id.py

@@ -9,7 +9,7 @@ from globus_cli.parsing import command, endpoint_id_arg
 from globus_cli.termio import display
 
 
-class SubscriptionIdType(click.ParamType):
+class SubscriptionIdType(click.ParamType[str]):
     def convert(
         self, value: str, param: click.Parameter | None, ctx: click.Context | None
     ) -> str:

{globus_cli-3.41.0 → globus_cli-3.43.0}/src/globus_cli/commands/endpoint/show.py

@@ -5,12 +5,14 @@ import click
 from globus_cli.endpointish import Endpointish
 from globus_cli.login_manager import LoginManager
 from globus_cli.parsing import command, endpoint_id_arg
+from globus_cli.services.transfer import DOMAIN_FIELD
 from globus_cli.termio import Field, display, formatters
 
 STANDARD_FIELDS = [
     Field("Display Name", "display_name"),
     Field("ID", "id"),
     Field("Owner", "owner_string"),
+    DOMAIN_FIELD,
     Field("Description", "description", wrap_enabled=True),
     Field("Shareable", "shareable"),
     Field("Keywords", "keywords"),

{globus_cli-3.41.0 → globus_cli-3.43.0}/src/globus_cli/commands/flows/__init__.py

@@ -13,6 +13,10 @@ from globus_cli.parsing import group
         "start": (".start", "start_command"),
         # "run" is a subgroup of commands.
         "run": (".run", "run_command"),
+        # "registered-api" is a subgroup of commands.
+        "registered-api": (".registered_api", "registered_api_command"),
+        # "web-input" is a subgroup of commands.
+        "web-input": (".web_input", "web_input_command"),
     },
 )
 def flows_command() -> None:

{globus_cli-3.41.0 → globus_cli-3.43.0}/src/globus_cli/commands/flows/_common.py

@@ -125,17 +125,27 @@ keywords_option = click.option(
 )
 
 
-class SubscriptionIdType(click.ParamType):
+class SubscriptionIdType(
+    click.ParamType[uuid.UUID | t.Literal["DEFAULT"] | globus_sdk.MissingType]
+):
     name = "SUBSCRIPTION_ID"
 
     def __init__(self, *, omittable: bool = False) -> None:
-        self._omittable = omittable
+        self._omittable: bool = omittable
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> uuid.UUID | t.Literal["DEFAULT"] | globus_sdk.MissingType:
-        if self._omittable and value is globus_sdk.MISSING:
-            return globus_sdk.MISSING
+        if value is globus_sdk.MISSING:
+            if self._omittable:
+                return globus_sdk.MISSING
+            else:
+                raise NotImplementedError(
+                    "Cannot pass MISSING to non-omittable SubscriptionidType."
+                )
 
         if value.upper() == "DEFAULT":
             return "DEFAULT"

globus_cli-3.43.0/src/globus_cli/commands/flows/_fields.py

@@ -0,0 +1,283 @@
+import typing as t
+
+import globus_sdk
+
+from globus_cli.termio import Field, formatters
+from globus_cli.termio.formatters import (
+    ArrayFormatter,
+    FieldFormatter,
+)
+from globus_cli.termio.formatters.auth import PrincipalURNFormatter
+
+
+class FlowPrincipalFormatter(PrincipalURNFormatter):
+    """A principal formatter which properly pre-registers all principals for a flow."""
+
+    def __init__(
+        self, auth_client: globus_sdk.AuthClient, flow: dict[str, t.Any]
+    ) -> None:
+        super().__init__(auth_client)
+        self.add_items(flow.get("flow_owner"))
+        self.add_items(*flow.get("flow_administrators", ()))
+        self.add_items(*flow.get("flow_viewers", ()))
+        self.add_items(*flow.get("run_managers", ()))
+        self.add_items(*flow.get("run_monitors", ()))
+
+
+def flow_format_fields(
+    auth_client: globus_sdk.AuthClient,
+    flow: dict[str, t.Any],
+) -> list[Field]:
+    """
+    The standard list of fields to render for a standard api flow-resource.
+
+    :param auth_client: An AuthClient, used to resolve principal URNs.
+    :param flow: The flow resource, used to pre-register formattable principals.
+    """
+    principal = FlowPrincipalFormatter(auth_client, flow)
+    csv_principal_list = formatters.ArrayFormatter(
+        element_formatter=principal,
+        delimiter=", ",
+    )
+    csv_list = formatters.ArrayFormatter(delimiter=", ")
+    fuzzy_bool = formatters.FuzzyBool
+
+    return [
+        Field("Flow ID", "id"),
+        Field("Title", "title"),
+        Field("Subtitle", "subtitle"),
+        Field("Description", "description"),
+        Field("Keywords", "keywords", formatter=csv_list),
+        Field("Owner", "flow_owner", formatter=principal),
+        Field("High Assurance", "authentication_policy_id", formatter=fuzzy_bool),
+        Field("Authentication Policy ID", "authentication_policy_id"),
+        Field("Subscription ID", "subscription_id"),
+        Field("Created At", "created_at", formatter=formatters.Date),
+        Field("Updated At", "updated_at", formatter=formatters.Date),
+        Field("Administrators", "flow_administrators", formatter=csv_principal_list),
+        Field("Viewers", "flow_viewers", formatter=csv_principal_list),
+        Field("Starters", "flow_starters", formatter=csv_principal_list),
+        Field("Run Managers", "run_managers", formatter=csv_principal_list),
+        Field("Run Monitors", "run_monitors", formatter=csv_principal_list),
+    ]
+
+
+class FlowRunPrincipalFormatter(PrincipalURNFormatter):
+    """A principal formatter which pre-registers all principals for a flow run."""
+
+    def __init__(
+        self, auth_client: globus_sdk.AuthClient, flow_run: dict[str, t.Any]
+    ) -> None:
+        super().__init__(auth_client)
+        self.add_items(flow_run.get("run_owner"))
+        self.add_items(*flow_run.get("run_managers", ()))
+        self.add_items(*flow_run.get("run_monitors", ()))
+
+
+def flow_run_format_fields(
+    auth_client: globus_sdk.AuthClient,
+    flow_run: dict[str, t.Any],
+) -> list[Field]:
+    """
+    The standard list of fields to render for a standard api flow-run resource.
+
+    :param auth_client: An AuthClient, used to resolve principal URNs.
+    :param flow_run: The flow run resource, used to pre-register formattable principals.
+    """
+    principal = FlowRunPrincipalFormatter(auth_client, flow_run)
+    csv_principal_list = formatters.ArrayFormatter(
+        element_formatter=principal,
+        delimiter=", ",
+    )
+    csv_list = formatters.ArrayFormatter(delimiter=", ")
+
+    flow_description_fields = (
+        [
+            Field("Flow Subtitle", "flow_description.subtitle"),
+            Field("Flow Description", "flow_description.description"),
+            Field("Flow Keywords", "flow_description.keywords", formatter=csv_list),
+        ]
+        if "flow_description" in flow_run
+        else []
+    )
+
+    return [
+        Field("Run ID", "run_id"),
+        Field("Run Label", "label"),
+        Field("Run Tags", "tags", formatter=csv_list),
+        Field("Status", "status"),
+        Field("Started At", "start_time", formatter=formatters.Date),
+        Field("Completed At", "completion_time", formatter=formatters.Date),
+        Field("Flow ID", "flow_id"),
+        Field("Flow Title", "flow_title"),
+        *flow_description_fields,
+        Field("Run Owner", "run_owner", formatter=principal),
+        Field("Run Managers", "run_managers", formatter=csv_principal_list),
+        Field("Run Monitors", "run_monitors", formatter=csv_principal_list),
+    ]
+
+
+class RegisteredAPIPrincipalFormatter(PrincipalURNFormatter):
+    """A principal formatter which pre-registers all principals for a registered API."""
+
+    def __init__(
+        self, auth_client: globus_sdk.AuthClient, registered_api: dict[str, t.Any]
+    ) -> None:
+        super().__init__(auth_client)
+        roles = registered_api.get("roles", {})
+        self.add_items(*roles.get("owners", ()))
+        self.add_items(*roles.get("administrators", ()))
+        self.add_items(*roles.get("viewers", ()))
+
+
+def registered_api_format_fields(
+    auth_client: globus_sdk.AuthClient,
+    registered_api: dict[str, t.Any],
+) -> list[Field]:
+    """
+    The standard list of fields to render for a registered API resource.
+
+    :param auth_client: An AuthClient, used to resolve principal URNs.
+    :param registered_api: The registered API resource, used to pre-register
+        principals.
+    """
+    principal = RegisteredAPIPrincipalFormatter(auth_client, registered_api)
+    csv_principal_list = formatters.ArrayFormatter(
+        element_formatter=principal,
+        delimiter=", ",
+    )
+
+    return [
+        Field("Registered API ID", "id"),
+        Field("Name", "name"),
+        Field("Description", "description"),
+        Field("Status", "status"),
+        Field("Subscription ID", "subscription_id"),
+        Field("Created At", "created_timestamp", formatter=formatters.Date),
+        Field("Updated At", "updated_timestamp", formatter=formatters.Date),
+        Field("Edited At", "edited_timestamp", formatter=formatters.Date),
+        Field(
+            "Scheduled Deletion",
+            "scheduled_deletion_timestamp",
+            formatter=formatters.Date,
+        ),
+        Field("Owners", "roles.owners", formatter=csv_principal_list),
+        Field("Administrators", "roles.administrators", formatter=csv_principal_list),
+        Field("Viewers", "roles.viewers", formatter=csv_principal_list),
+        Field("Target Type", "target.type"),
+        Field("OpenAPI Version", "target.openapi_version"),
+        Field("Destination Method", "target.destination.method"),
+        Field("Destination URL", "target.destination.url"),
+    ]
+
+
+class WebInputPrincipalFormatter(PrincipalURNFormatter):
+    """A principal formatter which pre-registers all principals for a web input."""
+
+    def __init__(
+        self, auth_client: globus_sdk.AuthClient, web_input: dict[str, t.Any]
+    ) -> None:
+        super().__init__(auth_client)
+        self.add_items(web_input.get("creator_urn"))
+        roles = web_input.get("roles", {})
+        self.add_items(*roles.get("viewer_urns", ()))
+        self.add_items(*roles.get("respondent_urns", ()))
+
+
+class IdentifiedResourceFormatter(FieldFormatter[str]):
+    def parse(self, value: t.Any) -> str:
+        if not isinstance(value, list) or len(value) != 2:
+            raise ValueError("cannot format parenthetical from data of wrong shape")
+        name, resource_id = value[0], value[1]
+        if not isinstance(resource_id, str):
+            raise ValueError("cannot format parenthetical non-str id")
+        if isinstance(name, str):
+            # If the name can be parsed, render it alongside the resource id
+            return f"{name} ({resource_id})"
+        # If the name can't be parsed, just render the resource id
+        return resource_id
+
+    def render(self, value: str) -> str:
+        return value
+
+
+class _OptionFormatter(FieldFormatter[tuple[t.Any, t.Any]]):
+    def parse(self, value: t.Any) -> tuple[t.Any, t.Any]:
+        if not isinstance(value, dict):
+            raise ValueError("non-dict field value")
+        elif "option_id" not in value or "label" not in value:
+            raise ValueError("missing key 'option_id' and/or 'label'")
+        return value["option_id"], value["label"]
+
+    def render(self, value: tuple[t.Any, t.Any]) -> str:
+        option_id, label = value
+        return f"*  {option_id}  {label}"
+
+
+class _WebInputContextRowsFormatter(FieldFormatter[t.List[t.Tuple[str, str]]]):
+    """Renders a list of {field, value} rows as an aligned 'field: value' block."""
+
+    def parse(self, value: t.Any) -> list[tuple[str, str]]:
+        if not isinstance(value, list):
+            raise ValueError("non list context rows value")
+        rows = []
+        for item in value:
+            if not isinstance(item, dict) or "field" not in item or "value" not in item:
+                raise ValueError("missing key 'field' and/or 'value'")
+            rows.append((item["field"], item["value"]))
+        return rows
+
+    def render(self, value: list[tuple[str, str]]) -> str:
+        width = max(len(field) for field, _ in value) + 2
+        return "\n".join(f"{field}:".ljust(width) + str(val) for field, val in value)
+
+
+def web_input_format_fields(
+    auth_client: globus_sdk.AuthClient,
+    web_input: dict[str, t.Any],
+) -> list[Field]:
+    """
+    The standard list of fields to render for a web input resource.
+
+    :param auth_client: An AuthClient, used to resolve principal URNs.
+    :param web_input: The web input resource, used to pre-register principals.
+    """
+    principal = WebInputPrincipalFormatter(auth_client, web_input)
+    csv_principal_list = formatters.ArrayFormatter(
+        element_formatter=principal,
+        delimiter=", ",
+    )
+    csv_list = formatters.ArrayFormatter(delimiter=", ")
+    flow_run_formatter = IdentifiedResourceFormatter()
+
+    fields = [
+        Field("Web Input ID", "id"),
+        Field("Status", "status"),
+        Field("Title", "context.title"),
+        Field("Your Roles", "user_roles", formatter=csv_list),
+        Field("Flow", "[flow.title, flow.id]", formatter=flow_run_formatter),
+        Field("Run", "[run.label, run.id]", formatter=flow_run_formatter),
+        Field("Creator", "creator_urn", formatter=principal),
+        Field("Viewers", "roles.viewer_urns", formatter=csv_principal_list),
+        Field("Respondents", "roles.respondent_urns", formatter=csv_principal_list),
+        Field("Created At", "created_timestamp", formatter=formatters.Date),
+        Field("Closed At", "closed_timestamp", formatter=formatters.Date),
+    ]
+
+    if web_input.get("context", {}).get("presentation_style") == "table":
+        fields += [
+            Field(
+                "Context",
+                "context.rows",
+                section=True,
+                formatter=_WebInputContextRowsFormatter(),
+            )
+        ]
+    else:
+        fields += [Field("Context", "context.text", section=True)]
+
+    if web_input.get("options"):
+        formatter = ArrayFormatter(delimiter="\n", element_formatter=_OptionFormatter())
+        fields += [Field("Options", "options", section=True, formatter=formatter)]
+
+    return fields

globus_cli-3.43.0/src/globus_cli/commands/flows/registered_api/__init__.py

@@ -0,0 +1,12 @@
+from globus_cli.parsing import group
+
+
+@group(
+    "registered-api",
+    lazy_subcommands={
+        "show": (".show", "show_command"),
+        "list": (".list", "list_command"),
+    },
+)
+def registered_api_command() -> None:
+    """Interact with registered APIs in the Globus Flows service."""