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

ccproxy/cli/main.py

@@ -1,20 +1,30 @@
-"""Main entry point for CCProxy API Server."""
+"""Main entry point for CCProxy API Server.
 
+Adds per-invocation debug logging of CLI argv and relevant environment
+variables (masked) so every command emits its context consistently.
+"""
+
+import os
+import sys
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated, Any, cast
 
 import typer
-from structlog import get_logger
 
-from ccproxy._version import __version__
 from ccproxy.cli.helpers import (
     get_rich_toolkit,
 )
+from ccproxy.core._version import __version__
+from ccproxy.core.logging import bootstrap_cli_logging, get_logger, set_command_context
+from ccproxy.core.plugins.cli_discovery import discover_plugin_cli_extensions
+from ccproxy.core.plugins.declaration import CliArgumentSpec, CliCommandSpec
 
+# from plugins.permissions.handlers.cli import app as permission_handler_app
 from .commands.auth import app as auth_app
 from .commands.config import app as config_app
-from .commands.permission_handler import app as permission_handler_app
+from .commands.plugins import app as plugins_app
 from .commands.serve import api
+from .commands.status import app as status_app
 
 
 def version_callback(value: bool) -> None:
@@ -36,6 +46,266 @@ app = typer.Typer(
 # Logger will be configured by configuration manager
 logger = get_logger(__name__)
 
+_plugins_registered = False
+
+
+def register_plugin_cli_extensions(app: typer.Typer) -> None:
+    """Register plugin CLI commands and arguments during app creation."""
+    try:
+        # Load settings to apply plugin filtering
+        try:
+            from ccproxy.config.settings import Settings
+
+            settings = Settings.from_config()
+        except Exception as e:
+            # Graceful degradation - use no filtering if settings fail to load
+            logger.debug("settings_load_failed_for_cli_discovery", error=str(e))
+            settings = None
+
+        plugin_manifests = discover_plugin_cli_extensions(settings)
+
+        logger.debug(
+            "plugin_cli_discovery_complete",
+            plugin_count=len(plugin_manifests),
+            plugins=[name for name, _ in plugin_manifests],
+        )
+
+        # Register new commands first
+        for plugin_name, manifest in plugin_manifests:
+            for cmd_spec in manifest.cli_commands:
+                _register_plugin_command(app, plugin_name, cmd_spec)
+
+        # Batch extend existing commands with new arguments
+        arg_batches: dict[str, list[tuple[str, CliArgumentSpec]]] = {}
+        for plugin_name, manifest in plugin_manifests:
+            for arg_spec in manifest.cli_arguments:
+                arg_batches.setdefault(arg_spec.target_command, []).append(
+                    (plugin_name, arg_spec)
+                )
+
+        for target, pairs in arg_batches.items():
+            _extend_command_with_arguments(app, target, pairs)
+
+    except Exception as e:
+        # Graceful degradation - CLI still works without plugin extensions
+        logger.debug("plugin_cli_extension_registration_failed", error=str(e))
+
+
+def ensure_plugin_cli_extensions_registered(app: typer.Typer) -> None:
+    """Register plugin CLI extensions once, after logging is configured."""
+    global _plugins_registered
+    if _plugins_registered:
+        return
+
+    register_plugin_cli_extensions(app)
+    _plugins_registered = True
+
+
+def _register_plugin_command(
+    app: typer.Typer, plugin_name: str, cmd_spec: CliCommandSpec
+) -> None:
+    """Register a single plugin command."""
+    try:
+        if cmd_spec.parent_command is None:
+            # Top-level command
+            app.command(
+                name=cmd_spec.command_name,
+                help=cmd_spec.help_text or f"Command from {plugin_name} plugin",
+            )(cmd_spec.command_function)
+            logger.debug(
+                "plugin_command_registered",
+                plugin=plugin_name,
+                command=cmd_spec.command_name,
+                type="top_level",
+            )
+        else:
+            # Subcommand - add to existing command groups
+            parent_app = _get_command_app(cmd_spec.parent_command)
+            if parent_app:
+                parent_app.command(
+                    name=cmd_spec.command_name,
+                    help=cmd_spec.help_text or f"Command from {plugin_name} plugin",
+                )(cmd_spec.command_function)
+                logger.debug(
+                    "plugin_command_registered",
+                    plugin=plugin_name,
+                    command=cmd_spec.command_name,
+                    parent=cmd_spec.parent_command,
+                    type="subcommand",
+                )
+            else:
+                logger.warning(
+                    "plugin_command_parent_not_found",
+                    plugin=plugin_name,
+                    command=cmd_spec.command_name,
+                    parent=cmd_spec.parent_command,
+                )
+    except Exception as e:
+        logger.warning(
+            "plugin_command_registration_failed",
+            plugin=plugin_name,
+            command=cmd_spec.command_name,
+            error=str(e),
+        )
+
+
+def _extend_command_with_arguments(
+    app: typer.Typer, target_name: str, pairs: list[tuple[str, CliArgumentSpec]]
+) -> None:
+    """Extend an existing command with multiple new arguments at once."""
+    try:
+        # Utility: resolve a command callback by dotted path, supporting subcommands
+        def _resolve_callback(root_app: typer.Typer, dotted: str) -> Any:
+            parts = dotted.split()
+            # Allow both space-separated or colon-separated ("auth login")
+            if len(parts) == 1 and (":" in dotted or "/" in dotted):
+                # normalize common separators
+                dotted_norm = dotted.replace(":", " ").replace("/", " ")
+                parts = dotted_norm.split()
+
+            current_app: typer.Typer | None = root_app
+            callback = None
+
+            # Typer API does not expose a stable public registry; we rely on
+            # attributes commonly present on Typer instances.
+            for idx, part in enumerate(parts):
+                if current_app is None:
+                    return None
+                # Try commands at this level
+                cmds = getattr(current_app, "registered_commands", [])
+                sub_app: typer.Typer | None = None
+                found = False
+                for cmd in cmds:
+                    name = getattr(cmd, "name", None)
+                    if name == part:
+                        found = True
+                        if idx == len(parts) - 1:
+                            callback = getattr(cmd, "callback", None)
+                        else:
+                            # navigate into sub-typer if present
+                            sub_app = getattr(cmd, "typer_instance", None)
+                        break
+                current_app = sub_app if sub_app is not None else current_app
+                if not found and idx == len(parts) - 1:
+                    # maybe the target is a top-level name even if earlier parts failed
+                    pass
+            return callback
+
+        # Find existing command callback on the root app or nested apps
+        original_callback = _resolve_callback(app, target_name)
+
+        if original_callback is None:
+            logger.debug(
+                "plugin_argument_extension_target_not_found",
+                target_command=target_name,
+            )
+            return
+        # Build all options and construct wrapper
+        built: list[tuple[CliArgumentSpec, Any]] = []
+        for _, arg_spec in pairs:
+            typer_kwargs = dict(arg_spec.typer_kwargs or {})
+            option_names = typer_kwargs.pop("option", None)
+            if option_names is None:
+                option_names = [f"--{arg_spec.argument_name.replace('_', '-')}"]
+            if isinstance(option_names, str):
+                option_names = [option_names]
+            option = typer.Option(
+                *option_names,
+                help=arg_spec.help_text or "",
+                **typer_kwargs,
+            )
+            built.append((arg_spec, option))
+
+        # Preserve original options: build wrapper with original signature + injected params
+        import inspect
+
+        sig = inspect.signature(original_callback)
+        param_defs: list[str] = []
+        call_args: list[str] = []
+        annotations: dict[str, object] = {}
+
+        # Always include ctx first for our bookkeeping
+        param_defs.append("ctx: typer.Context")
+        annotations["ctx"] = typer.Context
+
+        # Mirror original parameters with their defaults in order
+        for name, param in sig.parameters.items():
+            if getattr(original_callback, "__annotations__", {}).get(name) is not None:
+                annotations[name] = original_callback.__annotations__[name]
+            if param.default is inspect._empty:
+                param_defs.append(name)
+            else:
+                param_defs.append(f"{name}={repr(param.default)}")
+            call_args.append(name)
+
+        # Append injected params
+        for arg_spec, _ in built:
+            default_expr = "..." if arg_spec.required else "None"
+            param_defs.append(f"{arg_spec.argument_name}: object = {default_expr}")
+
+        params_sig = ", ".join(param_defs)
+
+        body_lines = [
+            "ctx.ensure_object(dict)",
+            "plugin_map = ctx.obj.get('plugin_cli_args') or {}",
+            "plugin_map = plugin_map if isinstance(plugin_map, dict) else {}",
+        ]
+        for arg_spec, _ in built:
+            name = arg_spec.argument_name
+            body_lines.append(f"if {name} is not None: plugin_map['{name}'] = {name}")
+        body_lines.append("ctx.obj['plugin_cli_args'] = plugin_map")
+        body_lines.append(f"return original_callback({', '.join(call_args)})")
+
+        body_src = "\n    ".join(body_lines)
+        func_src = f"def _wrapped({params_sig}):\n    {body_src}\n"
+        local_ns: dict[str, object] = {
+            "typer": typer,
+            "original_callback": original_callback,
+        }
+        exec(func_src, local_ns, local_ns)
+        _wrapped = local_ns["_wrapped"]
+
+        # Copy original annotations and append injected option annotations
+        for name, ann in getattr(original_callback, "__annotations__", {}).items():
+            annotations.setdefault(name, ann)
+        for arg_spec, option in built:
+            annotations[arg_spec.argument_name] = Annotated[
+                arg_spec.argument_type | None, option
+            ]
+        _wrapped.__annotations__ = annotations
+
+        _wrapped.__name__ = getattr(  # type: ignore[attr-defined]
+            original_callback, "__name__", f"_{target_name}_wrapped"
+        )
+        _wrapped.__doc__ = getattr(original_callback, "__doc__", None)
+
+        app.command(name=target_name)(cast(Any, _wrapped))
+
+        for plugin_name, arg_spec in pairs:
+            logger.debug(
+                "plugin_argument_extension_registered",
+                plugin=plugin_name,
+                target_command=target_name,
+                argument=arg_spec.argument_name,
+            )
+    except Exception as e:
+        logger.debug(
+            "plugin_argument_extension_failed",
+            target_command=target_name,
+            error=str(e),
+        )
+
+
+def _get_command_app(command_name: str) -> typer.Typer | None:
+    """Get the typer app for a parent command."""
+    command_apps = {
+        "auth": auth_app,
+        "config": config_app,
+        "plugins": plugins_app,
+        "status": status_app,
+    }
+    return command_apps.get(command_name)
+
 
 # Add global options
 @app.callback()
@@ -65,9 +335,13 @@ def app_main(
     ] = None,
 ) -> None:
     """CCProxy API Server - Anthropic and OpenAI compatible interface for Claude."""
