cloudsmith-cli 1.24.0__tar.gz → 1.26.0__tar.gz

{cloudsmith_cli-1.24.0/cloudsmith_cli.egg-info → cloudsmith_cli-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudsmith-cli
-Version: 1.24.0
+Version: 1.26.0
 Summary: Cloudsmith Command-Line Interface (CLI)
 Author-email: Cloudsmith Ltd <support@cloudsmith.io>
 License-Expression: Apache-2.0
@@ -28,7 +28,7 @@ Requires-Dist: click-configfile>=0.2.3
 Requires-Dist: click-didyoumean>=0.0.3
 Requires-Dist: click-spinner>=0.1.7
 Requires-Dist: json5>=0.9.0
-Requires-Dist: cloudsmith-api<3.0,>=2.0.29
+Requires-Dist: cloudsmith-api<3.0,>=2.0.31
 Requires-Dist: keyring>=25.4.1
 Requires-Dist: keyrings-alt>=5.0.2
 Requires-Dist: keyrings-cryptfile>=1.3.9
@@ -40,6 +40,7 @@ Requires-Dist: requests_toolbelt>=1.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: semver>=2.7.9
 Requires-Dist: urllib3>=2.5
+Requires-Dist: tomlkit>=0.15.0
 Provides-Extra: aws
 Requires-Dist: boto3[crt]>=1.26.0; extra == "aws"
 Provides-Extra: all

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/__init__.py

@@ -3,8 +3,6 @@
 import warnings
 
 import click
-import urllib3
 
 click.disable_unicode_literals_warning = True
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 warnings.filterwarnings("ignore", category=ResourceWarning)

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/command.py

@@ -1,5 +1,6 @@
 """CLI - Group/Command classes."""
 
+import importlib
 from collections import OrderedDict
 
 import click.exceptions
@@ -50,12 +51,25 @@ def _format_click_exception_as_json(exception):
 
 
 class AliasGroup(DYMGroup):
-    """A command group with DYM and alias support."""
+    """A command group with DYM, alias and lazy-subcommand support.
+
+    ``lazy_commands`` maps a command name to the module that registers it.
+    The module is imported on first use, which keeps startup fast because
+    an invocation imports only the module of the invoked command.
+    ``lazy_aliases`` supplies the alias map for those commands up front.
+    """
 
     def __init__(self, *args, **kwargs):
+        lazy_commands = kwargs.pop("lazy_commands", None)
+        lazy_aliases = kwargs.pop("lazy_aliases", None)
         super().__init__(*args, **kwargs)
+        self.lazy_commands = dict(lazy_commands or {})
         self.aliases = OrderedDict()
         self.inverse = {}
+        for name, aliases in (lazy_aliases or {}).items():
+            self.aliases[name] = aliases
+            for alias in aliases:
+                self.inverse[alias] = name
 
     def resolve_command(self, ctx, args):
         try:
@@ -74,7 +88,7 @@ class AliasGroup(DYMGroup):
             raise
 
     def list_commands(self, ctx):
-        commands = super().list_commands(ctx)
+        commands = sorted(set(super().list_commands(ctx)) | set(self.lazy_commands))
 
         if getattr(ctx, "showing_help", False):
             for k, v in enumerate(commands):
@@ -99,7 +113,11 @@ class AliasGroup(DYMGroup):
         except KeyError:
             pass
 
-        return super().get_command(ctx, cmd_name)
+        cmd = super().get_command(ctx, cmd_name)
+        if cmd is None and cmd_name in self.lazy_commands:
+            importlib.import_module(self.lazy_commands[cmd_name])
+            cmd = super().get_command(ctx, cmd_name)
+        return cmd
 
     def command(self, *args, **kwargs):
         def decorator(f):

cloudsmith_cli-1.26.0/cloudsmith_cli/cli/commands/__init__.py

@@ -0,0 +1,6 @@
+"""CLI/Commands.
+
+Command modules register themselves with the ``main`` group on import.
+The ``main`` group imports them lazily through ``registry.LAZY_COMMANDS``,
+so this package must not import them here.
+"""

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/auth.py

@@ -17,7 +17,12 @@ AUTH_SERVER_PORT = 12400
 
 
 def _perform_saml_authentication(
-    opts, owner, enable_token_creation=False, use_stderr=False, no_browser=False
+    opts,
+    owner,
+    enable_token_creation=False,
+    use_stderr=False,
+    no_browser=False,
+    profile=None,
 ):
     """Perform SAML authentication via web browser and local web server."""
     session = create_configured_session(opts)
@@ -26,7 +31,7 @@ def _perform_saml_authentication(
     idp_url = get_idp_url(api_host, owner, session=session)
 
     click.echo(
-        f"Your organization's SAML IDP URL is: {click.style(idp_url, bold=True)}",
+        f"Your Workspace's SAML IDP URL is: {click.style(idp_url, bold=True)}",
         err=use_stderr,
     )
     click.echo(err=use_stderr)
@@ -63,21 +68,13 @@ def _perform_saml_authentication(
         debug=opts.debug,
         refresh_api_on_success=enable_token_creation,
         api_opts=opts.api_config,
+        profile=profile,
     )
 
     auth_server.handle_request()
 
 
 @main.command(aliases=["auth"])
-@click.option(
-    "-o",
-    "--owner",
-    metavar="OWNER",
-    required=True,
-    callback=validators.validate_owner,
-    prompt=True,
-    help="The name of the Cloudsmith organization to authenticate with.",
-)
 @click.option(
     "-t",
     "--token",
@@ -126,7 +123,6 @@ def _perform_saml_authentication(
 def authenticate(
     ctx,
     opts,
-    owner,
     token,
     force,
     save_config,
@@ -134,7 +130,7 @@ def authenticate(
     request_api_key_flag,
     no_browser,
 ):
-    """Authenticate to Cloudsmith using the org's SAML setup."""
+    """Authenticate to Cloudsmith using the Workspace's SAML setup."""
     # Validate mutual exclusivity
     if request_api_key_flag and (token or force):
         raise click.UsageError(
@@ -169,10 +165,13 @@ def authenticate(
             err=True,
         )
 
-    owner = owner[0].strip("[]'")
+    workspace = opts.org or click.prompt("Workspace", err=use_stderr)
+    workspace = validators.validate_owner(ctx, None, workspace)[0]
+    opts.org = workspace
 
     click.echo(
-        f"Beginning authentication for the {click.style(owner, bold=True)} org ... ",
+        "Beginning authentication for the "
+        f"{click.style(workspace, bold=True)} Workspace ... ",
         err=use_stderr,
     )
 
@@ -183,10 +182,11 @@ def authenticate(
     with handle_api_exceptions(ctx, opts=opts, context_msg=context_message):
         _perform_saml_authentication(
             opts,
-            owner,
+            workspace,
             enable_token_creation=enable_token_creation,
             use_stderr=use_stderr,
             no_browser=no_browser,
+            profile=ctx.meta.get("profile"),
         )
 
     if request_api_key_flag:

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/copy.py

@@ -71,14 +71,26 @@ def copy(
         ),
         maybe_spinner(opts),
     ):
-        _, new_slug = copy_package(
+        slug_perm, new_slug = copy_package(
             owner=owner, repo=source, identifier=slug, destination=destination
         )
 
     click.secho("OK", fg="green", err=use_stderr)
 
+    click.echo(
+        "Copied: {owner}/{repo}/{slug} ({slug_perm})".format(
+            owner=click.style(owner, fg="magenta"),
+            repo=click.style(destination, fg="magenta"),
+            slug=click.style(new_slug, fg="green"),
+            slug_perm=click.style(slug_perm, bold=True),
+        ),
+        err=use_stderr,
+    )
+
     if no_wait_for_sync:
-        utils.maybe_print_status_json(opts, {"slug": new_slug, "status": "OK"})
+        utils.maybe_print_status_json(
+            opts, {"slug": new_slug, "slug_perm": slug_perm, "status": "OK"}
+        )
         return
 
     wait_for_package_sync(
@@ -92,4 +104,6 @@ def copy(
         attempts=sync_attempts,
     )
 
-    utils.maybe_print_status_json(opts, {"slug": new_slug, "status": "OK"})
+    utils.maybe_print_status_json(
+        opts, {"slug": new_slug, "slug_perm": slug_perm, "status": "OK"}
+    )

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/__init__.py

@@ -9,9 +9,11 @@ that follow their respective credential helper protocols.
 import click
 
 from ..main import main
+from .cargo import cargo as cargo_cmd
 from .docker import docker as docker_cmd
 from .generic import generic as generic_cmd
 from .manage import install_cmd, list_cmd, uninstall_cmd
+from .pnpm import pnpm as pnpm_cmd
 
 
 @click.group()
@@ -27,15 +29,26 @@ def credential_helper():
         # Install Docker credential helper
         $ cloudsmith credential-helper install docker
 
+        # Install pnpm credential helper
+        $ cloudsmith credential-helper install pnpm
+
+        # Install cargo credential helper
+        $ cloudsmith credential-helper install cargo
+
         # Test Docker credential helper directly
         $ echo "docker.cloudsmith.io" | cloudsmith credential-helper docker
+
+        # Test pnpm credential helper directly
+        $ cloudsmith credential-helper pnpm npm.cloudsmith.io
     """
 
 
+credential_helper.add_command(pnpm_cmd, name="pnpm")
 credential_helper.add_command(docker_cmd, name="docker")
 credential_helper.add_command(generic_cmd, name="generic")
 credential_helper.add_command(install_cmd, name="install")
 credential_helper.add_command(uninstall_cmd, name="uninstall")
 credential_helper.add_command(list_cmd, name="list")
+credential_helper.add_command(cargo_cmd, name="cargo")
 
 main.add_command(credential_helper, name="credential-helper")

cloudsmith_cli-1.26.0/cloudsmith_cli/cli/commands/credential_helper/cargo.py

@@ -0,0 +1,94 @@
+# Copyright 2026 Cloudsmith Ltd
+"""
+Cargo credential provider command.
+
+Implements the Cargo credential provider protocol for Cloudsmith registries.
+
+See: https://doc.rust-lang.org/cargo/reference/credential-provider-protocol.html
+"""
+
+import sys
+
+import click
+
+from ....credential_helpers.cargo import execute
+from ...decorators import common_api_auth_options, resolve_credentials
+
+
+@click.command(context_settings={"ignore_unknown_options": True})
+@click.option(
+    "--cargo-plugin",
+    is_flag=True,
+    default=False,
+    hidden=True,
+    help="Passed by Cargo when invoking this command as a credential provider.",
+)
+@click.argument("provider_args", nargs=-1, type=click.UNPROCESSED)
+@common_api_auth_options
+@resolve_credentials
+def cargo(opts, cargo_plugin, provider_args):  # pylint: disable=unused-argument
+    """
+    Cargo credential provider for Cloudsmith registries.
+
+    Speaks the Cargo credential provider protocol: a newline-delimited JSON
+    conversation on stdin/stdout, starting with a hello message that announces
+    the supported protocol versions, then one response per request.
+
+    Provides credentials for all Cloudsmith Cargo registries: ``*.cloudsmith.io``,
+    ``*.cloudsmith.com``, and any custom domains configured for the Workspace
+    (requires a Workspace - ``--workspace``, CLOUDSMITH_WORKSPACE, or
+    ``workspace`` in ``config.ini``; legacy aliases are also accepted - and a
+    valid API key/token).
+
+    A registry that is not a Cloudsmith one is answered with
+    ``url-not-supported`` so Cargo falls through to the next configured
+    credential provider.  ``cargo login``/``cargo logout`` are answered with
+    ``operation-not-supported``: credentials come from the Cloudsmith CLI's own
+    provider chain, so there is nothing to store or clear.
+
+    \b
+    Input (stdin):
+        One JSON request per line, e.g.
+        {"v":1,"kind":"get","operation":"read",
+         "registry":{"index-url":"sparse+https://cargo.cloudsmith.io/org/repo/"}}
+
+    \b
+    Output (stdout):
+        {"v":[1]}
+        {"Ok":{"kind":"get","token":"<cloudsmith-token>","cache":"session",
+               "operation_independent":true}}
+
+    \b
+    Exit codes:
+        0: Session completed
+        1: No credentials available, or the session broke down
+
+    \b
+    Examples:
+        # Manual testing
+        $ echo '{"v":1,"kind":"get","operation":"read","registry":{"index-url":"sparse+https://cargo.cloudsmith.io/org/repo/"}}' \\
+            | cloudsmith credential-helper cargo
+
+        # Called by Cargo via the launcher
+        $ cargo-credential-cloudsmith --cargo-plugin
+
+    \b
+    Environment variables:
+        CLOUDSMITH_API_KEY: API key for authentication (optional)
+        CLOUDSMITH_WORKSPACE: Workspace slug (CLOUDSMITH_ORG is also accepted)
+    """
+    # `provider_args` collects the extra arguments Cargo appends from the
+    # credential-provider config entry.  This provider takes no configuration
+    # of its own, so they are accepted and ignored rather than rejected — an
+    # unknown-option error would surface as an authentication failure.
+    exit_code, stderr = execute(
+        sys.stdin,
+        sys.stdout,
+        credential=opts.credential,
+        api_host=opts.api_host,
+        org=opts.org,
+    )
+
+    if stderr is not None:
+        click.echo(stderr, err=True)
+    sys.exit(exit_code)

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/docker.py

@@ -28,9 +28,10 @@ def docker(opts, operation):
     (get/store/erase/list).
 
     Provides credentials for all Cloudsmith Docker registries: ``*.cloudsmith.io``,
-    ``*.cloudsmith.com``, and any custom domains configured for the organisation
-    (requires an organisation - ``--org``, CLOUDSMITH_ORG or ``org`` in
-    ``config.ini`` - and a valid API key/token).
+    ``*.cloudsmith.com``, and any custom domains configured for the Workspace
+    (requires a Workspace - ``--workspace``, CLOUDSMITH_WORKSPACE, or
+    ``workspace`` in ``config.ini``; legacy aliases are also accepted - and a
+    valid API key/token).
 
     Input (stdin):
         Server URL as plain text (e.g. "docker.cloudsmith.io")
@@ -51,7 +52,7 @@ def docker(opts, operation):
 
     Environment variables:
         CLOUDSMITH_API_KEY: API key for authentication (optional)
-        CLOUDSMITH_ORG:     Organisation slug (required for custom domain support)
+        CLOUDSMITH_WORKSPACE: Workspace slug (CLOUDSMITH_ORG is also accepted)
     """
     exit_code, stdout, stderr = execute(
         operation,

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/generic.py

@@ -27,7 +27,7 @@ def generic(opts):
 
     Resolves a credential through the full provider chain and writes a
     versioned JSON document to stdout.  Takes no arguments: a Cloudsmith token
-    is organisation-wide, so the host it will be used against does not change
+    is Workspace-wide, so the host it will be used against does not change
     which credential resolves.
 
     \b

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/manage.py

@@ -12,6 +12,10 @@ import sys
 
 import click
 
+from cloudsmith_cli.credential_helpers.cargo.installer import CargoInstaller
+from cloudsmith_cli.credential_helpers.generic import PartialInstallError
+from cloudsmith_cli.credential_helpers.pnpm.installer import PNPMInstaller
+
 from ....credential_helpers.docker.installer import DockerInstaller
 from ... import utils
 from ...decorators import (
@@ -27,6 +31,8 @@ from ...decorators import (
 
 _INSTALLERS: dict[str, type] = {
     "docker": DockerInstaller,
+    "pnpm": PNPMInstaller,
+    "cargo": CargoInstaller,
 }
 
 
@@ -40,7 +46,7 @@ def _get_installer(name: str):
 
     Returns
     -------
-    DockerInstaller
+    BaseInstaller
         An instance of the appropriate installer class.
 
     Raises
@@ -85,7 +91,7 @@ def _get_installer(name: str):
     "--no-discover",
     is_flag=True,
     default=False,
-    help="Disable automatic discovery of custom Docker domains.",
+    help="Disable automatic discovery of custom domains.",
 )
 @click.option(
     "--refresh",
@@ -110,25 +116,30 @@ def install_cmd(
 ) -> None:
     """Install a credential helper launcher and configure the package manager.
 
-    HELPER is the name of the credential helper to install (e.g. ``docker``).
+    HELPER is the name of the credential helper to install (e.g. ``docker``, ``pnpm``).
+
+    Important for pnpm: The tokenHelper directive is only honored in the
+    user-level ~/.npmrc file, not in a project-level .npmrc. This is a pnpm
+    security restriction. The absolute path to the launcher is automatically
+    calculated and configured.
 
     Examples:
 
     \b
-        # Install Docker credential helper
-        $ cloudsmith credential-helper install docker
+        # Install credential helper
+        $ cloudsmith credential-helper install HELPER
 
     \b
         # Install with a custom domain
-        $ cloudsmith credential-helper install docker --domain my.registry.example.com
+        $ cloudsmith credential-helper install HELPER --domain my.registry.example.com
 
     \b
         # Preview without making changes
-        $ cloudsmith credential-helper install docker --dry-run
+        $ cloudsmith credential-helper install HELPER --dry-run
 
     \b
         # Disable automatic custom-domain discovery
-        $ cloudsmith credential-helper install docker --no-discover
+        $ cloudsmith credential-helper install HELPER --no-discover
     """
     installer = _get_installer(helper)
     try:
@@ -146,6 +157,11 @@ def install_cmd(
         raise click.ClickException(
             f"Failed to install {helper!r} credential helper: {exc}"
         )
+    except PartialInstallError as exc:
+        actions = exc.actions
+        ec = exc.exit_code
+    else:
+        ec = 0
 
     use_stderr = utils.should_use_stderr(opts)
     warnings = [a for a in actions if a.startswith("WARNING")]
@@ -157,7 +173,7 @@ def install_cmd(
         "warnings": warnings,
     }
     if utils.maybe_print_as_json(opts, data):
-        return
+        sys.exit(ec)
 
     if dry_run:
         click.echo("Dry run — no changes will be made:", err=use_stderr)
@@ -165,6 +181,7 @@ def install_cmd(
         click.echo(f"  {action}" if dry_run else action, err=use_stderr)
     for warning in warnings:
         click.secho(f"  {warning}" if dry_run else warning, err=True, fg="yellow")
+    sys.exit(ec)
 
 
 # ---------------------------------------------------------------------------

cloudsmith_cli-1.26.0/cloudsmith_cli/cli/commands/credential_helper/pnpm.py

@@ -0,0 +1,51 @@
+# Copyright 2026 Cloudsmith Ltd
+"""
+pnpm credential helper command.
+
+Implements the pnpm credential helper protocol for Cloudsmith registries.
+"""
+
+import sys
+
+import click
+
+from ....credential_helpers.pnpm import execute
+from ...decorators import common_api_auth_options, resolve_credentials
+
+
+@click.command()
+@click.argument("repo", required=False, default="npm.cloudsmith.io")
+@common_api_auth_options
+@resolve_credentials
+def pnpm(opts, repo):
+    """
+    Input (arg, optional):
+        Server URL as plain text (e.g. "npm.cloudsmith.io")
+
+    Output (stdout):
+        Text: <cloudsmith-token>
+
+    \b
+    Exit codes:
+        0: Success
+        1: Error (no credentials available, not a Cloudsmith registry, etc.)
+
+    \b
+    Environment variables:
+        CLOUDSMITH_API_KEY: API key for authentication (optional)
+        CLOUDSMITH_WORKSPACE: Workspace slug (CLOUDSMITH_ORG is also accepted)
+    """
+
+    exit_code, stdout, stderr = execute(
+        repo,
+        credential=opts.credential,
+        api_host=opts.api_host,
+        org=opts.org,
+    )
+
+    if stdout is not None:
+        click.echo(stdout, nl=False)
+    if stderr is not None:
+        click.echo(stderr, err=True)
+
+    sys.exit(exit_code)

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/dependencies.py

@@ -74,16 +74,15 @@ def list_dependencies(ctx, opts, owner_repo_package):
         return
 
     headers = ["Type", "Name", "Operator", "Version"]
-    rows = []
-    for dep in deps:
-        rows.append(
-            [
-                click.style(dep["dep_type"], fg="cyan"),
-                click.style(dep["name"], fg="yellow"),
-                click.style(dep["operator"], fg="magenta"),
-                click.style(dep["version"] or "", fg="green"),
-            ]
-        )
+    rows = [
+        [
+            click.style(dep["dep_type"], fg="cyan"),
+            click.style(dep["name"], fg="yellow"),
+            click.style(dep["operator"], fg="magenta"),
+            click.style(dep["version"] or "", fg="green"),
+        ]
+        for dep in deps
+    ]
 
     if deps:
         click.echo()

{cloudsmith_cli-1.24.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/domains.py

@@ -63,6 +63,7 @@ def _custom_entries(records) -> list[dict]:
             "format": format_for_backend_kind(record.backend_kind),
             "type": "custom",
             "domain_type": record.domain_type.value,
+            "workspace": record.org,
             "org": record.org,
             "repository": record.repository,
             "primary": record.primary,
@@ -133,19 +134,19 @@ def list_domains(  # pylint: disable=too-many-arguments
     ``*.cloudsmith.io`` service hosts alongside custom domains, with ``type``
     distinguishing ``default`` from ``custom`` and ``domain_type`` saying what
     each host is for: ``download``, ``upload``, or ``native_api`` for a host
-    speaking one package format's own protocol. An organisation's own custom
+    speaking one package format's own protocol. A Workspace's own custom
     domains are listed ahead of the built-in hosts, which serve as the
     fallback. Only usable hosts are listed: a custom domain that is disabled or
     not yet validated serves nothing, so it is left out rather than offered as
     somewhere to publish to. Check it in the Cloudsmith UI if one you expect is
     missing here.
 
-    Built-in hosts are always listed and need no organisation or authentication.
-    An organisation from ``--org``, CLOUDSMITH_ORG or ``org`` in ``config.ini``
-    adds its custom domains, and a failed lookup exits non-zero rather than
-    rendering as "no domains". With no organisation the command lists whatever
-    earlier runs cached and makes no API call; ``--refresh`` bypasses that cache
-    for a configured organisation.
+    Built-in hosts are always listed and need no Workspace or authentication.
+    A Workspace from ``--workspace``, CLOUDSMITH_WORKSPACE, or ``workspace`` in
+    ``config.ini`` adds its custom domains, and a failed lookup exits non-zero
+    rather than rendering as "no domains". With no Workspace the command lists
+    whatever earlier runs cached and makes no API call; ``--refresh`` bypasses
+    that cache for a configured Workspace.
 
     Where two custom domains could serve the same request Cloudsmith picks the
     one bound to the repository in hand, then ``primary`` over secondary, then
@@ -163,7 +164,7 @@ def list_domains(  # pylint: disable=too-many-arguments
 
     Output (stdout):
         JSON: {"version": 1, "domains": [{"host": ..., "format": ...,
-        "type": ..., "domain_type": ..., "org": ..., "repository": ...,
+        "type": ..., "domain_type": ..., "workspace": ..., "repository": ...,
         "primary": ..., "created_at": ...}], "meta": {"pagination": {...}}}
 
         "meta" is only present when the result is paginated (i.e. not
@@ -177,16 +178,16 @@ def list_domains(  # pylint: disable=too-many-arguments
         $ cloudsmith domains list
 
     \b
-        # List built-in hosts plus an organisation's custom domains
-        $ cloudsmith domains list --org my-org
+        # List built-in hosts plus a Workspace's custom domains
+        $ cloudsmith domains list --workspace my-workspace
 
     \b
         # The hosts usable for one repository, most-preferred first
-        $ cloudsmith domains list --org my-org --repo my-repo --format maven
+        $ cloudsmith domains list --workspace my-workspace --repo my-repo --format maven
 
     \b
         # Where to upload to
-        $ cloudsmith domains list --org my-org --domain-type upload
+        $ cloudsmith domains list --workspace my-workspace --domain-type upload
     """
     if not page_all:
         explicit_sources = {
@@ -229,6 +230,7 @@ def list_domains(  # pylint: disable=too-many-arguments
             "format": domain.format_label,
             "type": "default",
             "domain_type": domain.domain_type.value,
+            "workspace": None,
             "org": None,
             "repository": None,
             "primary": True,
@@ -257,9 +259,9 @@ def list_domains(  # pylint: disable=too-many-arguments
     else:
         if refresh:
             click.secho(
-                "Warning: --refresh needs an organisation to fetch from, so the "
-                "cached custom domains below are unchanged. Set --org, "
-                "CLOUDSMITH_ORG or org in config.ini.",
+                "Warning: --refresh needs a Workspace to fetch from, so the "
+                "cached custom domains below are unchanged. Set --workspace, "
+                "CLOUDSMITH_WORKSPACE, or workspace in config.ini.",
                 fg="yellow",
                 err=True,
             )