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

{cloudsmith_cli-1.25.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.25.0
+Version: 1.26.0
 Summary: Cloudsmith Command-Line Interface (CLI)
 Author-email: Cloudsmith Ltd <support@cloudsmith.io>
 License-Expression: Apache-2.0
@@ -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.25.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.25.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.25.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.25.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.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/__init__.py

@@ -9,6 +9,7 @@ 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
@@ -31,6 +32,9 @@ def credential_helper():
         # 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
 
@@ -45,5 +49,6 @@ 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.25.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.25.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.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/manage.py

@@ -12,6 +12,7 @@ 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
 
@@ -31,6 +32,7 @@ from ...decorators import (
 _INSTALLERS: dict[str, type] = {
     "docker": DockerInstaller,
     "pnpm": PNPMInstaller,
+    "cargo": CargoInstaller,
 }
 
 

{cloudsmith_cli-1.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/credential_helper/pnpm.py

@@ -33,7 +33,7 @@ def pnpm(opts, repo):
     \b
     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(

{cloudsmith_cli-1.25.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.25.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,
             )

{cloudsmith_cli-1.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/download.py

@@ -334,22 +334,20 @@ def _resolve_all_files_items(
             f"Output path '{output_dir}' exists but is not a directory."
         )
 
-    items = []
-    for f in sub_files:
-        items.append(
-            {
-                "filename": f["filename"],
-                "url": f["cdn_url"],
-                "output_path": _safe_join(output_dir, f["filename"]),
-                "tag": f.get("tag", "file"),
-                "is_primary": f.get("is_primary", False),
-                "size": f.get("size", 0),
-                "package_name": pkg_name,
-                "package_version": pkg_version,
-                "status": None,
-            }
-        )
-    return items
+    return [
+        {
+            "filename": f["filename"],
+            "url": f["cdn_url"],
+            "output_path": _safe_join(output_dir, f["filename"]),
+            "tag": f.get("tag", "file"),
+            "is_primary": f.get("is_primary", False),
+            "size": f.get("size", 0),
+            "package_name": pkg_name,
+            "package_version": pkg_version,
+            "status": None,
+        }
+        for f in sub_files
+    ]
 
 
 def _resolve_single_file_item(

{cloudsmith_cli-1.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/list_.py

@@ -239,20 +239,19 @@ def packages(ctx, opts, owner_repo, page, page_size, query, sort, page_all):
         return
 
     headers = ["Name", "Version", "Status", "Owner / Repository (Identifier)"]
-    rows = []
-    for package in sorted(packages_, key=itemgetter("namespace", "slug")):
-        rows.append(
-            [
-                click.style(_get_package_name(package), fg="cyan"),
-                click.style(_get_package_version(package), fg="yellow"),
-                click.style(_get_package_status(package), fg="blue"),
-                "{owner_slug}/{repo_slug}/{slug}".format(
-                    owner_slug=click.style(package["namespace"], fg="magenta"),
-                    repo_slug=click.style(package["repository"], fg="magenta"),
-                    slug=click.style(package["slug"], fg="green"),
-                ),
-            ]
-        )
+    rows = [
+        [
+            click.style(_get_package_name(package), fg="cyan"),
+            click.style(_get_package_version(package), fg="yellow"),
+            click.style(_get_package_status(package), fg="blue"),
+            "{owner_slug}/{repo_slug}/{slug}".format(
+                owner_slug=click.style(package["namespace"], fg="magenta"),
+                repo_slug=click.style(package["repository"], fg="magenta"),
+                slug=click.style(package["slug"], fg="green"),
+            ),
+        ]
+        for package in sorted(packages_, key=itemgetter("namespace", "slug"))
+    ]
 
     if packages_:
         click.echo()

{cloudsmith_cli-1.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/logout.py

@@ -33,8 +33,13 @@ def _clear_credentials(dry_run, use_stderr):
     return {"action": action, "files": list(creds_files)}
 
 
-def _clear_keyring(api_host, dry_run, use_stderr):
-    """Clear SSO tokens from keyring. Returns result dict."""
+def _clear_keyring(api_host, dry_run, use_stderr, profile=None):
+    """Clear SSO tokens from keyring. Returns result dict.
+
+    Remove the profile's own entries. The legacy unscoped entries hold
+    the default profile's session, so remove them only when the profile
+    has no entries of its own.
+    """
     if not keyring.should_use_keyring():
         click.secho(
             "Keyring is disabled (CLOUDSMITH_NO_KEYRING is set).",
@@ -43,7 +48,7 @@ def _clear_keyring(api_host, dry_run, use_stderr):
         )
         return {"action": "disabled"}
 
-    if not keyring.has_sso_tokens(api_host):
+    if not keyring.has_sso_tokens(api_host, profile=profile):
         click.echo("No SSO tokens found in system keyring.", err=use_stderr)
         return {"action": "not_found"}
 
@@ -51,7 +56,9 @@ def _clear_keyring(api_host, dry_run, use_stderr):
         click.echo("Would remove SSO tokens from system keyring.", err=use_stderr)
         return {"action": "would_remove"}
 
-    deleted = keyring.delete_sso_tokens(api_host)
+    deleted = keyring.delete_sso_tokens(api_host, profile=profile, include_legacy=False)
+    if not deleted:
+        deleted = keyring.delete_sso_tokens(api_host)
     action = "removed" if deleted else "failed"
     msg = f"{'Removed' if deleted else 'Failed to remove'} SSO tokens from system keyring."
     click.secho(msg, fg=None if deleted else "red", err=use_stderr)
@@ -131,7 +138,7 @@ def logout(ctx, opts, api_host, keyring_only, config_only, dry_run):
         else {"action": "skipped", "files": []}
     )
     keyring_result = (
-        _clear_keyring(api_host, dry_run, use_stderr)
+        _clear_keyring(api_host, dry_run, use_stderr, profile=ctx.meta.get("profile"))
         if not config_only
         else {"action": "skipped"}
     )

{cloudsmith_cli-1.25.0 → cloudsmith_cli-1.26.0}/cloudsmith_cli/cli/commands/main.py

@@ -6,6 +6,7 @@ from ...core.api.version import get_version as get_api_version
 from ...core.utils import get_github_website, get_help_website
 from ...core.version import get_version as get_cli_version
 from .. import command, decorators, utils
+from .registry import LAZY_ALIASES, LAZY_COMMANDS
 
 CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
 
@@ -28,6 +29,8 @@ def print_version(opts):
 
 @click.group(
     cls=command.AliasGroup,
+    lazy_commands=LAZY_COMMANDS,
+    lazy_aliases=LAZY_ALIASES,
     context_settings=CONTEXT_SETTINGS,
     invoke_without_command=True,
     help="""\b