-    # Store config path for commands to use
+    # Store config path and initialize plugin arg bucket
     ctx.ensure_object(dict)
     ctx.obj["config_path"] = config
+    if "plugin_cli_args" not in ctx.obj or not isinstance(
+        ctx.obj.get("plugin_cli_args"), dict
+    ):
+        ctx.obj["plugin_cli_args"] = {}
 
     # If no command is invoked, run the serve command by default
     if ctx.invoked_subcommand is None:
@@ -85,20 +359,95 @@ app.add_typer(config_app)
 app.add_typer(auth_app)
 
 # Register permission handler command
-app.add_typer(permission_handler_app)
+# app.add_typer(permission_handler_app)
 
+# Register plugins command
+app.add_typer(plugins_app)
 
-# Register imported commands
+# Register status command
+app.add_typer(status_app)
+
+# Register imported commands first
 app.command(name="serve")(api)
+
 # Claude command removed - functionality moved to serve command
 
 
 def main() -> None:
     """Entry point for the CLI application."""
+    # Bind a command-wide correlation ID so all logs have `cmd_id`
+    set_command_context()
+    # Early logging bootstrap from env/argv; safe to reconfigure later
+    bootstrap_cli_logging()
+    # Register plugin-supplied CLI commands after logging honors env overrides
+    ensure_plugin_cli_extensions_registered(app)
+    # Log invocation context (argv + env) for all commands
+    _log_cli_invocation_context()
     app()
 
 
 if __name__ == "__main__":
