ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/cli/commands/config/commands.py

@@ -5,14 +5,25 @@ import secrets
 from pathlib import Path
 from typing import Any
 
+import structlog
 import typer
 from click import get_current_context
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
-from ccproxy._version import __version__
 from ccproxy.cli.helpers import get_rich_toolkit
-from ccproxy.config.settings import Settings, get_settings
+from ccproxy.config.settings import Settings
+from ccproxy.core._version import __version__
+from ccproxy.services.container import ServiceContainer
+
+
+logger = structlog.get_logger(__name__)
+
+
+def _get_service_container() -> ServiceContainer:
+    """Create a service container for the config commands."""
+    settings = Settings.from_config(config_path=get_config_path_from_context())
+    return ServiceContainer(settings)
 
 
 def _create_config_table(title: str, rows: list[tuple[str, str, str]]) -> Any:
@@ -20,9 +31,9 @@ def _create_config_table(title: str, rows: list[tuple[str, str, str]]) -> Any:
     from rich.table import Table
 
     table = Table(title=title, show_header=True, header_style="bold magenta")
-    table.add_column("Setting", style="cyan", width=20)
-    table.add_column("Value", style="green")
-    table.add_column("Description", style="dim")
+    table.add_column("Setting", style="cyan", overflow="fold")
+    table.add_column("Value", style="green", overflow="fold")
+    table.add_column("Description", style="dim", overflow="fold")
 
     for setting, value, description in rows:
         table.add_row(setting, value, description)
@@ -39,7 +50,6 @@ def _format_value(value: Any) -> str:
     elif isinstance(value, str):
         if not value:
             return "[dim]Not set[/dim]"
