cloudsmith-cli 1.20.2__tar.gz → 1.22.0__tar.gz

{cloudsmith_cli-1.20.2/cloudsmith_cli.egg-info → cloudsmith_cli-1.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudsmith-cli
-Version: 1.20.2
+Version: 1.22.0
 Summary: Cloudsmith Command-Line Interface (CLI)
 Author-email: Cloudsmith Ltd <support@cloudsmith.io>
 License-Expression: Apache-2.0
@@ -30,7 +30,7 @@ Requires-Dist: click-spinner>=0.1.7
 Requires-Dist: json5>=0.9.0
 Requires-Dist: cloudsmith-api<3.0,>=2.0.29
 Requires-Dist: keyring>=25.4.1
-Requires-Dist: mcp==1.27.2
+Requires-Dist: mcp==1.28.1
 Requires-Dist: PyJWT[crypto]>=2.0.0
 Requires-Dist: python-toon==0.1.2
 Requires-Dist: requests>=2.18.4

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/command.py

@@ -24,9 +24,12 @@ def _is_json_output_requested(exception):
         return True
 
     for idx, arg in enumerate(argv):
-        if arg in ("-F", "--output-format") and idx + 1 < len(argv):
-            if argv[idx + 1] in ("json", "pretty_json"):
-                return True
+        if (
+            arg in ("-F", "--output-format")
+            and idx + 1 < len(argv)
+            and argv[idx + 1] in ("json", "pretty_json")
+        ):
+            return True
 
     return False
 
@@ -88,9 +91,8 @@ class AliasGroup(DYMGroup):
         return commands
 
     def get_command(self, ctx, cmd_name):
-        if getattr(ctx, "showing_help", False):
-            if "|" in cmd_name:
-                cmd_name = cmd_name.split("|")[0]
+        if getattr(ctx, "showing_help", False) and "|" in cmd_name:
+            cmd_name = cmd_name.split("|")[0]
 
         try:
             cmd_name = self.inverse[cmd_name]

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/__init__.py

@@ -8,6 +8,7 @@ from . import (
     delete,
     dependencies,
     docs,
+    domains,
     download,
     entitlements,
     help_,

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/auth.py

@@ -133,7 +133,7 @@ def authenticate(
             err=True,
         )
 
-    owner = owner[0].strip("'[]'")
+    owner = owner[0].strip("[]'")
 
     click.echo(
         f"Beginning authentication for the {click.style(owner, bold=True)} org ... ",

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/check.py

@@ -33,9 +33,11 @@ def rates(ctx, opts):
     click.echo("Retrieving rate limits ... ", nl=False, err=use_stderr)
 
     context_msg = "Failed to retrieve status!"
-    with handle_api_exceptions(ctx, opts=opts, context_msg=context_msg):
-        with maybe_spinner(opts):
-            resources_limits = get_rate_limits()
+    with (
+        handle_api_exceptions(ctx, opts=opts, context_msg=context_msg),
+        maybe_spinner(opts),
+    ):
+        resources_limits = get_rate_limits()
 
     click.secho("OK", fg="green", err=use_stderr)
 
@@ -53,11 +55,10 @@ def rates(ctx, opts):
                     "Yes" if limits.throttled else "No",
                     fg="red" if limits.throttled else "green",
                 ),
-                "%(remaining)s/%(limit)s"
-                % {
-                    "remaining": click.style(str(limits.remaining), fg="yellow"),
-                    "limit": click.style(str(limits.limit), fg="yellow"),
-                },
+                "{remaining}/{limit}".format(
+                    remaining=click.style(str(limits.remaining), fg="yellow"),
+                    limit=click.style(str(limits.limit), fg="yellow"),
+                ),
                 click.style(str(limits.interval), fg="blue"),
                 click.style(str(limits.reset), fg="magenta"),
             ]
@@ -85,9 +86,11 @@ def service(ctx, opts):
     click.echo("Retrieving service status ... ", nl=False, err=use_stderr)
 
     context_msg = "Failed to retrieve status!"
-    with handle_api_exceptions(ctx, opts=opts, context_msg=context_msg):
-        with maybe_spinner(opts):
-            status, version = get_status(with_version=True)
+    with (
+        handle_api_exceptions(ctx, opts=opts, context_msg=context_msg),
+        maybe_spinner(opts),
+    ):
+        status, version = get_status(with_version=True)
 
     click.secho("OK", fg="green", err=use_stderr)
 

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/copy.py

@@ -59,24 +59,21 @@ def copy(
     use_stderr = utils.should_use_stderr(opts)
 
     click.echo(
-        "Copying %(slug)s package from %(source)s to %(dest)s ... "
-        % {
-            "slug": click.style(slug, bold=True),
-            "source": click.style(source, bold=True),
-            "dest": click.style(destination, bold=True),
-        },
+        f"Copying {click.style(slug, bold=True)} package from {click.style(source, bold=True)} to {click.style(destination, bold=True)} ... ",
         nl=False,
         err=use_stderr,
     )
 
     context_msg = "Failed to copy package!"
-    with handle_api_exceptions(
-        ctx, opts=opts, context_msg=context_msg, reraise_on_error=skip_errors
+    with (
+        handle_api_exceptions(
+            ctx, opts=opts, context_msg=context_msg, reraise_on_error=skip_errors
+        ),
+        maybe_spinner(opts),
     ):
-        with maybe_spinner(opts):
-            _, new_slug = copy_package(
-                owner=owner, repo=source, identifier=slug, destination=destination
-            )
+        _, new_slug = copy_package(
+            owner=owner, repo=source, identifier=slug, destination=destination
+        )
 
     click.secho("OK", fg="green", err=use_stderr)
 

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/credential_helper/__init__.py

@@ -10,6 +10,7 @@ import click
 
 from ..main import main
 from .docker import docker as docker_cmd
+from .generic import generic as generic_cmd
 from .manage import install_cmd, list_cmd, uninstall_cmd
 
 
@@ -32,6 +33,7 @@ def credential_helper():
 
 
 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")

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/credential_helper/docker.py

@@ -29,7 +29,8 @@ def docker(opts, operation):
 
     Provides credentials for all Cloudsmith Docker registries: ``*.cloudsmith.io``,
     ``*.cloudsmith.com``, and any custom domains configured for the organisation
-    (requires CLOUDSMITH_ORG and a valid API key/token).
+    (requires an organisation - ``--org``, CLOUDSMITH_ORG or ``org`` in
+    ``config.ini`` - and a valid API key/token).
 
     Input (stdin):
         Server URL as plain text (e.g. "docker.cloudsmith.io")
@@ -57,6 +58,7 @@ def docker(opts, operation):
         sys.stdin,
         credential=opts.credential,
         api_host=opts.api_host,
+        org=opts.org,
     )
 
     if stdout is not None:

cloudsmith_cli-1.22.0/cloudsmith_cli/cli/commands/credential_helper/generic.py

@@ -0,0 +1,62 @@
+# Copyright 2026 Cloudsmith Ltd
+"""
+Generic credential helper command.
+
+Emits a versioned JSON credential document.
+"""
+
+import sys
+
+import click
+
+from ....credential_helpers.generic import execute
+from ...decorators import (
+    common_api_auth_options,
+    common_cli_config_options,
+    resolve_credentials,
+)
+
+
+@click.command()
+@common_cli_config_options
+@common_api_auth_options
+@resolve_credentials
+def generic(opts):
+    """
+    Emit a Cloudsmith credential as JSON.
+
+    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
+    which credential resolves.
+
+    \b
+    Output (stdout):
+        JSON: {"version": 1, "username": "token", "password": "<token>"}
+
+    \b
+    Exit codes:
+        0: Success
+        1: No credential could be resolved
+
+    Examples:
+
+    \b
+        # Resolve a credential
+        $ cloudsmith credential-helper generic
+
+    \b
+        # Extract just the token
+        $ cloudsmith credential-helper generic | jq -r .password
+
+    \b
+    Environment variables:
+        CLOUDSMITH_API_KEY: API key for authentication (optional)
+    """
+    exit_code, stdout, stderr = execute(credential=opts.credential)
+
+    if stdout is not None:
+        click.echo(stdout)
+    if stderr is not None:
+        click.echo(stderr, err=True)
+    sys.exit(exit_code)

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/credential_helper/manage.py

@@ -8,7 +8,6 @@ Provides ``credential-helper install``, ``credential-helper uninstall``, and
 
 from __future__ import annotations
 
-import os
 import sys
 
 import click
@@ -94,11 +93,6 @@ def _get_installer(name: str):
     default=False,
     help="Bypass the custom-domain cache and fetch fresh data from the API.",
 )
-@click.option(
-    "--org",
-    default=None,
-    help="Cloudsmith organisation slug for custom-domain discovery.",
-)
 @common_cli_config_options
 @common_cli_output_options
 @common_api_auth_options
@@ -113,7 +107,6 @@ def install_cmd(
     dry_run: bool,
     no_discover: bool,
     refresh: bool,
-    org: str | None,
 ) -> None:
     """Install a credential helper launcher and configure the package manager.
 
@@ -138,13 +131,6 @@ def install_cmd(
         $ cloudsmith credential-helper install docker --no-discover
     """
     installer = _get_installer(helper)
-    org = org or os.environ.get("CLOUDSMITH_ORG", "").strip() or None
-    api_key = opts.credential.api_key if opts.credential else None
-    auth_type = (
-        getattr(opts.credential, "auth_type", "api_key")
-        if opts.credential
-        else "api_key"
-    )
     try:
         actions = installer.install(
             bin_dir=bin_dir,
@@ -152,9 +138,8 @@ def install_cmd(
             dry_run=dry_run,
             discover=not no_discover,
             refresh=refresh,
-            org=org,
-            api_key=api_key,
-            auth_type=auth_type,
+            org=opts.org,
+            credential=opts.credential,
             api_host=opts.api_host,
         )
     except OSError as exc:

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/delete.py

@@ -47,20 +47,22 @@ def delete(ctx, opts, owner_repo_package, yes):
 
     use_stderr = utils.should_use_stderr(opts)
 
-    prompt = "delete the %(package)s from %(owner)s/%(repo)s" % delete_args
+    prompt = "delete the {package} from {owner}/{repo}".format(**delete_args)
     if not utils.confirm_operation(prompt, assume_yes=yes, err=use_stderr):
         return
 
     click.echo(
-        "Deleting %(package)s from %(owner)s/%(repo)s ... " % delete_args,
+        "Deleting {package} from {owner}/{repo} ... ".format(**delete_args),
         nl=False,
         err=use_stderr,
     )
 
     context_msg = "Failed to delete the package!"
-    with handle_api_exceptions(ctx, opts=opts, context_msg=context_msg):
-        with maybe_spinner(opts):
-            delete_package(owner=owner, repo=repo, identifier=slug)
+    with (
+        handle_api_exceptions(ctx, opts=opts, context_msg=context_msg),
+        maybe_spinner(opts),
+    ):
+        delete_package(owner=owner, repo=repo, identifier=slug)
 
     click.secho("OK", fg="green", err=use_stderr)
 

{cloudsmith_cli-1.20.2 → cloudsmith_cli-1.22.0}/cloudsmith_cli/cli/commands/dependencies.py

@@ -53,23 +53,20 @@ def list_dependencies(ctx, opts, owner_repo_package):
     use_stderr = utils.should_use_stderr(opts)
 
     click.echo(
-        "Getting direct (non-transitive) dependencies of %(package)s in "
-        "%(owner)s/%(repo)s ... "
-        % {
-            "owner": click.style(owner, bold=True),
-            "repo": click.style(repo, bold=True),
-            "package": click.style(identifier, bold=True),
-        },
+        f"Getting direct (non-transitive) dependencies of {click.style(identifier, bold=True)} in "
+        f"{click.style(owner, bold=True)}/{click.style(repo, bold=True)} ... ",
         nl=False,
         err=use_stderr,
     )
 
     context_msg = "Failed to get dependencies of package!"
-    with handle_api_exceptions(ctx, opts=opts, context_msg=context_msg):
-        with maybe_spinner(opts):
-            deps, page_info = get_package_dependencies(
-                owner=owner, repo=repo, identifier=identifier
-            )
+    with (
+        handle_api_exceptions(ctx, opts=opts, context_msg=context_msg),
+        maybe_spinner(opts),
+    ):
+        deps, page_info = get_package_dependencies(
+            owner=owner, repo=repo, identifier=identifier
+        )
 
     click.secho("OK", fg="green", err=use_stderr)
 

cloudsmith_cli-1.22.0/cloudsmith_cli/cli/commands/domains.py

@@ -0,0 +1,301 @@
+# Copyright 2026 Cloudsmith Ltd
+"""List the hosts Cloudsmith can authenticate: built-in and custom domains.
+
+The built-in ``*.cloudsmith.io`` service hosts ship with the CLI so that every
+consumer shares one authoritative table; custom domains cannot be inferred, so
+discovering them requires an API lookup.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+import click
+from click.core import ParameterSource
+
+from ...core.api.exceptions import ApiException
+from ...core.pagination import PageInfo
+from ...credential_helpers.custom_domains import (
+    get_custom_domains,
+    order_by_precedence,
+    read_all_cached_domains,
+)
+from ...credential_helpers.default_domains import (
+    DomainType,
+    format_for_backend_kind,
+    load_default_domains,
+    untrusted_config_declares_domains,
+)
+from .. import command
+from ..config import get_default_config_path
+from ..decorators import (
+    common_api_auth_options,
+    common_cli_config_options,
+    common_cli_list_options,
+    initialise_api,
+)
+from .main import main
+
+PROTOCOL_VERSION = 1
+
+
+def _label(value: str | None) -> str | None:
+    """Normalise a filter value for comparison, or None if it is empty."""
+    return (value or "").strip().lower() or None
+
+
+def _serves_format(entry_format: str | None, wanted: str | None) -> bool:
+    """Whether an entry's format satisfies a ``--format`` filter."""
+    return wanted is None or entry_format is None or entry_format == wanted
+
+
+def _is_domain_type(domain_type: DomainType, wanted: str | None) -> bool:
+    """Whether a host's purpose satisfies a ``--domain-type`` filter."""
+    return wanted is None or domain_type.value == wanted
+
+
+def _custom_entries(records) -> list[dict]:
+    """Render custom-domain records as document entries, in the order given."""
+    return [
+        {
+            "host": record.host,
+            "format": format_for_backend_kind(record.backend_kind),
+            "type": "custom",
+            "domain_type": record.domain_type.value,
+            "org": record.org,
+            "repository": record.repository,
+            "primary": record.primary,
+            "created_at": record.created_at,
+        }
+        for record in records
+    ]
+
+
+@main.group(name="domains", cls=command.AliasGroup, aliases=["domain"])
+def domains_():
+    """
+    Inspect the Cloudsmith domains the CLI can authenticate.
+
+    See the help for subcommands for more information on each.
+    """
+
+
+@domains_.command(name="list", aliases=["ls"])
+@click.option(
+    "--refresh",
+    is_flag=True,
+    default=False,
+    help="Bypass the custom-domain cache and fetch fresh data from the API.",
+)
+@click.option(
+    "--format",
+    "format_",
+    default=None,
+    help="Only list hosts usable for this package format. Hosts that serve no "
+    "single format (the download CDN, the generic upload endpoint) serve every "
+    "format and are always listed.",
+)
+@click.option(
+    "--domain-type",
+    "domain_type",
+    default=None,
+    help="Only list hosts with this purpose: download, upload, or native_api. "
+    "Every host has exactly one, so this is an exact match.",
+)
+@click.option(
+    "--repo",
+    "--repository",
+    "repo",
+    default=None,
+    help="Only list hosts usable for this repository, most-preferred first. "
+    "Drops custom domains bound to a different repository.",
+)
+@common_cli_config_options
+@common_cli_list_options
+@common_api_auth_options
+@initialise_api
+@click.pass_context
+def list_domains(  # pylint: disable=too-many-arguments
+    ctx,
+    opts,
+    refresh: bool,
+    format_: str | None,
+    domain_type: str | None,
+    repo: str | None,
+    page: int,
+    page_size: int,
+    page_all: bool,
+) -> None:
+    """Emit the Cloudsmith hosts and their package formats as JSON.
+
+    Machine-readable output for programmatic consumers. It lists the built-in
+    ``*.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
+    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.
+
+    Where two custom domains could serve the same request Cloudsmith picks the
+    one bound to the repository in hand, then ``primary`` over secondary, then
+    the oldest — so ``created_at`` is reported to make that order reproducible.
+    The custom domains are always listed in that order, so the first is the one
+    Cloudsmith would bind; ``--repo`` is what lets the repository-bound hosts
+    take part in it.
+
+    Results support the same --page/--page-size (-p/-l) options as other
+    `list` commands, selecting a page of the combined, filtered list. Unlike
+    those commands, this one defaults to --page-all (--show-all): the
+    combined list is small and built from a local cache rather than a live
+    paginated endpoint, so there is no benefit to hiding entries by default.
+    Passing --page or --page-size switches to paged output.
+
+    Output (stdout):
+        JSON: {"version": 1, "domains": [{"host": ..., "format": ...,
+        "type": ..., "domain_type": ..., "org": ..., "repository": ...,
+        "primary": ..., "created_at": ...}], "meta": {"pagination": {...}}}
+
+        "meta" is only present when the result is paginated (i.e. not
+        --page-all), and mirrors the pagination metadata other `list`
+        commands emit for `-F json`.
+
+    Examples:
+
+    \b
+        # List built-in hosts plus any custom domains already cached
+        $ cloudsmith domains list
+
+    \b
+        # List built-in hosts plus an organisation's custom domains
+        $ cloudsmith domains list --org my-org
+
+    \b
+        # The hosts usable for one repository, most-preferred first
+        $ cloudsmith domains list --org my-org --repo my-repo --format maven
+
+    \b
+        # Where to upload to
+        $ cloudsmith domains list --org my-org --domain-type upload
+    """
+    if not page_all:
+        explicit_sources = {
+            src
+            for src in (
+                ParameterSource.COMMANDLINE,
+                ParameterSource.ENVIRONMENT,
+                getattr(ParameterSource, "PROMPT", None),
+            )
+            if src is not None
+        }
+        page_explicit = ctx.get_parameter_source("page") in explicit_sources
+        page_size_explicit = ctx.get_parameter_source("page_size") in explicit_sources
+        if not page_explicit and not page_size_explicit:
+            # Unlike other `list` commands, domains list defaults to showing
+            # everything: the combined list is small and built from a local
+            # cache, so paging by default would hide entries for no benefit.
+            page_all = True
+
+    explicit_config = ctx.meta.get("config_file")
+    if explicit_config and os.path.isdir(explicit_config):
+        explicit_config = os.path.join(explicit_config, "config.ini")
+
+    if explicit_config is None and untrusted_config_declares_domains():
+        click.secho(
+            "Warning: ignoring [domains] section in ./config.ini -- config.ini "
+            "in the current directory is untrusted. Put it in "
+            f"{get_default_config_path()} or ~/.cloudsmith instead.",
+            fg="yellow",
+            err=True,
+        )
+
+    wanted_format = _label(format_)
+    wanted_type = _label(domain_type)
+    repository = _label(repo)
+
+    default_entries = [
+        {
+            "host": domain.host,
+            "format": domain.format_label,
+            "type": "default",
+            "domain_type": domain.domain_type.value,
+            "org": None,
+            "repository": None,
+            "primary": True,
+            "created_at": None,
+        }
+        for domain in load_default_domains(config_path=explicit_config)
+        if _serves_format(domain.format_label, wanted_format)
+        and _is_domain_type(domain.domain_type, wanted_type)
+    ]
+
+    org = opts.org
+    if org:
+        try:
+            records = get_custom_domains(
+                org,
+                credential=opts.credential,
+                api_host=opts.api_host,
+                refresh=refresh,
+                strict=True,
+                configure_api=False,
+            )
+        except ApiException as exc:
+            raise click.ClickException(
+                f"Failed to fetch custom domains for {org!r}: {exc}"
+            ) from exc
+    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.",
+                fg="yellow",
+                err=True,
+            )
+        records = read_all_cached_domains()
+
+    records = [
+        record
+        for record in records
+        if _serves_format(format_for_backend_kind(record.backend_kind), wanted_format)
+        and _is_domain_type(record.domain_type, wanted_type)
+        and record.is_active
+        and (repository is None or record.serves_repository(repository))
+    ]
+    records = sorted(
+        order_by_precedence(records, repository), key=lambda record: record.org
+    )
+
+    data = _custom_entries(records) + default_entries
+
+    document = {"version": PROTOCOL_VERSION, "domains": data}
+
+    if not page_all:
+        if page < 1 or page_size < 1:
+            raise click.UsageError("--page and --page-size must be positive.")
+
+        total = len(data)
+        start = (page - 1) * page_size
+        page_info = PageInfo()
+        page_info.count = total
+        page_info.page = page
+        page_info.page_size = page_size
+        page_info.page_total = -(-total // page_size) or 1
+
+        document["domains"] = data[start : start + page_size]
+        document["meta"] = {
+            "pagination": page_info.as_dict(num_results=len(document["domains"]))
+        }
+
+    click.echo(json.dumps(document))