-    import sys
+    main()
+
+
+def _mask_env_value(key: str, value: str) -> str:
+    """Mask sensitive values based on common substrings in the key."""
+    lowered = key.lower()
+    sensitive_markers = [
+        "token",
+        "secret",
+        "password",
+        "passwd",
+        "key",
+        "api_key",
+        "bearer",
+        "auth",
+        "credential",
+    ]
+    if any(m in lowered for m in sensitive_markers):
+        if not value:
+            return value
+        # keep only last 4 chars for minimal debugging
+        tail = value[-4:] if len(value) > 4 else "".join("*" for _ in value)
+        return f"***MASKED***{tail}"
+    return value
+
+
+def _collect_relevant_env() -> dict[str, str]:
+    """Collect env vars relevant to settings/plugins and mask sensitive ones.
+
+    We include nested-style variables (containing "__") and key CCProxy groups.
+    """
+    prefixes = (
+        "LOGGING__",
+        "PLUGINS__",
+        "SERVER__",
+        "STORAGE__",
+        "AUTH__",
+        "CCPROXY__",
+        "CCPROXY_",
+    )
+    env = {}
+    for k, v in os.environ.items():
+        # Ignore variables that start with double underscore
+        if k.startswith("__"):
+            continue
+        if "__" in k or k.startswith(prefixes):
+            env[k] = _mask_env_value(k, v)
+    # Sort for stable output
+    return dict(sorted(env.items(), key=lambda kv: kv[0]))
+
 
