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

ccproxy/cli/commands/status.py

@@ -0,0 +1,254 @@
+"""Status command for displaying system information."""
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from ccproxy.cli.helpers import get_rich_toolkit
+from ccproxy.config.settings import Settings
+from ccproxy.core._version import __version__
+from ccproxy.core.logging import get_logger
+from ccproxy.core.status_report import (
+    ConfigSnapshot,
+    PluginSnapshot,
+    SystemSnapshot,
+    collect_config_snapshot,
+    collect_plugin_snapshot,
+    collect_system_snapshot,
+)
+
+
+app = typer.Typer(name="status", help="Show system status and information")
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def status_main(
+    ctx: typer.Context,
+    plugins: bool = typer.Option(
+        True, "--plugins/--no-plugins", help="Show plugin status"
+    ),
+    config: bool = typer.Option(
+        True, "--config/--no-config", help="Show configuration info"
+    ),
+) -> None:
+    """Show CCProxy system status and configuration."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    toolkit = get_rich_toolkit()
+    console = Console()
+
+    # Header
+    toolkit.print("[bold cyan]CCProxy Status[/bold cyan]", centered=True)
+    toolkit.print(f"Version: {__version__}", tag="info")
+    toolkit.print_line()
+
+    try:
+        settings = Settings.from_config()
+
+        system_snapshot = collect_system_snapshot(settings)
+        _show_system_info(console, system_snapshot)
+
+        if config:
+            config_snapshot = collect_config_snapshot()
+            _show_config_info(console, config_snapshot)
+
+        if plugins:
+            plugin_snapshot = collect_plugin_snapshot(settings)
+            _show_plugin_status(console, plugin_snapshot)
+
+    except Exception as e:
+        logger.error("status_command_error", error=str(e), exc_info=e)
+        toolkit.print(f"[red]✗[/red] Error gathering status: {e}", tag="error")
+
+
+def _show_system_info(console: Console, snapshot: SystemSnapshot) -> None:
+    """Show basic system information."""
+    table = Table(
+        show_header=False,
+        box=box.ROUNDED,
+        title="System Information",
+        title_style="bold white",
+        border_style="blue",
+    )
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+
+    # Server configuration
+    table.add_row("Server Host", snapshot.host)
+    table.add_row("Server Port", str(snapshot.port))
+    table.add_row("Log Level", snapshot.log_level)
+
+    # Authentication
+    auth_token_status = (
+        "✓ Configured" if snapshot.auth_token_configured else "✗ Not set"
+    )
+    table.add_row("API Token", auth_token_status)
+
+    # Plugin directories
+    plugin_dirs = snapshot.plugin_directories
+    plugins_enabled = "✓ Enabled" if snapshot.plugins_enabled else "✗ Disabled"
+    table.add_row("Plugins", plugins_enabled)
+
+    # Show each plugin directory with existence check
+    for i, plugin_dir in enumerate(plugin_dirs):
+        dir_exists = "✓ Exists" if plugin_dir.exists else "✗ Missing"
+        dir_label = (
+            f"Plugin Directory {i + 1}" if len(plugin_dirs) > 1 else "Plugin Directory"
+        )
+        table.add_row(dir_label, f"{plugin_dir.path} ({dir_exists})")
+
+    console.print(table)
+    console.print()
+
+
+def _show_config_info(console: Console, snapshot: ConfigSnapshot) -> None:
+    """Show configuration source information."""
+    if snapshot.sources:
+        info_text = Text()
+        info_text.append("Configuration Sources:\n", style="bold")
+        for source in snapshot.sources:
+            prefix = "✓" if source.exists else "✗"
+            info_text.append(f"{prefix} {source.path}\n")
+
+        console.print(Panel(info_text, title="Configuration", border_style="green"))
+        console.print()
+
+
+def _show_plugin_status(console: Console, snapshot: PluginSnapshot) -> None:
+    """Show plugin discovery and status information."""
+
+    # Short-circuit if plugins are entirely disabled
+    if not snapshot.plugin_system_enabled:
+        table = Table(
+            show_header=True,
+            header_style="bold cyan",
+            box=box.ROUNDED,
+            title="Plugin Status",
+            title_style="bold white",
+            border_style="yellow",
+        )
+        table.add_column("Plugin", style="cyan", no_wrap=True)
+        table.add_column("Status", style="white", no_wrap=True)
+        table.add_column("Version", style="yellow")
+        table.add_column("Description", style="dim white")
+
+        table.add_row(
+            "Plugin System",
+            "[red]✗ Disabled[/red]",
+            "",
+            "Plugin system disabled in configuration",
+        )
+
+        console.print(table)
+        console.print(
+            Panel(
+                "Plugin system is disabled. No plugins will be loaded or executed.",
+                title="Plugin Summary",
+                border_style="yellow",
+            )
+        )
+        if snapshot.configuration_notes:
+            _print_plugin_configuration_notes(console, snapshot.configuration_notes)
+        return
+
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=box.ROUNDED,
+        title="Plugin Status",
+        title_style="bold white",
+        border_style="green",
+    )
+    table.add_column("Plugin", style="cyan", no_wrap=True)
+    table.add_column("Status", style="white", no_wrap=True)
+    table.add_column("Version", style="yellow")
+    table.add_column("Description", style="dim white")
+
+    for info in snapshot.enabled_plugins:
+        status = "[green]✓ Enabled[/green]"
+        version = info.version or "unknown"
+        description = info.description or ""
+
+        if info.state == "error":
+            status = "[red]✗ Error[/red]"
+            error_message = info.error or "Unknown error"
+            preview = error_message[:50]
+            if len(error_message) > 50:
+                preview += "..."
+            description = f"Error: {preview}"
+
+        table.add_row(info.name, status, version, description)
+
+    for name in snapshot.disabled_plugins:
+        table.add_row(
+            name,
+            "[yellow]⦸ Disabled[/yellow]",
+            "unknown",
+            "Plugin disabled in configuration",
+        )
+
+    if not snapshot.enabled_plugins and not snapshot.disabled_plugins:
+        table.add_row("No plugins found", "[yellow]⚠ Warning[/yellow]", "", "")
+
+    console.print(table)
+
+    summary_text = Text()
+    summary_text.append(f"Total plugins: {snapshot.total_count} ", style="bold")
+    summary_text.append(f"(Enabled: {snapshot.enabled_count}, ", style="green")
+    summary_text.append(f"Disabled: {snapshot.disabled_count})", style="yellow")
+
+    console.print(Panel(summary_text, title="Plugin Summary", border_style="blue"))
+
+    if snapshot.configuration_notes:
+        _print_plugin_configuration_notes(console, snapshot.configuration_notes)
+
+
+def _print_plugin_configuration_notes(console: Console, notes: tuple[str, ...]) -> None:
+    config_text = Text()
+    config_text.append("Configuration: ", style="bold")
+    config_text.append(" • ".join(notes))
+    console.print(Panel(config_text, title="Plugin Configuration", border_style="blue"))
+    console.print()
+
+
+@app.command()
+def plugins() -> None:
+    """Show detailed plugin information only."""
+    toolkit = get_rich_toolkit()
+    console = Console()
+
+    toolkit.print("[bold cyan]Plugin Status[/bold cyan]", centered=True)
+    toolkit.print_line()
+
+    try:
+        settings = Settings.from_config()
+        plugin_snapshot = collect_plugin_snapshot(settings)
+        _show_plugin_status(console, plugin_snapshot)
+    except Exception as e:
+        logger.error("plugin_status_command_error", error=str(e), exc_info=e)
+        toolkit.print(f"[red]✗[/red] Error: {e}", tag="error")
+
+
+@app.command()
+def config() -> None:
+    """Show configuration information only."""
+    toolkit = get_rich_toolkit()
+    console = Console()
+
+    toolkit.print("[bold cyan]Configuration Status[/bold cyan]", centered=True)
+    toolkit.print_line()
+
+    try:
+        settings = Settings.from_config()
+        system_snapshot = collect_system_snapshot(settings)
+        config_snapshot = collect_config_snapshot()
+        _show_system_info(console, system_snapshot)
+        _show_config_info(console, config_snapshot)
+    except Exception as e:
+        logger.error("config_status_command_error", error=str(e), exc_info=e)
+        toolkit.print(f"[red]✗[/red] Error: {e}", tag="error")

ccproxy/cli/decorators.py

@@ -0,0 +1,83 @@
+"""CLI command decorators for plugin dependency management."""
+
+from collections.abc import Callable
+from typing import Any, ParamSpec, TypeVar
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def needs_auth_provider() -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator to mark CLI commands that need an auth provider.
+
+    This decorator marks the command as requiring the auth provider specified
+    in the command arguments. The actual plugin loading is handled by the
+    command implementation using load_cli_plugins().
+
+    Usage:
+        @app.command()
+        @needs_auth_provider()
+        async def auth_status(provider: str):
+            # Command implementation
+            pass
+    """
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        # Add metadata to the function
+        func._needs_auth_provider = True  # type: ignore
+        return func
+
+    return decorator
+
+
+def allows_plugins(
+    plugin_names: list[str],
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator to specify additional plugins a CLI command can use.
+
+    This decorator specifies additional CLI-safe plugins that the command
+    wants to use beyond the default set. These plugins must still be marked
+    as cli_safe = True to be loaded.
+
+    Args:
+        plugin_names: List of plugin names to allow (e.g., ["request_tracer", "metrics"])
+
+    Usage:
+        @app.command()
+        @allows_plugins(["request_tracer", "metrics"])
+        async def my_command():
+            # Command implementation
+            pass
+    """
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        # Add metadata to the function
+        func._allows_plugins = plugin_names  # type: ignore
+        return func
+
+    return decorator
+
+
+def get_command_auth_provider(func: Callable[..., Any]) -> bool:
+    """Check if a command needs an auth provider.
+
+    Args:
+        func: Function to check
+
+    Returns:
+        True if the command is decorated with @needs_auth_provider()
+    """
+    return getattr(func, "_needs_auth_provider", False)
+
+
+def get_command_allowed_plugins(func: Callable[..., Any]) -> list[str]:
+    """Get the allowed plugins for a command.
+
+    Args:
+        func: Function to check
+
+    Returns:
+        List of allowed plugin names (empty list if none specified)
+    """
+    return getattr(func, "_allows_plugins", [])

ccproxy/cli/helpers.py

@@ -3,11 +3,10 @@
 from pathlib import Path
 from typing import Any
 
+import typer
 from rich_toolkit import RichToolkit, RichToolkitTheme
 from rich_toolkit.styles import TaggedStyle
 
-from ccproxy.core.async_utils import patched_typing
-
 
 def get_rich_toolkit() -> RichToolkit:
     theme = RichToolkitTheme(
@@ -79,64 +78,27 @@ def link(text: str, link: str) -> str:
     return f"[link={link}]{text}[/link]"
 
 
-def merge_claude_code_options(base_options: Any, **overrides: Any) -> Any:
-    """
-    Create a new ClaudeCodeOptions instance by merging base options with overrides.
+def is_running_in_docker() -> bool:
+    return Path("/.dockerenv").exists()
 
-    Args:
-        base_options: Base ClaudeCodeOptions instance to copy from
-        **overrides: Dictionary of option overrides
 
-    Returns:
-        New ClaudeCodeOptions instance with merged options
-    """
-    with patched_typing():
-        from claude_code_sdk import ClaudeCodeOptions
-
-    # Create a new options instance with the base values
-    options = ClaudeCodeOptions()
-
-    # Copy all attributes from base_options
-    if base_options:
-        for attr in [
-            "model",
-            "max_thinking_tokens",
-            "max_turns",
-            "cwd",
-            "system_prompt",
-            "append_system_prompt",
-            "permission_mode",
-            "permission_prompt_tool_name",
-            "continue_conversation",
-            "resume",
-            "allowed_tools",
-            "disallowed_tools",
-            "mcp_servers",
-            "mcp_tools",
-            # Anthropic API fields
-            "temperature",
-            "top_p",
-            "top_k",
-            "stop_sequences",
-            "tools",
-            "metadata",
-            "service_tier",
-        ]:
-            if hasattr(base_options, attr):
-                base_value = getattr(base_options, attr)
-                if base_value is not None:
-                    setattr(options, attr, base_value)
-
-    # Apply overrides
-    for key, value in overrides.items():
-        if value is not None and hasattr(options, key):
-            # Handle special type conversions for specific fields
-            if key == "cwd" and not isinstance(value, str):
-                value = str(value)
-            setattr(options, key, value)
-
-    return options
+def get_plugin_cli_args(ctx: typer.Context | None = None) -> dict[str, Any]:
+    """Return plugin-injected CLI args from Typer context.
 
-
-def is_running_in_docker() -> bool:
-    return Path("/.dockerenv").exists()
+    Ensures a dict is returned. If no context is provided, attempts to fetch the
+    current Click/Typer context. This is safe to call from command bodies.
+    """
+    try:
+        if ctx is None:
+            # Lazy import to avoid hard dependency when not in CLI execution
+            from click import get_current_context as _get_ctx
+
+            ctx = _get_ctx(silent=True)  # type: ignore[assignment]
+        if ctx and getattr(ctx, "obj", None) and isinstance(ctx.obj, dict):
+            data = ctx.obj.get("plugin_cli_args")
+            if isinstance(data, dict):
+                # Only return non-None values to simplify merging
+                return {k: v for k, v in data.items() if v is not None}
+    except Exception:
+        pass
+    return {}