cloudsmith-cli 1.11.1__py2.py3-none-any.whl → 1.12.1__py2.py3-none-any.whl

cloudsmith_cli/cli/commands/__init__.py

@@ -12,6 +12,7 @@ from . import (
     help_,
     list_,
     login,
+    mcp,
     metrics,
     move,
     policy,

cloudsmith_cli/cli/commands/main.py

@@ -5,22 +5,31 @@ import click
 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
+from .. import command, decorators, utils
 
 CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
 
 
-def print_version():
+def print_version(opts):
     """Print the environment versions."""
-    click.echo("Versions:")
-    click.secho(
-        "CLI Package Version: %(version)s"
-        % {"version": click.style(get_cli_version(), bold=True)}
-    )
-    click.secho(
-        "API Package Version: %(version)s"
-        % {"version": click.style(get_api_version(), bold=True)}
-    )
+    cli_version = get_cli_version()
+    api_version = get_api_version()
+
+    data = {
+        "cli_version": cli_version,
+        "api_version": api_version,
+    }
+
+    if not utils.maybe_print_as_json(opts, data):
+        click.echo("Versions:")
+        click.secho(
+            "CLI Package Version: %(version)s"
+            % {"version": click.style(cli_version, bold=True)}
+        )
+        click.secho(
+            "API Package Version: %(version)s"
+            % {"version": click.style(api_version, bold=True)}
+        )
 
 
 @click.group(
@@ -52,12 +61,13 @@ For issues/contributing: %(github_website)s
     is_eager=True,
 )
 @decorators.common_cli_config_options
+@decorators.common_cli_output_options
 @click.pass_context
 def main(ctx, opts, version):
     """Handle entrypoint to CLI."""
     # pylint: disable=unused-argument
 
     if version:
-        print_version()
+        print_version(opts)
     elif ctx.invoked_subcommand is None:
         click.echo(ctx.get_help())

cloudsmith_cli/cli/commands/mcp.py

@@ -0,0 +1,432 @@
+"""Main command/entrypoint."""
+
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+import click
+import json5
+
+from ...core.mcp import server
+from ...core.mcp.data import OpenAPITool
+from .. import command, decorators, utils
+from .main import main
+
+SUPPORTED_MCP_CLIENTS = {
+    "claude": "Claude Desktop",
+    "cursor": "Cursor IDE",
+    "vscode": "VS Code",
+    "gemini-cli": "Gemini CLI",
+}
+
+
+@main.group(cls=command.AliasGroup, name="mcp")
+@decorators.common_cli_config_options
+@decorators.common_cli_output_options
+@decorators.common_api_auth_options
+@decorators.initialise_api
+@click.pass_context
+def mcp_(ctx, opts):  # pylint: disable=unused-argument
+    """
+    Start the Cloudsmith MCP Server
+
+    See the help for subcommands for more information on each.
+    """
+
+
+@mcp_.command(name="start")
+@decorators.initialise_api
+@decorators.initialise_mcp
+@click.pass_context
+def start(ctx, opts, mcp_server: server.DynamicMCPServer):
+    """
+    Start the MCP Server
+    """
+    mcp_server.run()
+
+
+@mcp_.command(name="list_tools")
+@decorators.common_cli_config_options
+@decorators.common_cli_output_options
+@decorators.common_api_auth_options
+@decorators.initialise_api
+@decorators.initialise_mcp
+@click.pass_context
+def list_tools(ctx, opts, mcp_server: server.DynamicMCPServer):
+    """
+    List available tools that will be exposed to the MCP Client
+    """
+    use_stderr = utils.should_use_stderr(opts)
+
+    if not use_stderr:
+        click.echo("Getting list of tools ... ", nl=False, err=use_stderr)
+
+    with utils.maybe_spinner(opts):
+        tools = mcp_server.list_tools()
+
+    if not use_stderr:
+        click.secho("OK", fg="green", err=use_stderr)
+
+    tools_data = [
+        {"name": name, "description": spec.description} for name, spec in tools.items()
+    ]
+
+    if utils.maybe_print_as_json(opts, tools_data):
+        return
+
+    print_tools(tools)
+
+
+@mcp_.command(name="list_groups")
+@decorators.common_cli_config_options
+@decorators.common_cli_output_options
+@decorators.common_api_auth_options
+@decorators.initialise_api
+@decorators.initialise_mcp
+@click.pass_context
+def list_groups(ctx, opts, mcp_server: server.DynamicMCPServer):
+    """
+    List available tool groups and the tools they contain
+    """
+    use_stderr = utils.should_use_stderr(opts)
+
+    if not use_stderr:
+        click.echo("Getting list of tool groups ... ", nl=False, err=use_stderr)
+
+    with utils.maybe_spinner(opts):
+        groups = mcp_server.list_groups()
+
+    if not use_stderr:
+        click.secho("OK", fg="green", err=use_stderr)
+
+    groups_data = [{"name": name, "tools": tools} for name, tools in groups.items()]
+
+    if utils.maybe_print_as_json(opts, groups_data):
+        return
+
+    print_groups(groups)
+
+
+def print_tools(tool_list: Dict[str, OpenAPITool]):
+    """Print tools as a table or output in another format."""
+
+    headers = [
+        "Name",
+        "Description",
+    ]
+
+    rows = []
+    for tool_name, tools_spec in tool_list.items():
+        rows.append(
+            [
+                click.style(tool_name, fg="cyan"),
+                click.style(tools_spec.description, fg="yellow"),
+            ]
+        )
+
+    if tool_list:
+        click.echo()
+        utils.pretty_print_table(headers, rows)
+
+    click.echo()
+
+    num_results = len(tool_list)
+    list_suffix = "tool%s visible" % ("s" if num_results != 1 else "")
+    utils.pretty_print_list_info(num_results=num_results, suffix=list_suffix)
+
+
+def print_groups(group_list: Dict[str, List[str]]):
+    """Print tool groups as a table or output in another format."""
+
+    headers = [
+        "Group Name",
+        "Tool Count",
+        "Sample Tools",
+    ]
+
+    rows = []
+    for group_name, tools in group_list.items():
+        # Show first 3 tools as samples
+        sample_tools = ", ".join(tools[:3])
+        if len(tools) > 3:
+            sample_tools += f", ... (+{len(tools) - 3} more)"
+
+        rows.append(
+            [
+                click.style(group_name, fg="cyan"),
+                click.style(str(len(tools)), fg="yellow"),
+                click.style(sample_tools, fg="white"),
+            ]
+        )
+
+    if group_list:
+        click.echo()
+        utils.pretty_print_table(headers, rows)
+
+    click.echo()
+
+    num_results = len(group_list)
+    list_suffix = "group%s visible" % ("s" if num_results != 1 else "")
+    utils.pretty_print_list_info(num_results=num_results, suffix=list_suffix)
+
+
+@mcp_.command(name="configure")
+@decorators.common_cli_config_options
+@decorators.common_cli_output_options
+@decorators.common_api_auth_options
+@click.option(
+    "--client",
+    type=click.Choice(list(SUPPORTED_MCP_CLIENTS.keys()), case_sensitive=False),
+    help=f"MCP client to configure ({', '.join(SUPPORTED_MCP_CLIENTS.keys())}). If not specified, will attempt to detect and configure all.",
+)
+@click.option(
+    "--global/--local",
+    "is_global",
+    default=True,
+    help="Configure globally (default) or in current project directory (local)",
+)
+@decorators.initialise_api
+@click.pass_context
+def configure(ctx, opts, client, is_global):  # pylint: disable=unused-argument
+    """
+    Configure the Cloudsmith MCP server for supported clients.
+
+    This command automatically adds the Cloudsmith MCP server configuration
+    to the specified client's configuration file. Supported clients are:
+    - Claude Desktop
+    - Cursor IDE
+    - VS Code (GitHub Copilot)
+    - Gemini CLI
+
+    Examples:\n
+        cloudsmith mcp configure --client claude\n
+        cloudsmith mcp configure --client cursor --local\n
+        cloudsmith mcp configure --client gemini-cli\n
+        cloudsmith mcp configure  # Auto-detect and configure all
+    """
+
+    use_stderr = utils.should_use_stderr(opts)
+
+    # Get the profile from context
+    profile = ctx.meta.get("profile")
+
+    # Determine the best command to run the MCP server
+    server_config = _get_server_config(profile)
+
+    clients_to_configure = []
+    if client:
+        clients_to_configure = [client.lower()]
+    else:
+        # Auto-detect available clients
+        clients_to_configure = detect_available_clients()
+
+    if not clients_to_configure:
+        if not use_stderr:
+            click.echo(click.style("No supported MCP clients detected.", fg="yellow"))
+            click.echo("\nSupported clients:")
+            for display_name in SUPPORTED_MCP_CLIENTS.values():
+                click.echo(f"  - {display_name}")
+
+        utils.maybe_print_as_json(opts, [])
+        return
+
+    results = []
+    success_count = 0
+    for client_name in clients_to_configure:
+        try:
+            if configure_client(client_name, server_config, is_global, profile):
+                if not use_stderr:
+                    click.echo(
+                        click.style(f"✓ Configured {client_name.title()}", fg="green")
+                    )
+                success_count += 1
+                results.append({"client": client_name, "success": True})
+            else:
+                if not use_stderr:
+                    click.echo(
+                        click.style(
+                            f"✗ Failed to configure {client_name.title()}", fg="red"
+                        )
+                    )
+                results.append(
+                    {
+                        "client": client_name,
+                        "success": False,
+                        "error": "Configuration failed",
+                    }
+                )
+        except (OSError, ValueError) as e:
+            if not use_stderr:
+                click.echo(
+                    click.style(
+                        f"✗ Error configuring {client_name.title()}: {str(e)}", fg="red"
+                    )
+                )
+            results.append({"client": client_name, "success": False, "error": str(e)})
+
+    if utils.maybe_print_as_json(opts, results):
+        return
+
+    if success_count > 0:
+        click.echo(
+            click.style(
+                f"\n✓ Successfully configured {success_count} client(s)", fg="green"
+            )
+        )
+        click.echo(
+            "\nNote: You may need to restart the client application for changes to take effect."
+        )
+    else:
+        click.echo(click.style("\n✗ No clients were configured successfully", fg="red"))
+
+
+def _get_server_config(profile=None):
+    """Determine the first available command configuration to run the MCP server."""
+    # Check if running in a virtual environment
+    in_venv = hasattr(sys, "real_prefix") or (
+        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+    )
+
+    # Build the base args
+    base_args = []
+    if profile:
+        base_args.extend(["-P", profile])
+
+    # In a venv, always use python -m to ensure we use the venv's packages
+    if in_venv:
+        return {
+            "command": sys.executable,
+            "args": ["-m", "cloudsmith_cli"] + base_args + ["mcp", "start"],
+        }
+
+    # Otherwise, try to find cloudsmith in PATH, fall back to python -m
+    cloudsmith_cmd = shutil.which("cloudsmith")
+    if cloudsmith_cmd:
+        return {"command": cloudsmith_cmd, "args": base_args + ["mcp", "start"]}
+
+    return {
+        "command": sys.executable,
+        "args": ["-m", "cloudsmith_cli"] + base_args + ["mcp", "start"],
+    }
+
+
+def detect_available_clients():
+    """Detect which MCP clients are available on the system."""
+    available = []
+
+    for client in SUPPORTED_MCP_CLIENTS:
+        config = get_config_path(client, is_global=True)
+        if config and config.parent.exists():
+            available.append(client)
+
+    return available
+
+
+def get_config_path(client_name, is_global=True):
+    """Get the configuration file path for a given client."""
+    home = Path.home()
+    appdata = os.getenv("APPDATA", "")
+
+    # Configuration paths by client, platform, and scope
+    config_paths = {
+        "claude": {
+            "darwin": home
+            / "Library"
+            / "Application Support"
+            / "Claude"
+            / "claude_desktop_config.json",
+            "win32": (
+                Path(appdata) / "Claude" / "claude_desktop_config.json"
+                if appdata
+                else None
+            ),
+            "linux": home / ".config" / "Claude" / "claude_desktop_config.json",
+        },
+        "cursor": {
+            "global": home / ".cursor" / "mcp.json",
+            "local": Path.cwd() / ".cursor" / "mcp.json",
+        },
+        "vscode": {
+            "darwin": home
+            / "Library"
+            / "Application Support"
+            / "Code"
+            / "User"
+            / "settings.json",
+            "win32": (
+                Path(appdata) / "Code" / "User" / "settings.json" if appdata else None
+            ),
+            "linux": home / ".config" / "Code" / "User" / "settings.json",
+            "local": Path.cwd() / ".vscode" / "settings.json",
+        },
+        "gemini-cli": {
+            "global": home / ".gemini" / "settings.json",
+            "local": Path.cwd() / ".gemini" / "settings.json",
+        },
+    }
+
+    client_config = config_paths.get(client_name, {})
+
+    # For Cursor and Gemini CLI, use global/local scope instead of platform
+    if client_name in ("cursor", "gemini-cli"):
+        scope = "global" if is_global else "local"
+        return client_config.get(scope)
+
+    # For VS Code local config
+    if client_name == "vscode" and not is_global:
+        return client_config.get("local")
+
+    # For platform-specific configs (Claude and VS Code global)
+    platform = sys.platform if sys.platform in ("darwin", "win32") else "linux"
+    return client_config.get(platform)
+
+
+def configure_client(client_name, server_config, is_global=True, profile=None):
+    """Configure a specific MCP client with the Cloudsmith server."""
+    config_path = get_config_path(client_name, is_global)
+
+    if not config_path:
+        return False
+
+    # Ensure parent directory exists
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Read existing config or create new one
+    config = {}
+    if config_path.exists():
+        with open(config_path) as f:
+            content = f.read()
+        try:
+            # Use json5 first as it handles both standard JSON and JSONC
+            # (comments, trailing commas) which VS Code settings.json may contain
+            config = json5.loads(content)
+        except (json.JSONDecodeError, ValueError) as e:
+            raise ValueError(
+                f"Cannot parse config file '{config_path}': {e}. "
+                f"Please fix the JSON syntax or remove the file to create a new one."
+            ) from e
+
+    # Determine server name based on profile
+    server_name = f"cloudsmith-{profile}" if profile else "cloudsmith"
+
+    # Add Cloudsmith MCP server based on client format
+    if client_name in {"claude", "cursor", "gemini-cli"}:
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+        config["mcpServers"][server_name] = server_config
+
+    elif client_name == "vscode":
+        # VS Code uses a different format in settings.json
+        if "chat.mcp.servers" not in config:
+            config["chat.mcp.servers"] = {}
+        config["chat.mcp.servers"][server_name] = server_config
+
+    # Write updated config
+    with open(config_path, "w") as f:
+        # As we are using json5 to read, we write standard JSON back, which removes existing user JSON comments in the files (currently only present in VS Code settings.json).
+        json.dump(config, f, indent=2)
+
+    return True

cloudsmith_cli/cli/commands/metrics/entitlements.py

@@ -75,7 +75,7 @@ def _print_metrics_table(opts, data):
     type=str,
     required=False,
     help=(
-        "A comma seperated list of entitlement token identifiers (i.e. slug_perm) or "
+        "A comma separated list of entitlement token identifiers (i.e. slug_perm) or "
         "token secrets. If a list is not specified then all entitlement tokens will "
         "be included for a given namespace or repository."
     ),

cloudsmith_cli/cli/commands/metrics/packages.py

@@ -74,7 +74,7 @@ def _print_metrics_table(opts, data):
     type=str,
     required=False,
     help=(
-        "A comma seperated list of package identifiers (i.e. slug_perm). "
+        "A comma separated list of package identifiers (i.e. slug_perm). "
         "If a list is not specified then all package will be included for "
         "a given repository."
     ),

cloudsmith_cli/cli/commands/upstream.py

@@ -24,6 +24,7 @@ UPSTREAM_FORMATS = [
     "dart",
     "deb",
     "docker",
+    "generic",
     "go",
     "helm",
     "hex",

cloudsmith_cli/cli/config.py

@@ -64,6 +64,8 @@ class ConfigSchema:
         api_proxy = ConfigParam(name="api_proxy", type=str)
         api_ssl_verify = ConfigParam(name="api_ssl_verify", type=bool, default=True)
         api_user_agent = ConfigParam(name="api_user_agent", type=str)
+        mcp_allowed_tools = ConfigParam(name="mcp_allowed_tools", type=str)
+        mcp_allowed_tool_groups = ConfigParam(name="mcp_allowed_tool_groups", type=str)
 
     @matches_section("profile:*")
     class Profile(Default):
@@ -95,7 +97,7 @@ class ConfigReader(ConfigFileReader):
 
     @classmethod
     def get_default_filepath(cls):
-        """Get the default filepath for the configuratin file."""
+        """Get the default filepath for the configuration file."""
         if not cls.config_files:
             return None
         if not cls.config_searchpath:
@@ -348,6 +350,34 @@ class Options:
         """Set value for debug flag."""
         self._set_option("debug", bool(value))
 
+    @property
+    def mcp_allowed_tools(self):
+        """Get value for Allowed MCP Tools."""
+        return self._get_option("mcp_allowed_tools")
+
+    @mcp_allowed_tools.setter
+    def mcp_allowed_tools(self, value):
+        """Set value for Allowed MCP Tools."""
+        if not value:
+            return
+        tools = [tool.strip() for tool in value.split(",")]
+
+        self._set_option("mcp_allowed_tools", tools)
+
+    @property
+    def mcp_allowed_tool_groups(self):
+        """Get value for Allowed MCP Tool Groups."""
+        return self._get_option("mcp_allowed_tool_groups")
+
+    @mcp_allowed_tool_groups.setter
+    def mcp_allowed_tool_groups(self, value):
+        """Set value for Allowed MCP Tool Groups."""
+        if not value:
+            return
+        tool_groups = [group.strip() for group in value.split(",")]
+
+        self._set_option("mcp_allowed_tool_groups", tool_groups)
+
     @property
     def output(self):
         """Get value for output format."""

cloudsmith_cli/cli/decorators.py

@@ -7,6 +7,7 @@ import click
 from cloudsmith_cli.cli import validators
 
 from ..core.api.init import initialise_api as _initialise_api
+from ..core.mcp import server
 from . import config, utils
 
 
@@ -93,9 +94,15 @@ def common_cli_config_options(f):
     def wrapper(ctx, *args, **kwargs):
         # pylint: disable=missing-docstring
         opts = config.get_or_create_options(ctx)
-        profile = kwargs.pop("profile")
-        config_file = kwargs.pop("config_file")
-        creds_file = kwargs.pop("credentials_file")
+        profile = kwargs.pop("profile") or ctx.meta.get("profile")
+        config_file = kwargs.pop("config_file") or ctx.meta.get("config_file")
+        creds_file = kwargs.pop("credentials_file") or ctx.meta.get("creds_file")
+
+        # Store in context for subcommands to inherit
+        ctx.meta["profile"] = profile
+        ctx.meta["config_file"] = config_file
+        ctx.meta["creds_file"] = creds_file
+
         opts.load_config_file(path=config_file, profile=profile)
         opts.load_creds_file(path=creds_file, profile=profile)
         kwargs["opts"] = opts
@@ -330,3 +337,40 @@ def initialise_api(f):
         return ctx.invoke(f, *args, **kwargs)
 
     return wrapper
+
+
+def initialise_mcp(f):
+    @click.option(
+        "-a",
+        "--all-tools",
+        default=False,
+        is_flag=True,
+        help="Show all tools",
+    )
+    @click.option(
+        "-D",
+        "--allow-destructive-tools",
+        default=False,
+        is_flag=True,
+        help="Allow destructive tools to be used",
+    )
+    @click.pass_context
+    @functools.wraps(f)
+    def wrapper(ctx, *args, **kwargs):
+        opts = kwargs.get("opts")
+
+        all_tools = kwargs.pop("all_tools")
+        allow_destructive_tools = kwargs.pop("allow_destructive_tools")
+
+        mcp_server = server.DynamicMCPServer(
+            api_config=opts.api_config,
+            debug_mode=opts.debug,
+            allow_destructive_tools=allow_destructive_tools,
+            allowed_tool_groups=opts.mcp_allowed_tool_groups,
+            allowed_tools=opts.mcp_allowed_tools,
+            force_all_tools=all_tools,
+        )
+        kwargs["mcp_server"] = mcp_server
+        return ctx.invoke(f, *args, **kwargs)
+
+    return wrapper

cloudsmith_cli/cli/tests/commands/test_main.py

@@ -1,3 +1,5 @@
+import json
+
 import pytest
 
 from ....core.api.version import get_version as get_api_version
@@ -17,6 +19,32 @@ class TestMainCommand:
             "API Package Version: " + get_api_version() + "\n"
         )
 
+    @pytest.mark.parametrize("option", ["-V", "--version"])
+    @pytest.mark.parametrize(
+        "format_option,format_value",
+        [("-F", "json"), ("--output-format", "json")],
+    )
+    def test_main_version_json(self, runner, option, format_option, format_value):
+        """Test the JSON output of `cloudsmith --version --output-format json`."""
+        result = runner.invoke(main, [option, format_option, format_value])
+        assert result.exit_code == 0
+        output = json.loads(result.output)
+        assert "data" in output
+        assert output["data"]["cli_version"] == get_version()
+        assert output["data"]["api_version"] == get_api_version()
+
+    @pytest.mark.parametrize("option", ["-V", "--version"])
+    def test_main_version_pretty_json(self, runner, option):
+        """Test the pretty JSON output of `cloudsmith --version --output-format pretty_json`."""
+        result = runner.invoke(main, [option, "--output-format", "pretty_json"])
+        assert result.exit_code == 0
+        output = json.loads(result.output)
+        assert "data" in output
+        assert output["data"]["cli_version"] == get_version()
+        assert output["data"]["api_version"] == get_api_version()
+        # Verify it's formatted with indentation
+        assert "    " in result.output
+
     @pytest.mark.parametrize("option", ["-h", "--help"])
     def test_main_help(self, runner, option):
         """Test the output of `cloudsmith --help`."""