-    sys.exit(app())
+def _log_cli_invocation_context() -> None:
+    """Log argv and selected env at debug level for all commands."""
+    try:
+        env = _collect_relevant_env()
+        logger.debug(
+            "cli_invocation",
+            argv=sys.argv,
+            env=env,
+            category="cli",
+        )
+    except Exception:
+        # Never let logging context fail the CLI
+        pass

ccproxy/cli/options/claude_options.py

@@ -31,22 +31,6 @@ def validate_max_turns(
     return value
 
 
-def validate_permission_mode(
-    ctx: typer.Context, param: typer.CallbackParam, value: str | None
-) -> str | None:
-    """Validate permission mode."""
-    if value is None:
-        return None
-
-    valid_modes = {"default", "acceptEdits", "bypassPermissions"}
-    if value not in valid_modes:
-        raise typer.BadParameter(
-            f"Permission mode must be one of: {', '.join(valid_modes)}"
-        )
-
-    return value
-
-
 def validate_claude_cli_path(
     ctx: typer.Context, param: typer.CallbackParam, value: str | None
 ) -> str | None:
@@ -142,16 +126,13 @@ class ClaudeOptions:
         disallowed_tools: str | None = None,
         claude_cli_path: str | None = None,
         append_system_prompt: str | None = None,
-        permission_mode: str | None = None,
         max_turns: int | None = None,
         cwd: str | None = None,
-        permission_prompt_tool_name: str | None = None,
         sdk_message_mode: str | None = None,
         sdk_pool: bool = False,
         sdk_pool_size: int | None = None,
         sdk_session_pool: bool = False,
         system_prompt_injection_mode: str | None = None,
-        builtin_permissions: bool = True,
     ):
         """Initialize Claude options.
 
@@ -161,29 +142,23 @@ class ClaudeOptions:
             disallowed_tools: List of disallowed tools (comma-separated)
             claude_cli_path: Path to Claude CLI executable
             append_system_prompt: Additional system prompt to append
-            permission_mode: Permission mode
             max_turns: Maximum conversation turns
             cwd: Working directory path
-            permission_prompt_tool_name: Permission prompt tool name
             sdk_message_mode: SDK message handling mode
             sdk_pool: Enable general Claude SDK client connection pooling
             sdk_pool_size: Number of clients to maintain in the general pool
             sdk_session_pool: Enable session-aware Claude SDK client pooling
             system_prompt_injection_mode: System prompt injection mode
-            builtin_permissions: Enable built-in permission handling infrastructure
         """
         self.max_thinking_tokens = max_thinking_tokens
         self.allowed_tools = allowed_tools
         self.disallowed_tools = disallowed_tools
         self.claude_cli_path = claude_cli_path
         self.append_system_prompt = append_system_prompt
-        self.permission_mode = permission_mode
         self.max_turns = max_turns
         self.cwd = cwd
-        self.permission_prompt_tool_name = permission_prompt_tool_name
         self.sdk_message_mode = sdk_message_mode
         self.sdk_pool = sdk_pool
         self.sdk_pool_size = sdk_pool_size
         self.sdk_session_pool = sdk_session_pool
         self.system_prompt_injection_mode = system_prompt_injection_mode
-        self.builtin_permissions = builtin_permissions

ccproxy/config/__init__.py

@@ -1,10 +1,8 @@
 """Configuration module for Claude Proxy API Server."""
 
-from .auth import AuthSettings, CredentialStorageSettings, OAuthSettings
-from .docker_settings import DockerSettings
-from .reverse_proxy import ReverseProxySettings
-from .settings import Settings, get_settings
-from .validators import (
+from .core import CORSSettings, HTTPSettings, LoggingSettings, ServerSettings
+from .settings import Settings
+from .utils import (
     ConfigValidationError,
     validate_config_dict,
     validate_cors_origins,
@@ -19,12 +17,6 @@ from .validators import (
 
 __all__ = [
     "Settings",
-    "get_settings",
-    "AuthSettings",
-    "OAuthSettings",
-    "CredentialStorageSettings",
-    "ReverseProxySettings",
-    "DockerSettings",
     "ConfigValidationError",
     "validate_config_dict",
     "validate_cors_origins",
@@ -34,4 +26,8 @@ __all__ = [
     "validate_port",
     "validate_timeout",
     "validate_url",
+    "ServerSettings",
+    "LoggingSettings",
+    "HTTPSettings",
+    "CORSSettings",
 ]