data-designer 0.4.0rc3__py3-none-any.whl → 0.5.0rc1__py3-none-any.whl

data_designer/cli/commands/list.py

@@ -3,13 +3,53 @@
 
 from __future__ import annotations
 
+import re
+
 from rich.table import Table
 
+from data_designer.cli.repositories.mcp_provider_repository import MCPProviderRepository
 from data_designer.cli.repositories.model_repository import ModelRepository
 from data_designer.cli.repositories.provider_repository import ProviderRepository
+from data_designer.cli.repositories.tool_repository import ToolRepository
 from data_designer.cli.ui import console, print_error, print_header, print_info, print_warning
+from data_designer.config.mcp import LocalStdioMCPProvider, MCPProvider
 from data_designer.config.utils.constants import DATA_DESIGNER_HOME, NordColor
 
+# Pattern for valid environment variable names (uppercase letters, digits, underscores, not starting with digit)
+_ENV_VAR_PATTERN = re.compile(r"^[A-Z_][A-Z0-9_]*$")
+
+
+def _is_env_var_name(value: str) -> bool:
+    """Check if a string looks like an environment variable name.
+
+    Returns True only if the string matches the pattern for typical env var names:
+    - All uppercase letters, digits, and underscores only
+    - Does not start with a digit
+    - At least one character
+
+    This is intentionally conservative to avoid leaking secrets that happen
+    to be uppercase (e.g., base32-encoded API keys).
+    """
+    return bool(_ENV_VAR_PATTERN.match(value))
+
+
+def _mask_api_key(api_key: str | None) -> str:
+    """Mask an API key for display, preserving environment variable names.
+
+    Args:
+        api_key: The API key value or None.
+
+    Returns:
+        A display string: "(not set)" if None, the original value if it looks
+        like an env var name, or a masked version showing only the last 4 chars.
+    """
+    if not api_key:
+        return "(not set)"
+    # Only show unmasked if it looks like a valid environment variable name
+    if _is_env_var_name(api_key):
+        return api_key
+    return "***" + api_key[-4:] if len(api_key) > 4 else "***"
+
 
 def list_command() -> None:
     """List current Data Designer configurations.
@@ -22,9 +62,11 @@ def list_command() -> None:
     print_info(f"Configuration directory: {DATA_DESIGNER_HOME}")
     console.print()
 
-    # Display providers
+    # Display all configuration types
     display_providers(ProviderRepository(DATA_DESIGNER_HOME))
     display_models(ModelRepository(DATA_DESIGNER_HOME))
+    display_mcp_providers(MCPProviderRepository(DATA_DESIGNER_HOME))
+    display_tool_configs(ToolRepository(DATA_DESIGNER_HOME))
 
 
 def display_providers(provider_repo: ProviderRepository) -> None:
@@ -56,11 +98,7 @@ def display_providers(provider_repo: ProviderRepository) -> None:
 
         for provider in provider_registry.providers:
             is_default = "✓" if provider.name == default_name else ""
-            api_key_display = provider.api_key or "(not set)"
-
-            # Mask actual API keys (keep env var names visible)
-            if provider.api_key and not provider.api_key.isupper():
-                api_key_display = "***" + provider.api_key[-4:] if len(provider.api_key) > 4 else "***"
+            api_key_display = _mask_api_key(provider.api_key)
 
             table.add_row(
                 provider.name,
@@ -116,3 +154,102 @@ def display_models(model_repo: ModelRepository) -> None:
     except Exception as e:
         print_error(f"Error loading model configuration: {e}")
         console.print()
+
+
+def display_mcp_providers(mcp_provider_repo: MCPProviderRepository) -> None:
+    """Load and display MCP provider configurations.
+
+    Handles both MCPProvider (remote SSE) and LocalStdioMCPProvider (subprocess).
+
+    Args:
+        mcp_provider_repo: MCP provider repository
+
+    Returns:
+        None
+    """
+    try:
+        registry = mcp_provider_repo.load()
+
+        if not registry:
+            print_warning("MCP providers have not been configured. Run 'data-designer config mcp' to configure them.")
+            console.print()
+            return
+
+        # Display as table
+        table = Table(title="MCP Providers", border_style=NordColor.NORD8.value)
+        table.add_column("Name", style=NordColor.NORD14.value, no_wrap=True)
+        table.add_column("Endpoint / Command", style=NordColor.NORD4.value)
+        table.add_column("Type", style=NordColor.NORD9.value, no_wrap=True)
+        table.add_column("API Key / Env", style=NordColor.NORD7.value)
+
+        for provider in registry.providers:
+            if isinstance(provider, MCPProvider):
+                endpoint_display = provider.endpoint
+                api_key_display = _mask_api_key(provider.api_key)
+            elif isinstance(provider, LocalStdioMCPProvider):
+                # Display command + args for stdio provider
+                args_str = " ".join(provider.args) if provider.args else ""
+                endpoint_display = f"{provider.command} {args_str}".strip()
+                # Show env vars count for stdio provider
+                api_key_display = f"{len(provider.env)} env vars" if provider.env else "(none)"
+            else:
+                endpoint_display = "(unknown)"
+                api_key_display = "(unknown)"
+
+            table.add_row(
+                provider.name,
+                endpoint_display,
+                provider.provider_type,
+                api_key_display,
+            )
+
+        console.print(table)
+        console.print()
+    except Exception as e:
+        print_error(f"Error loading MCP provider configuration: {e}")
+        console.print()
+
+
+def display_tool_configs(tool_repo: ToolRepository) -> None:
+    """Load and display tool configurations.
+
+    Args:
+        tool_repo: Tool repository
+
+    Returns:
+        None
+    """
+    try:
+        registry = tool_repo.load()
+
+        if not registry:
+            print_warning("Tool configs have not been configured. Run 'data-designer config tools' to configure them.")
+            console.print()
+            return
+
+        # Display as table
+        table = Table(title="Tool Configurations", border_style=NordColor.NORD8.value)
+        table.add_column("Alias", style=NordColor.NORD14.value, no_wrap=True)
+        table.add_column("Providers", style=NordColor.NORD4.value)
+        table.add_column("Allowed Tools", style=NordColor.NORD9.value)
+        table.add_column("Max Turns", style=NordColor.NORD7.value, justify="center")
+        table.add_column("Timeout", style=NordColor.NORD15.value, justify="center")
+
+        for tc in registry.tool_configs:
+            providers_display = ", ".join(tc.providers)
+            allow_tools_display = ", ".join(tc.allow_tools) if tc.allow_tools else "(all)"
+            timeout_display = f"{tc.timeout_sec}s" if tc.timeout_sec else "(none)"
+
+            table.add_row(
+                tc.tool_alias,
+                providers_display,
+                allow_tools_display,
+                str(tc.max_tool_call_turns),
+                timeout_display,
+            )
+
+        console.print(table)
+        console.print()
+    except Exception as e:
+        print_error(f"Error loading tool configuration: {e}")
+        console.print()

data_designer/cli/commands/mcp.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from data_designer.cli.controllers.mcp_provider_controller import MCPProviderController
+from data_designer.config.utils.constants import DATA_DESIGNER_HOME
+
+
+def mcp_command() -> None:
+    """Configure MCP providers interactively."""
+    controller = MCPProviderController(DATA_DESIGNER_HOME)
+    controller.run()

data_designer/cli/commands/tools.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from data_designer.cli.controllers.tool_controller import ToolController
+from data_designer.config.utils.constants import DATA_DESIGNER_HOME
+
+
+def tools_command() -> None:
+    """Configure tool configs interactively."""
+    controller = ToolController(DATA_DESIGNER_HOME)
+    controller.run()

data_designer/cli/controllers/mcp_provider_controller.py

@@ -0,0 +1,241 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import copy
+import re
+from pathlib import Path
+
+# Pattern for valid environment variable names (uppercase letters, digits, underscores, not starting with digit)
+_ENV_VAR_PATTERN = re.compile(r"^[A-Z_][A-Z0-9_]*$")
+
+from data_designer.cli.forms.mcp_provider_builder import MCPProviderFormBuilder, MCPProviderT
+from data_designer.cli.repositories.mcp_provider_repository import MCPProviderRepository
+from data_designer.cli.services.mcp_provider_service import MCPProviderService
+from data_designer.cli.ui import (
+    confirm_action,
+    console,
+    display_config_preview,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    select_with_arrows,
+)
+from data_designer.config.mcp import LocalStdioMCPProvider, MCPProvider
+
+
+class MCPProviderController:
+    """Controller for MCP provider configuration workflows."""
+
+    def __init__(self, config_dir: Path):
+        self.config_dir = config_dir
+        self.repository = MCPProviderRepository(config_dir)
+        self.service = MCPProviderService(self.repository)
+
+    def run(self) -> None:
+        """Main entry point for MCP provider configuration."""
+        print_header("Configure MCP Providers")
+        print_info(f"Configuration directory: {self.config_dir}")
+        console.print()
+
+        # Check for existing configuration
+        providers = self.service.list_all()
+
+        if providers:
+            self._show_existing_config()
+            mode = self._select_mode()
+        else:
+            print_info("No MCP providers configured yet")
+            console.print()
+            mode = "add"
+
+        if mode is None:
+            print_info("No changes made")
+            return
+
+        # Execute selected mode
+        mode_handlers = {
+            "add": self._handle_add,
+            "update": self._handle_update,
+            "delete": self._handle_delete,
+            "delete_all": self._handle_delete_all,
+        }
+
+        handler = mode_handlers.get(mode)
+        if handler:
+            handler()
+
+    def _show_existing_config(self) -> None:
+        """Display current configuration."""
+        registry = self.repository.load()
+        if not registry:
+            return
+
+        print_info(f"Found {len(registry.providers)} configured MCP provider(s)")
+        console.print()
+
+        # Display configuration (with masked API keys)
+        config_dict = registry.model_dump(mode="json", exclude_none=True)
+        masked_config = self._mask_api_keys(config_dict)
+        display_config_preview(masked_config, "Current Configuration")
+        console.print()
+
+    def _mask_api_keys(self, config: dict) -> dict:
+        """Mask API keys in configuration for display."""
+        masked = copy.deepcopy(config)
+
+        if "providers" in masked:
+            for provider in masked["providers"]:
+                if "api_key" in provider and provider["api_key"]:
+                    api_key = provider["api_key"]
+                    # Only show unmasked if it looks like a valid environment variable name
+                    if not _ENV_VAR_PATTERN.match(api_key):
+                        provider["api_key"] = "***" + api_key[-4:] if len(api_key) > 4 else "***"
+
+        return masked
+
+    def _select_mode(self) -> str | None:
+        """Prompt user to select operation mode."""
+        options = {
+            "add": "Add a new MCP provider",
+            "update": "Update an existing MCP provider",
+            "delete": "Delete an MCP provider",
+            "delete_all": "Delete all MCP providers",
+            "exit": "Exit without changes",
+        }
+
+        result = select_with_arrows(
+            options,
+            "What would you like to do?",
+            default_key="add",
+            allow_back=False,
+        )
+
+        return None if result == "exit" or result is None else result
+
+    def _handle_add(self) -> None:
+        """Handle adding new MCP providers."""
+        existing_names = {p.name for p in self.service.list_all()}
+
+        while True:
+            # Create builder with current existing names
+            builder = MCPProviderFormBuilder(existing_names)
+            provider = builder.run()
+
+            if provider is None:
+                break
+
+            # Attempt to add
+            try:
+                self.service.add(provider)
+                print_success(f"MCP provider '{provider.name}' added successfully")
+                existing_names.add(provider.name)
+            except ValueError as e:
+                print_error(f"Failed to add MCP provider: {e}")
+                break
+
+            # Ask if they want to add more
+            if not self._confirm_add_another():
+                break
+
+    def _handle_update(self) -> None:
+        """Handle updating an existing MCP provider."""
+        providers = self.service.list_all()
+        if not providers:
+            print_error("No MCP providers to update")
+            return
+
+        # Select provider to update
+        selected_name = self._select_provider(providers, "Select MCP provider to update")
+        if selected_name is None:
+            return
+
+        provider = self.service.get_by_name(selected_name)
+        if not provider:
+            print_error(f"MCP provider '{selected_name}' not found")
+            return
+
+        # Run builder with existing data
+        existing_names = {p.name for p in providers if p.name != selected_name}
+        builder = MCPProviderFormBuilder(existing_names)
+        initial_data = provider.model_dump(mode="json", exclude_none=True)
+        updated_provider = builder.run(initial_data)
+
+        if updated_provider:
+            try:
+                self.service.update(selected_name, updated_provider)
+                print_success(f"MCP provider '{updated_provider.name}' updated successfully")
+            except ValueError as e:
+                print_error(f"Failed to update MCP provider: {e}")
+
+    def _handle_delete(self) -> None:
+        """Handle deleting an MCP provider."""
+        providers = self.service.list_all()
+        if not providers:
+            print_error("No MCP providers to delete")
+            return
+
+        # Select provider to delete
+        selected_name = self._select_provider(providers, "Select MCP provider to delete")
+        if selected_name is None:
+            return
+
+        # Confirm deletion
+        console.print()
+        if confirm_action(f"Delete MCP provider '{selected_name}'?", default=False):
+            try:
+                self.service.delete(selected_name)
+                print_success(f"MCP provider '{selected_name}' deleted successfully")
+            except ValueError as e:
+                print_error(f"Failed to delete MCP provider: {e}")
+
+    def _handle_delete_all(self) -> None:
+        """Handle deleting all MCP providers."""
+        providers = self.service.list_all()
+        if not providers:
+            print_error("No MCP providers to delete")
+            return
+
+        # List providers to be deleted
+        console.print()
+        provider_count = len(providers)
+        provider_names = ", ".join([f"'{p.name}'" for p in providers])
+
+        if confirm_action(
+            f"Delete ALL ({provider_count}) MCP provider(s): {provider_names}?\n   This action cannot be undone.",
+            default=False,
+        ):
+            try:
+                self.repository.delete()
+                print_success(f"All ({provider_count}) MCP provider(s) deleted successfully")
+            except Exception as e:
+                print_error(f"Failed to delete all MCP providers: {e}")
+
+    def _select_provider(self, providers: list[MCPProviderT], prompt: str, default: str | None = None) -> str | None:
+        """Helper to select an MCP provider from list."""
+        options = {}
+        for p in providers:
+            if isinstance(p, MCPProvider):
+                options[p.name] = f"{p.name} (SSE: {p.endpoint})"
+            elif isinstance(p, LocalStdioMCPProvider):
+                options[p.name] = f"{p.name} (stdio: {p.command})"
+            else:
+                options[p.name] = p.name
+        return select_with_arrows(
+            options,
+            prompt,
+            default_key=default or providers[0].name,
+            allow_back=False,
+        )
+
+    def _confirm_add_another(self) -> bool:
+        """Ask if user wants to add another MCP provider."""
+        result = select_with_arrows(
+            {"yes": "Add another MCP provider", "no": "Finish"},
+            "Add another MCP provider?",
+            default_key="no",
+            allow_back=False,
+        )
+        return result == "yes"

data_designer/cli/controllers/provider_controller.py

@@ -4,10 +4,14 @@
 from __future__ import annotations
 
 import copy
+import re
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 from data_designer.cli.forms.provider_builder import ProviderFormBuilder
+
+# Pattern for valid environment variable names (uppercase letters, digits, underscores, not starting with digit)
+_ENV_VAR_PATTERN = re.compile(r"^[A-Z_][A-Z0-9_]*$")
 from data_designer.cli.repositories.model_repository import ModelRepository
 from data_designer.cli.repositories.provider_repository import ProviderRepository
 from data_designer.cli.services.model_service import ModelService
@@ -95,8 +99,8 @@ class ProviderController:
             for provider in masked["providers"]:
                 if "api_key" in provider and provider["api_key"]:
                     api_key = provider["api_key"]
-                    # Keep environment variable names visible
-                    if not api_key.isupper():
+                    # Only show unmasked if it looks like a valid environment variable name
+                    if not _ENV_VAR_PATTERN.match(api_key):
                         provider["api_key"] = "***" + api_key[-4:] if len(api_key) > 4 else "***"
 
         return masked