ccproxy-api 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

ccproxy/cli/commands/serve.py

@@ -3,7 +3,7 @@
 import json
 import os
 from pathlib import Path
-from typing import Any
+from typing import Annotated, Any
 
 import typer
 import uvicorn
@@ -23,48 +23,25 @@ from ccproxy.config.settings import (
 )
 from ccproxy.core.async_utils import get_root_package_name
 from ccproxy.docker import (
-    DockerEnv,
-    DockerPath,
-    DockerUserContext,
-    DockerVolume,
     create_docker_adapter,
 )
 
 from ..docker import (
     _create_docker_adapter_from_settings,
 )
-from ..docker.params import (
-    docker_arg_option,
-    docker_env_option,
-    docker_home_option,
-    docker_image_option,
-    docker_volume_option,
-    docker_workspace_option,
-    user_gid_option,
-    user_mapping_option,
-    user_uid_option,
-)
 from ..options.claude_options import (
     ClaudeOptions,
-    allowed_tools_option,
-    append_system_prompt_option,
-    claude_cli_path_option,
-    cwd_option,
-    disallowed_tools_option,
-    max_thinking_tokens_option,
-    max_turns_option,
-    permission_mode_option,
-    permission_prompt_tool_name_option,
+    validate_claude_cli_path,
+    validate_cwd,
+    validate_max_thinking_tokens,
+    validate_max_turns,
+    validate_permission_mode,
 )
-from ..options.core_options import CoreOptions, config_option
-from ..options.security_options import SecurityOptions, auth_token_option
+from ..options.security_options import SecurityOptions, validate_auth_token
 from ..options.server_options import (
     ServerOptions,
-    host_option,
-    log_file_option,
-    log_level_option,
-    port_option,
-    reload_option,
+    validate_log_level,
+    validate_port,
 )
 
 