-        # Special handling for sensitive values
         if any(
             keyword in value.lower()
             for keyword in ["token", "key", "secret", "password"]
@@ -64,7 +74,6 @@ def _get_field_description(field_info: FieldInfo) -> str:
     """Get a human-readable description from a Pydantic field."""
     if field_info.description:
         return field_info.description
-    # Generate a basic description from the field name
     return "Configuration setting"
 
 
@@ -74,14 +83,13 @@ def _generate_config_rows_from_model(
     """Generate configuration rows from a Pydantic model dynamically."""
     rows = []
 
-    for field_name, _field_info in model.model_fields.items():
+    field_definitions = model.__class__.model_fields
+
+    for field_name, _field_info in field_definitions.items():
         field_value = getattr(model, field_name)
         display_name = f"{prefix}{field_name}" if prefix else field_name
 
-        # If the field value is also a BaseModel, we might want to flatten it
         if isinstance(field_value, BaseModel):
-            # For nested models, we can either flatten or show as a summary
-            # For now, let's show a summary and then add sub-rows
             model_name = field_value.__class__.__name__
             rows.append(
                 (
@@ -91,11 +99,9 @@ def _generate_config_rows_from_model(
                 )
             )
 
-            # Add sub-rows for the nested model
-            sub_rows = _generate_config_rows_from_model(field_value, f"{display_name}_")
+            sub_rows = _generate_config_rows_from_model(field_value, f"{display_name}.")
             rows.extend(sub_rows)
         else:
-            # Regular field
             formatted_value = _format_value(field_value)
             description = _get_field_description(_field_info)
             rows.append((display_name, formatted_value, description))
@@ -109,41 +115,68 @@ def _group_config_rows(
     """Group configuration rows by their top-level section."""
     groups: dict[str, list[tuple[str, str, str]]] = {}
 
+    CATEGORY_PREFIXES = {
+        "server_": "Server Configuration",
+        "security_": "Security Configuration",
+        "cors_": "CORS Configuration",
+        "claude_": "Claude CLI Configuration",
+        "auth_": "Authentication Configuration",
+        "docker_": "Docker Configuration",
+        "observability_": "Observability Configuration",
+        "scheduler_": "Scheduler Configuration",
+        "pricing_": "Pricing Configuration",
+    }
+
     for setting, value, description in rows:
-        # Determine the group based on the setting name
-        if setting.startswith("server"):
-            group_name = "Server Configuration"
-        elif setting.startswith("security"):
-            group_name = "Security Configuration"
-        elif setting.startswith("cors"):
-            group_name = "CORS Configuration"
-        elif setting.startswith("claude"):
-            group_name = "Claude CLI Configuration"
-        elif setting.startswith("reverse_proxy"):
-            group_name = "Reverse Proxy Configuration"
-        elif setting.startswith("auth"):
-            group_name = "Authentication Configuration"
-        elif setting.startswith("docker"):
-            group_name = "Docker Configuration"
-        elif setting.startswith("observability"):
-            group_name = "Observability Configuration"
-        elif setting.startswith("scheduler"):
-            group_name = "Scheduler Configuration"
-        elif setting.startswith("pricing"):
-            group_name = "Pricing Configuration"
+        normalized_setting = setting
+        group_name = "General Configuration"
+
+        for prefix, group in CATEGORY_PREFIXES.items():
+            if setting.startswith(prefix):
+                normalized_setting = setting[len(prefix) :]
+                group_name = group
+                break
         else:
-            group_name = "General Configuration"
+            if setting.startswith("server"):
+                group_name = "Server Configuration"
+            elif setting.startswith("security"):
+                group_name = "Security Configuration"
+            elif setting.startswith("cors"):
+                group_name = "CORS Configuration"
+            elif setting.startswith("claude"):
+                group_name = "Claude CLI Configuration"
+            elif setting.startswith("auth"):
+                group_name = "Authentication Configuration"
+            elif setting.startswith("docker"):
+                group_name = "Docker Configuration"
+            elif setting.startswith("observability"):
+                group_name = "Observability Configuration"
+            elif setting.startswith("scheduler"):
+                group_name = "Scheduler Configuration"
+            elif setting.startswith("pricing"):
+                group_name = "Pricing Configuration"
+
+        if "." in normalized_setting:
+            normalized_setting = normalized_setting.split(".")[-1]
 
         if group_name not in groups:
             groups[group_name] = []
 
-        # Clean up the setting name by removing the prefix
-        clean_setting = setting.split("_", 1)[1] if "_" in setting else setting
-        groups[group_name].append((clean_setting, value, description))
+        groups[group_name].append((normalized_setting, value, description))
 
     return groups
 
 
+def _is_hidden_in_example(field_info: FieldInfo) -> bool:
+    """Determine if a field should be omitted from generated example configs."""
+
+    if bool(field_info.exclude):
+        return True
+
+    extra = getattr(field_info, "json_schema_extra", None) or {}
+    return bool(extra.get("config_example_hidden"))
+
+
 def get_config_path_from_context() -> Path | None:
     """Get config path from typer context if available."""
     try:
@@ -152,7 +185,6 @@ def get_config_path_from_context() -> Path | None:
             config_path = ctx.obj["config_path"]
             return config_path if config_path is None else Path(config_path)
     except RuntimeError:
-        # No active click context (e.g., in tests)
         pass
     return None
 
@@ -169,10 +201,13 @@ app = typer.Typer(
 @app.command(name="list")
 def config_list() -> None:
     """Show current configuration."""
+    from ccproxy.cli._settings_help import print_settings_help
+
     toolkit = get_rich_toolkit()
 
     try:
-        settings = get_settings(config_path=get_config_path_from_context())
+        container = _get_service_container()
+        settings = container.get_service(Settings)
 
         from rich.console import Console
         from rich.panel import Panel
@@ -180,34 +215,18 @@ def config_list() -> None:
 
         console = Console()
 
-        # Generate configuration rows dynamically from the Settings model
-        all_rows = _generate_config_rows_from_model(settings)
-
-        # Add computed fields that aren't part of the model but are useful to display
-        all_rows.append(
-            ("server_url", settings.server_url, "Complete server URL (computed)")
-        )
-
-        # Group rows by configuration section
-        grouped_rows = _group_config_rows(all_rows)
-
-        # Display header
+        # Display header panel
         console.print(
             Panel.fit(
                 f"[bold]CCProxy API Configuration[/bold]\n[dim]Version: {__version__}[/dim]",
                 border_style="blue",
             )
         )
-        console.print()
 
-        # Display each configuration section as a table
-        for section_name, section_rows in grouped_rows.items():
-            if section_rows:  # Only show sections that have data
-                table = _create_config_table(section_name, section_rows)
-                console.print(table)
-                console.print()
+        # Use generic settings display
+        print_settings_help(Settings, settings)
 
-        # Show configuration file sources
+        # Display footer panel
         info_text = Text()
         info_text.append("Configuration loaded from: ", style="bold")
         info_text.append(
@@ -218,7 +237,20 @@ def config_list() -> None:
             Panel(info_text, title="Configuration Sources", border_style="green")
         )
 
+    except (OSError, PermissionError) as e:
+        logger.error("config_list_file_access_error", error=str(e), exc_info=e)
+        toolkit.print(f"Error accessing configuration files: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except (json.JSONDecodeError, ValueError) as e:
+        logger.error("config_list_parsing_error", error=str(e), exc_info=e)
+        toolkit.print(f"Configuration parsing error: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except ImportError as e:
+        logger.error("config_list_import_error", error=str(e), exc_info=e)
+        toolkit.print(f"Module import error: {e}", tag="error")
+        raise typer.Exit(1) from e
     except Exception as e:
+        logger.error("config_list_unexpected_error", error=str(e), exc_info=e)
         toolkit.print(f"Error loading configuration: {e}", tag="error")
         raise typer.Exit(1) from e
 
@@ -243,16 +275,7 @@ def config_init(
         help="Overwrite existing configuration files",
     ),
 ) -> None:
-    """Generate example configuration files.
-
-    This command creates example configuration files with all available options
-    and documentation comments.
-
-    Examples:
-        ccproxy config init                      # Create TOML config in default location
-        ccproxy config init --output-dir ./config  # Create in specific directory
-    """
-    # Validate format
+    """Generate example configuration files."""
     if format != "toml":
         toolkit = get_rich_toolkit()
         toolkit.print(
@@ -264,19 +287,15 @@ def config_init(
     toolkit = get_rich_toolkit()
 
     try:
-        from ccproxy.config.discovery import get_ccproxy_config_dir
+        from ccproxy.config.utils import get_ccproxy_config_dir
 
-        # Determine output directory
         if output_dir is None:
             output_dir = get_ccproxy_config_dir()
 
-        # Create output directory if it doesn't exist
         output_dir.mkdir(parents=True, exist_ok=True)
 
-        # Generate configuration dynamically from Settings model
         example_config = _generate_default_config_from_model(Settings)
 
-        # Determine output file name
         if format == "toml":
             output_file = output_dir / "config.toml"
             if output_file.exists() and not force:
@@ -286,7 +305,6 @@ def config_init(
                 )
                 raise typer.Exit(1)
 
-            # Write TOML with comments using dynamic generation
             _write_toml_config_with_comments(output_file, example_config, Settings)
 
         toolkit.print(
@@ -300,7 +318,24 @@ def config_init(
         toolkit.print(f"  export CONFIG_FILE={output_file}", tag="command")
         toolkit.print("  ccproxy api", tag="command")
 
+    except (OSError, PermissionError) as e:
+        logger.error("config_init_file_access_error", error=str(e), exc_info=e)
+        toolkit.print(
+            f"Error creating configuration file (permission/IO error): {e}", tag="error"
+        )
+        raise typer.Exit(1) from e
+    except ImportError as e:
+        logger.error("config_init_import_error", error=str(e), exc_info=e)
+        toolkit.print(f"Module import error: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except ValueError as e:
+        logger.error("config_init_value_error", error=str(e), exc_info=e)
+        toolkit.print(f"Configuration value error: {e}", tag="error")
+        raise typer.Exit(1) from e
     except Exception as e:
+        if isinstance(e, typer.Exit):
+            raise
+        logger.error("config_init_unexpected_error", error=str(e), exc_info=e)
         toolkit.print(f"Error creating configuration file: {e}", tag="error")
         raise typer.Exit(1) from e
 
@@ -325,23 +360,10 @@ def generate_token(
         help="Overwrite existing auth_token without confirmation",
     ),
 ) -> None:
-    """Generate a secure random token for API authentication.
-
-    This command generates a secure authentication token that can be used with
-    both Anthropic and OpenAI compatible APIs.
-
-    Use --save to write the token to a TOML configuration file.
-
-    Examples:
-        ccproxy config generate-token                    # Generate and display token
-        ccproxy config generate-token --save             # Generate and save to config
-        ccproxy config generate-token --save --config-file custom.toml  # Save to TOML config
-        ccproxy config generate-token --save --force     # Overwrite existing token
-    """
+    """Generate a secure random token for API authentication."""
     toolkit = get_rich_toolkit()
 
     try:
-        # Generate a secure token
         token = secrets.token_urlsafe(32)
 
         from rich.console import Console
@@ -349,7 +371,6 @@ def generate_token(
 
         console = Console()
 
-        # Display the generated token
         console.print()
         console.print(
             Panel.fit(
@@ -359,7 +380,6 @@ def generate_token(
         )
         console.print()
 
-        # Show environment variable commands - server first, then clients
         console.print("[bold]Server Environment Variables:[/bold]")
         console.print(f"[cyan]export SECURITY__AUTH_TOKEN={token}[/cyan]")
         console.print()
@@ -385,47 +405,40 @@ def generate_token(
 
         console.print("[bold]Usage with curl (using environment variables):[/bold]")
         console.print("[dim]Anthropic API:[/dim]")
-        console.print('[cyan]curl -H "x-api-key: $ANTHROPIC_API_KEY" \\\\[/cyan]')
-        console.print('[cyan]     -H "Content-Type: application/json" \\\\[/cyan]')
+        console.print(r'[cyan]curl -H "x-api-key: $ANTHROPIC_API_KEY" \ [/cyan]')
+        console.print(r'[cyan]     -H "Content-Type: application/json" \ [/cyan]')
         console.print('[cyan]     "$ANTHROPIC_BASE_URL/v1/messages"[/cyan]')
         console.print()
         console.print("[dim]OpenAI API:[/dim]")
         console.print(
-            '[cyan]curl -H "Authorization: Bearer $OPENAI_API_KEY" \\\\[/cyan]'
+            r'[cyan]curl -H "Authorization: Bearer $OPENAI_API_KEY" \ [/cyan]'
         )
-        console.print('[cyan]     -H "Content-Type: application/json" \\\\[/cyan]')
+        console.print(r'[cyan]     -H "Content-Type: application/json" \ [/cyan]')
         console.print('[cyan]     "$OPENAI_BASE_URL/v1/chat/completions"[/cyan]')
         console.print()
 
-        # Mention the save functionality if not using it
         if not save:
             console.print(
                 "[dim]Tip: Use --save to write this token to a configuration file[/dim]"
             )
             console.print()
 
-        # Save to config file if requested
         if save:
-            # Determine config file path
             if config_file is None:
-                # Try to find existing config file or create default
-                from ccproxy.config.discovery import find_toml_config_file
+                from ccproxy.config.utils import find_toml_config_file
 
                 config_file = find_toml_config_file()
 
                 if config_file is None:
-                    # Create default config file in current directory
                     config_file = Path(".ccproxy.toml")
 
             console.print(
                 f"[bold]Saving token to configuration file:[/bold] {config_file}"
             )
 
-            # Detect file format from extension
             file_format = _detect_config_format(config_file)
             console.print(f"[dim]Detected format: {file_format.upper()}[/dim]")
 
-            # Read existing config or create new one using existing Settings functionality
             config_data = {}
             existing_token = None
 
@@ -436,7 +449,32 @@ def generate_token(
                     config_data = Settings.load_config_file(config_file)
                     existing_token = config_data.get("auth_token")
                     console.print("[dim]Found existing configuration file[/dim]")
+                except (OSError, PermissionError) as e:
+                    logger.warning(
+                        "generate_token_config_file_access_error",
+                        error=str(e),
+                        exc_info=e,
+                    )
+                    console.print(
+                        f"[yellow]Warning: Could not access existing config file: {e}[/yellow]"
+                    )
+                    console.print("[dim]Will create new configuration file[/dim]")
+                except (json.JSONDecodeError, ValueError) as e:
+                    logger.warning(
+                        "generate_token_config_file_parse_error",
+                        error=str(e),
+                        exc_info=e,
+                    )
+                    console.print(
+                        f"[yellow]Warning: Could not parse existing config file: {e}[/yellow]"
+                    )
+                    console.print("[dim]Will create new configuration file[/dim]")
                 except Exception as e:
+                    logger.warning(
+                        "generate_token_config_file_read_error",
+                        error=str(e),
+                        exc_info=e,
+                    )
                     console.print(
                         f"[yellow]Warning: Could not read existing config file: {e}[/yellow]"
                     )
@@ -444,7 +482,6 @@ def generate_token(
             else:
                 console.print("[dim]Will create new configuration file[/dim]")
 
-            # Check for existing token and ask for confirmation if needed
             if existing_token and not force:
                 console.print()
                 console.print(
@@ -458,10 +495,8 @@ def generate_token(
                     console.print("[dim]Token generation cancelled[/dim]")
                     return
 
-            # Update auth_token in config
             config_data["auth_token"] = token
 
-            # Write updated config in the appropriate format
             _write_config_file(config_file, config_data, file_format)
 
             console.print(f"[green]✓[/green] Token saved to {config_file}")
@@ -473,7 +508,20 @@ def generate_token(
             console.print(f"[cyan]export CONFIG_FILE={config_file}[/cyan]")
             console.print("[cyan]ccproxy api[/cyan]")
 
+    except (OSError, PermissionError) as e:
+        logger.error("generate_token_file_write_error", error=str(e), exc_info=e)
+        toolkit.print(f"Error writing configuration file: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except ValueError as e:
+        logger.error("generate_token_value_error", error=str(e), exc_info=e)
+        toolkit.print(f"Token generation configuration error: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except ImportError as e:
+        logger.error("generate_token_import_error", error=str(e), exc_info=e)
+        toolkit.print(f"Module import error: {e}", tag="error")
+        raise typer.Exit(1) from e
     except Exception as e:
+        logger.error("generate_token_unexpected_error", error=str(e), exc_info=e)
         toolkit.print(f"Error generating token: {e}", tag="error")
         raise typer.Exit(1) from e
 
@@ -484,7 +532,6 @@ def _detect_config_format(config_file: Path) -> str:
     if suffix in [".toml"]:
         return "toml"
     else:
-        # Only TOML is supported
         return "toml"
 
 
@@ -492,22 +539,30 @@ def _generate_default_config_from_model(
     settings_class: type[Settings],
 ) -> dict[str, Any]:
     """Generate a default configuration dictionary from the Settings model."""
-    # Create a default instance to get all default values
+    from ccproxy.config.settings import DEFAULT_ENABLED_PLUGINS
+
     default_settings = settings_class()
 
-    config_data = {}
+    config_data: dict[str, Any] = {}
+
+    for field_name, field_info in settings_class.model_fields.items():
+        if _is_hidden_in_example(field_info):
+            continue
 
-    # Iterate through all fields and extract their default values
-    for field_name, _field_info in settings_class.model_fields.items():
         field_value = getattr(default_settings, field_name)
 
+        # Special case: enabled_plugins should use DEFAULT_ENABLED_PLUGINS for config init
+        if field_name == "enabled_plugins" and field_value is None:
+            config_data[field_name] = DEFAULT_ENABLED_PLUGINS
+            continue
+
         if isinstance(field_value, BaseModel):
-            # For nested models, recursively generate their config
-            config_data[field_name] = _generate_nested_config_from_model(field_value)
+            nested_config = _generate_nested_config_from_model(field_value)
+            if nested_config:
+                config_data[field_name] = nested_config
         else:
-            # Convert Path objects to strings for JSON serialization
             if isinstance(field_value, Path):
-                config_data[field_name] = str(field_value)  # type: ignore[assignment]
+                config_data[field_name] = str(field_value)
             else:
                 config_data[field_name] = field_value
 
@@ -516,17 +571,21 @@ def _generate_default_config_from_model(
 
 def _generate_nested_config_from_model(model: BaseModel) -> dict[str, Any]:
     """Generate configuration for nested models."""
-    config_data = {}
+    config_data: dict[str, Any] = {}
+
+    for field_name, field_info in model.model_fields.items():
+        if _is_hidden_in_example(field_info):
+            continue
 
-    for field_name, _field_info in model.model_fields.items():
         field_value = getattr(model, field_name)
 
         if isinstance(field_value, BaseModel):
-            config_data[field_name] = _generate_nested_config_from_model(field_value)
+            nested_config = _generate_nested_config_from_model(field_value)
+            if nested_config:
+                config_data[field_name] = nested_config
         else:
-            # Convert Path objects to strings for JSON serialization
             if isinstance(field_value, Path):
-                config_data[field_name] = str(field_value)  # type: ignore[assignment]
+                config_data[field_name] = str(field_value)
             else:
                 config_data[field_name] = field_value
 
@@ -543,19 +602,34 @@ def _write_toml_config_with_comments(
         f.write("# Most settings are commented out with their default values\n")
         f.write("# Uncomment and modify as needed\n\n")
 
-        # Write each top-level section
-        for field_name, _field_info in settings_class.model_fields.items():
+        # Reorder fields to put enabled_plugins first
+        field_items = list(settings_class.model_fields.items())
+        priority_fields = ["enabled_plugins", "disabled_plugins"]
+
+        # Separate priority fields from others
+        priority_items = [
+            (name, info) for name, info in field_items if name in priority_fields
+        ]
+        other_items = [
+            (name, info) for name, info in field_items if name not in priority_fields
+        ]
+
+        # Combine with priority fields first
+        ordered_items = priority_items + other_items
+
+        for field_name, field_info in ordered_items:
+            if _is_hidden_in_example(field_info):
+                continue
+
             field_value = config_data.get(field_name)
-            description = _get_field_description(_field_info)
+            description = _get_field_description(field_info)
 
             f.write(f"# {description}\n")
 
             if isinstance(field_value, dict):
-                # This is a nested model - write as a TOML section
                 f.write(f"# [{field_name}]\n")
                 _write_toml_section(f, field_value, prefix="# ", level=0)
             else:
-                # Simple field - write as commented line
                 formatted_value = _format_config_value_for_toml(field_value)
                 f.write(f"# {field_name} = {formatted_value}\n")
 
@@ -568,11 +642,9 @@ def _write_toml_section(
     """Write a TOML section with proper indentation and commenting."""
     for key, value in data.items():
         if isinstance(value, dict):
-            # Nested section
             f.write(f"{prefix}[{key}]\n")
             _write_toml_section(f, value, prefix, level + 1)
         else:
-            # Simple value
             formatted_value = _format_config_value_for_toml(value)
             f.write(f"{prefix}{key} = {formatted_value}\n")
 
@@ -584,28 +656,30 @@ def _format_config_value_for_toml(value: Any) -> str:
     elif isinstance(value, bool):
         return "true" if value else "false"
     elif isinstance(value, str):
-        return f'"{value}"'
+        return f'"{value}"'  # Correctly escape quotes within strings
     elif isinstance(value, int | float):
         return str(value)
     elif isinstance(value, list):
         if not value:
             return "[]"
-        # Format list items
         formatted_items = []
         for item in value:
             if isinstance(item, str):
-                formatted_items.append(f'"{item}"')
+                formatted_items.append(
+                    f'"{item}"'
+                )  # Correctly escape quotes within list strings
             else:
                 formatted_items.append(str(item))
         return f"[{', '.join(formatted_items)}]"
     elif isinstance(value, dict):
         if not value:
-            return "{}"
-        # Format dict as inline table
+            return "{{}}"
         formatted_items = []
         for k, v in value.items():
             if isinstance(v, str):
-                formatted_items.append(f'{k} = "{v}"')
+                formatted_items.append(
+                    f'{k} = "{v}"'
+                )  # Correctly escape quotes within dict strings
             else:
                 formatted_items.append(f"{k} = {v}")
         return f"{{{', '.join(formatted_items)}}}"
@@ -613,32 +687,6 @@ def _format_config_value_for_toml(value: Any) -> str:
         return str(value)
 
 
-def _write_json_config_with_comments(
-    config_file: Path, config_data: dict[str, Any]
-) -> None:
-    """Write configuration data to a JSON file with formatting."""
-
-    def convert_for_json(obj: Any) -> Any:
-        """Convert objects to JSON-serializable format."""
-        if isinstance(obj, Path):
-            return str(obj)
-        elif isinstance(obj, dict):
-            return {k: convert_for_json(v) for k, v in obj.items()}
-        elif isinstance(obj, list):
-            return [convert_for_json(item) for item in obj]
-        elif hasattr(obj, "__dict__"):
-            # Handle complex objects by converting to string
-            return str(obj)
-        else:
-            return obj
-
-    serializable_data = convert_for_json(config_data)
-
-    with config_file.open("w", encoding="utf-8") as f:
-        json.dump(serializable_data, f, indent=2, sort_keys=True)
-        f.write("\n")
-
-
 def _write_config_file(
     config_file: Path, config_data: dict[str, Any], file_format: str
 ) -> None:
@@ -649,118 +697,3 @@ def _write_config_file(
         raise ValueError(
             f"Unsupported config format: {file_format}. Only TOML is supported."
         )
-
-
-def _write_toml_config(config_file: Path, config_data: dict[str, Any]) -> None:
-    """Write configuration data to a TOML file with proper formatting."""
-    try:
-        # Create a nicely formatted TOML file
-        with config_file.open("w", encoding="utf-8") as f:
-            f.write("# CCProxy API Configuration\n")
-            f.write("# Generated by ccproxy config generate-token\n\n")
-
-            # Write server settings
-            if any(
-                key in config_data
-                for key in ["host", "port", "log_level", "workers", "reload"]
-            ):
-                f.write("# Server configuration\n")
-                if "host" in config_data:
-                    f.write(f'host = "{config_data["host"]}"\n')
-                if "port" in config_data:
-                    f.write(f"port = {config_data['port']}\n")
-                if "log_level" in config_data:
-                    f.write(f'log_level = "{config_data["log_level"]}"\n')
-                if "workers" in config_data:
-                    f.write(f"workers = {config_data['workers']}\n")
-                if "reload" in config_data:
-                    f.write(f"reload = {str(config_data['reload']).lower()}\n")
-                f.write("\n")
-
-            # Write security settings
-            if any(key in config_data for key in ["auth_token", "cors_origins"]):
-                f.write("# Security configuration\n")
-                if "auth_token" in config_data:
-                    f.write(f'auth_token = "{config_data["auth_token"]}"\n')
-                if "cors_origins" in config_data:
-                    origins = config_data["cors_origins"]
-                    if isinstance(origins, list):
-                        origins_str = '", "'.join(origins)
-                        f.write(f'cors_origins = ["{origins_str}"]\n')
-                    else:
-                        f.write(f'cors_origins = ["{origins}"]\n')
-                f.write("\n")
-
-            # Write Claude CLI configuration
-            if "claude_cli_path" in config_data:
-                f.write("# Claude CLI configuration\n")
-                if config_data["claude_cli_path"]:
-                    f.write(f'claude_cli_path = "{config_data["claude_cli_path"]}"\n')
-                else:
-                    f.write(
-                        '# claude_cli_path = "/path/to/claude"  # Auto-detect if not set\n'
-                    )
-                f.write("\n")
-
-            # Write Docker settings
-            if "docker" in config_data:
-                docker_settings = config_data["docker"]
-                f.write("# Docker configuration\n")
-                f.write("[docker]\n")
-
-                for key, value in docker_settings.items():
-                    if isinstance(value, str):
-                        f.write(f'{key} = "{value}"\n')
-                    elif isinstance(value, bool):
-                        f.write(f"{key} = {str(value).lower()}\n")
-                    elif isinstance(value, int | float):
-                        f.write(f"{key} = {value}\n")
-                    elif isinstance(value, list):
-                        if value:  # Only write non-empty lists
-                            if all(isinstance(item, str) for item in value):
-                                items_str = '", "'.join(value)
-                                f.write(f'{key} = ["{items_str}"]\n')
-                            else:
-                                f.write(f"{key} = {value}\n")
-                        else:
-                            f.write(f"{key} = []\n")
-                    elif isinstance(value, dict):
-                        if value:  # Only write non-empty dicts
-                            f.write(f"{key} = {json.dumps(value)}\n")
-                        else:
-                            f.write(f"{key} = {{}}\n")
-                    elif value is None:
-                        f.write(f"# {key} = null  # Not configured\n")
-                f.write("\n")
-
-            # Write any remaining top-level settings
-            written_keys = {
-                "host",
-                "port",
-                "log_level",
-                "workers",
-                "reload",
-                "auth_token",
-                "cors_origins",
-                "claude_cli_path",
-                "docker",
-            }
-            remaining_keys = set(config_data.keys()) - written_keys
-
-            if remaining_keys:
-                f.write("# Additional settings\n")
-                for key in sorted(remaining_keys):
-                    value = config_data[key]
-                    if isinstance(value, str):
-                        f.write(f'{key} = "{value}"\n')
-                    elif isinstance(value, bool):
-                        f.write(f"{key} = {str(value).lower()}\n")
-                    elif isinstance(value, int | float):
-                        f.write(f"{key} = {value}\n")
-                    elif isinstance(value, list | dict):
-                        f.write(f"{key} = {json.dumps(value)}\n")
-                    elif value is None:
-                        f.write(f"# {key} = null\n")
-
-    except Exception as e:
-        raise ValueError(f"Failed to write TOML configuration: {e}") from e