@@ -306,42 +283,236 @@ def _run_local_server(settings: Settings, cli_overrides: dict[str, Any]) -> None
 
 def api(
     # Configuration
-    config: Path | None = config_option(),
+    config: Annotated[
+        Path | None,
+        typer.Option(
+            "--config",
+            "-c",
+            help="Path to configuration file (TOML, JSON, or YAML)",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            rich_help_panel="Configuration",
+        ),
+    ] = None,
     # Server options
-    port: int | None = port_option(),
-    host: str | None = host_option(),
-    reload: bool | None = reload_option(),
-    log_level: str | None = log_level_option(),
-    log_file: str | None = log_file_option(),
+    port: Annotated[
+        int | None,
+        typer.Option(
+            "--port",
+            "-p",
+            help="Port to run the server on",
+            callback=validate_port,
+            rich_help_panel="Server Settings",
+        ),
+    ] = None,
+    host: Annotated[
+        str | None,
+        typer.Option(
+            "--host",
+            "-h",
+            help="Host to bind the server to",
+            rich_help_panel="Server Settings",
+        ),
+    ] = None,
+    reload: Annotated[
+        bool | None,
+        typer.Option(
+            "--reload/--no-reload",
+            help="Enable auto-reload for development",
+            rich_help_panel="Server Settings",
+        ),
+    ] = None,
+    log_level: Annotated[
+        str | None,
+        typer.Option(
+            "--log-level",
+            help="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+            callback=validate_log_level,
+            rich_help_panel="Server Settings",
+        ),
+    ] = None,
+    log_file: Annotated[
+        str | None,
+        typer.Option(
+            "--log-file",
+            help="Path to JSON log file. If specified, logs will be written to this file in JSON format",
+            rich_help_panel="Server Settings",
+        ),
+    ] = None,
     # Security options
-    auth_token: str | None = auth_token_option(),
+    auth_token: Annotated[
+        str | None,
+        typer.Option(
+            "--auth-token",
+            help="Bearer token for API authentication",
+            callback=validate_auth_token,
+            rich_help_panel="Security Settings",
+        ),
+    ] = None,
     # Claude options
-    max_thinking_tokens: int | None = max_thinking_tokens_option(),
-    allowed_tools: str | None = allowed_tools_option(),
-    disallowed_tools: str | None = disallowed_tools_option(),
-    claude_cli_path: str | None = claude_cli_path_option(),
-    append_system_prompt: str | None = append_system_prompt_option(),
-    permission_mode: str | None = permission_mode_option(),
-    max_turns: int | None = max_turns_option(),
-    cwd: str | None = cwd_option(),
-    permission_prompt_tool_name: str | None = permission_prompt_tool_name_option(),
+    max_thinking_tokens: Annotated[
+        int | None,
+        typer.Option(
+            "--max-thinking-tokens",
+            help="Maximum thinking tokens for Claude Code",
+            callback=validate_max_thinking_tokens,
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    allowed_tools: Annotated[
+        str | None,
+        typer.Option(
+            "--allowed-tools",
+            help="List of allowed tools (comma-separated)",
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    disallowed_tools: Annotated[
+        str | None,
+        typer.Option(
+            "--disallowed-tools",
+            help="List of disallowed tools (comma-separated)",
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    claude_cli_path: Annotated[
+        str | None,
+        typer.Option(
+            "--claude-cli-path",
+            help="Path to Claude CLI executable",
+            callback=validate_claude_cli_path,
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    append_system_prompt: Annotated[
+        str | None,
+        typer.Option(
+            "--append-system-prompt",
+            help="Additional system prompt to append",
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    permission_mode: Annotated[
+        str | None,
+        typer.Option(
+            "--permission-mode",
+            help="Permission mode: default, acceptEdits, or bypassPermissions",
+            callback=validate_permission_mode,
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    max_turns: Annotated[
+        int | None,
+        typer.Option(
+            "--max-turns",
+            help="Maximum conversation turns",
+            callback=validate_max_turns,
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    cwd: Annotated[
+        str | None,
+        typer.Option(
+            "--cwd",
+            help="Working directory path",
+            callback=validate_cwd,
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
+    permission_prompt_tool_name: Annotated[
+        str | None,
+        typer.Option(
+            "--permission-prompt-tool-name",
+            help="Permission prompt tool name",
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
     # Core settings
-    docker: bool = typer.Option(
-        False,
-        "--docker",
-        "-d",
-        help="Run API server using Docker instead of local execution",
-    ),
+    docker: Annotated[
+        bool,
+        typer.Option(
+            "--docker",
+            "-d",
+            help="Run API server using Docker instead of local execution",
+        ),
+    ] = False,
     # Docker settings using shared parameters
-    docker_image: str | None = docker_image_option(),
-    docker_env: list[str] = docker_env_option(),
-    docker_volume: list[str] = docker_volume_option(),
-    docker_arg: list[str] = docker_arg_option(),
-    docker_home: str | None = docker_home_option(),
-    docker_workspace: str | None = docker_workspace_option(),
-    user_mapping_enabled: bool | None = user_mapping_option(),
-    user_uid: int | None = user_uid_option(),
-    user_gid: int | None = user_gid_option(),
+    docker_image: Annotated[
+        str | None,
+        typer.Option(
+            "--docker-image",
+            help="Docker image to use (overrides configuration)",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--docker-env",
+            "-e",
+            help="Environment variables to pass to Docker container",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_volume: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--docker-volume",
+            "-v",
+            help="Volume mounts for Docker container",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_arg: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--docker-arg",
+            help="Additional arguments to pass to docker run",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_home: Annotated[
+        str | None,
+        typer.Option(
+            "--docker-home",
+            help="Override the home directory for Docker",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_workspace: Annotated[
+        str | None,
+        typer.Option(
+            "--docker-workspace",
+            help="Override the workspace directory for Docker",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    user_mapping_enabled: Annotated[
+        bool | None,
+        typer.Option(
+            "--user-mapping/--no-user-mapping",
+            help="Enable user mapping for Docker",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    user_uid: Annotated[
+        int | None,
+        typer.Option(
+            "--user-uid",
+            help="User UID for Docker user mapping",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    user_gid: Annotated[
+        int | None,
+        typer.Option(
+            "--user-gid",
+            help="User GID for Docker user mapping",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
 ) -> None:
     """
     Start the CCProxy API server.
@@ -496,26 +667,95 @@ def api(
 
 
 def claude(
-    args: list[str] | None = typer.Argument(
-        default=None,
-        help="Arguments to pass to claude CLI (e.g. --version, doctor, config)",
-    ),
-    docker: bool = typer.Option(
-        False,
-        "--docker",
-        "-d",
-        help="Run claude command from docker image instead of local CLI",
-    ),
+    args: Annotated[
+        list[str] | None,
+        typer.Argument(
+            help="Arguments to pass to claude CLI (e.g. --version, doctor, config)",
+        ),
+    ] = None,
+    docker: Annotated[
+        bool,
+        typer.Option(
+            "--docker",
+            "-d",
+            help="Run claude command from docker image instead of local CLI",
+        ),
+    ] = False,
     # Docker settings using shared parameters
-    docker_image: str | None = docker_image_option(),
-    docker_env: list[str] = docker_env_option(),
-    docker_volume: list[str] = docker_volume_option(),
-    docker_arg: list[str] = docker_arg_option(),
-    docker_home: str | None = docker_home_option(),
-    docker_workspace: str | None = docker_workspace_option(),
-    user_mapping_enabled: bool | None = user_mapping_option(),
-    user_uid: int | None = user_uid_option(),
-    user_gid: int | None = user_gid_option(),
+    docker_image: Annotated[
+        str | None,
+        typer.Option(
+            "--docker-image",
+            help="Docker image to use (overrides configuration)",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--docker-env",
+            "-e",
+            help="Environment variables to pass to Docker container",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_volume: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--docker-volume",
+            "-v",
+            help="Volume mounts for Docker container",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_arg: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--docker-arg",
+            help="Additional arguments to pass to docker run",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_home: Annotated[
+        str | None,
+        typer.Option(
+            "--docker-home",
+            help="Override the home directory for Docker",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    docker_workspace: Annotated[
+        str | None,
+        typer.Option(
+            "--docker-workspace",
+            help="Override the workspace directory for Docker",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    user_mapping_enabled: Annotated[
+        bool | None,
+        typer.Option(
+            "--user-mapping/--no-user-mapping",
+            help="Enable user mapping for Docker",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    user_uid: Annotated[
+        int | None,
+        typer.Option(
+            "--user-uid",
+            help="User UID for Docker user mapping",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
+    user_gid: Annotated[
+        int | None,
+        typer.Option(
+            "--user-gid",
+            help="User GID for Docker user mapping",
+            rich_help_panel="Docker Settings",
+        ),
+    ] = None,
 ) -> None:
     """
     Execute claude CLI commands directly.

ccproxy/cli/main.py

@@ -1,10 +1,9 @@
 """Main entry point for CCProxy API Server."""
 
-import json
 import os
 import secrets
 from pathlib import Path
-from typing import Any, Optional, cast
+from typing import Annotated, Any, Optional, cast
 
 import typer
 from click import get_current_context
@@ -26,14 +25,10 @@ from ccproxy.config.settings import (
 )
 from ccproxy.core.async_utils import get_package_dir, get_root_package_name
 from ccproxy.core.logging import setup_logging
-from ccproxy.models.responses import (
-    PermissionToolAllowResponse,
-    PermissionToolDenyResponse,
-)
 
 from .commands.auth import app as auth_app
 from .commands.config import app as config_app
-from .commands.serve import api, get_config_path_from_context
+from .commands.serve import api
 
 
 def version_callback(value: bool) -> None:
@@ -49,6 +44,7 @@ app = typer.Typer(
     add_completion=True,
     no_args_is_help=False,
     pretty_exceptions_enable=False,
+    invoke_without_command=True,
 )
 
 # Logger will be configured by configuration manager
@@ -59,30 +55,42 @@ logger = get_logger(__name__)
 @app.callback()
 def app_main(
     ctx: typer.Context,
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        callback=version_callback,
-        is_eager=True,
-        help="Show version and exit.",
-    ),
-    config: Path | None = typer.Option(
-        None,
-        "--config",
-        "-c",
-        help="Path to configuration file (TOML, JSON, or YAML)",
-        exists=True,
-        file_okay=True,
-        dir_okay=False,
-        readable=True,
-    ),
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-V",
+            callback=version_callback,
+            is_eager=True,
+            help="Show version and exit.",
+        ),
+    ] = False,
+    config: Annotated[
+        Path | None,
+        typer.Option(
+            "--config",
+            "-c",
+            help="Path to configuration file (TOML, JSON, or YAML)",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ] = None,
 ) -> None:
     """CCProxy API Server - Anthropic and OpenAI compatible interface for Claude."""
     # Store config path for commands to use
     ctx.ensure_object(dict)
     ctx.obj["config_path"] = config
 
+    # If no command is invoked, run the serve command by default
+    if ctx.invoked_subcommand is None:
+        # Import here to avoid circular imports
+        from .commands.serve import api
+
+        # Invoke the serve command
+        ctx.invoke(api)
+
 
 # Register config command
 app.add_typer(config_app)
@@ -96,92 +104,6 @@ app.command(name="serve")(api)
 # Claude command removed - functionality moved to serve command
 
 
-@app.command()
-def permission_tool(
-    tool_name: str = typer.Argument(
-        ..., help="Name of the tool to check permissions for"
-    ),
-    tool_input: str = typer.Argument(..., help="JSON string of the tool input"),
-) -> None:
-    """
-    MCP permission prompt tool for Claude Code SDK.
-
-    This tool is used by the Claude Code SDK to check permissions for tool calls.
-    It returns a JSON response indicating whether the tool call should be allowed or denied.
-
-    Response format:
-    - Allow: {"behavior": "allow", "updatedInput": {...}}
-    - Deny: {"behavior": "deny", "message": "reason"}
-
-    Examples:
-        ccproxy permission_tool "bash" '{"command": "ls -la"}'
-        ccproxy permission_tool "edit_file" '{"path": "/etc/passwd", "content": "..."}'
-    """
-    toolkit = get_rich_toolkit()
-
-    try:
-        # Parse the tool input JSON
-        try:
-            input_data = json.loads(tool_input)
-        except json.JSONDecodeError as e:
-            response = PermissionToolDenyResponse(message=f"Invalid JSON input: {e}")
-            toolkit.print(response.model_dump_json(by_alias=True), tag="result")
-            raise typer.Exit(1) from e
-
-        # Load settings to get permission configuration
-        settings = config_manager.load_settings(
-            config_path=get_config_path_from_context()
-        )
-
-        # Basic permission checking logic
-        # This can be extended with more sophisticated rules
-
-        # Check for potentially dangerous commands
-        dangerous_patterns = [
-            "rm -rf",
-            "sudo",
-            "passwd",
-            "chmod 777",
-            "/etc/passwd",
-            "/etc/shadow",
-            "format",
-            "mkfs",
-        ]
-
-        # Convert input to string for pattern matching
-        input_str = json.dumps(input_data).lower()
-
-        # Check for dangerous patterns
-        for pattern in dangerous_patterns:
-            if pattern in input_str:
-                response = PermissionToolDenyResponse(
-                    message=f"Tool call contains potentially dangerous pattern: {pattern}"
-                )
-                toolkit.print(response.model_dump_json(by_alias=True), tag="result")
-                return
-
-        # Check for specific tool restrictions
-        restricted_tools = {"exec", "system", "shell", "subprocess"}
-
-        if tool_name.lower() in restricted_tools:
-            response = PermissionToolDenyResponse(
-                message=f"Tool {tool_name} is restricted for security reasons"
-            )
-            toolkit.print(response.model_dump_json(by_alias=True), tag="result")
-            return
-
-        # Allow the tool call with original input
-        allow_response = PermissionToolAllowResponse(updated_input=input_data)
-        toolkit.print(allow_response.model_dump_json(by_alias=True), tag="result")
-
-    except Exception as e:
-        error_response = PermissionToolDenyResponse(
-            message=f"Error processing permission request: {e}"
-        )
-        toolkit.print(error_response.model_dump_json(by_alias=True), tag="result")
-        raise typer.Exit(1) from e
-
-
 def main() -> None:
     """Entry point for the CLI application."""
     app()