ccproxy-api 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

ccproxy/cli/commands/serve.py

@@ -10,7 +10,6 @@ import uvicorn
 from click import get_current_context
 from structlog import get_logger
 
-from ccproxy._version import __version__
 from ccproxy.cli.helpers import (
     get_rich_toolkit,
     is_running_in_docker,
@@ -35,6 +34,8 @@ from ..options.claude_options import (
     validate_cwd,
     validate_max_thinking_tokens,
     validate_max_turns,
+    validate_permission_mode,
+    validate_sdk_message_mode,
 )
 from ..options.security_options import SecurityOptions, validate_auth_token
 from ..options.server_options import (
@@ -44,10 +45,6 @@ from ..options.server_options import (
 )
 
 
-# Logger will be configured by configuration manager
-logger = get_logger(__name__)
-
-
 def get_config_path_from_context() -> Path | None:
     """Get config path from typer context if available."""
     try:
@@ -327,7 +324,7 @@ def api(
         str | None,
         typer.Option(
             "--log-level",
-            help="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+            help="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL). Use WARNING for minimal output.",
             callback=validate_log_level,
             rich_help_panel="Server Settings",
         ),
@@ -340,6 +337,14 @@ def api(
             rich_help_panel="Server Settings",
         ),
     ] = None,
+    use_terminal_permission_handler: Annotated[
+        bool,
+        typer.Option(
+            "--terminal-permission-handler",
+            help="Enable terminal permission terminal handler",
+            rich_help_panel="Server Settings",
+        ),
+    ] = False,
     # Security options
     auth_token: Annotated[
         str | None,
@@ -393,6 +398,15 @@ def api(
             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(
@@ -411,6 +425,23 @@ def api(
             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,
+    sdk_message_mode: Annotated[
+        str | None,
+        typer.Option(
+            "--sdk-message-mode",
+            help="SDK message handling mode: forward (direct SDK blocks), ignore (skip blocks), formatted (XML tags with JSON data)",
+            callback=validate_sdk_message_mode,
+            rich_help_panel="Claude Settings",
+        ),
+    ] = None,
     # Core settings
     docker: Annotated[
         bool,
@@ -528,6 +559,7 @@ def api(
             reload=reload,
             log_level=log_level,
             log_file=log_file,
+            use_terminal_confirmation_handler=use_terminal_permission_handler,
         )
 
         claude_options = ClaudeOptions(
@@ -536,8 +568,11 @@ def api(
             disallowed_tools=disallowed_tools,
             claude_cli_path=claude_cli_path,
             append_system_prompt=append_system_prompt,
+            permission_mode=permission_mode,
             max_turns=max_turns,
             cwd=cwd,
+            permission_prompt_tool_name=permission_prompt_tool_name,
+            sdk_message_mode=sdk_message_mode,
         )
 
         security_options = SecurityOptions(auth_token=auth_token)
@@ -550,6 +585,7 @@ def api(
             reload=server_options.reload,
             log_level=server_options.log_level,
             log_file=server_options.log_file,
+            use_terminal_confirmation_handler=server_options.use_terminal_confirmation_handler,
             # Security options
             auth_token=security_options.auth_token,
             # Claude options
@@ -558,8 +594,11 @@ def api(
             allowed_tools=claude_options.allowed_tools,
             disallowed_tools=claude_options.disallowed_tools,
             append_system_prompt=claude_options.append_system_prompt,
+            permission_mode=claude_options.permission_mode,
             max_turns=claude_options.max_turns,
+            permission_prompt_tool_name=claude_options.permission_prompt_tool_name,
             cwd=claude_options.cwd,
+            sdk_message_mode=claude_options.sdk_message_mode,
         )
 
         # Load settings with CLI overrides
@@ -569,17 +608,16 @@ def api(
 
         # Set up logging once with the effective log level
         # Import here to avoid circular import
-        import structlog
 
         from ccproxy.core.logging import setup_logging
 
         # Always reconfigure logging to ensure log level changes are picked up
         # Use JSON logs if explicitly requested via env var
-        json_logs = os.environ.get("CCPROXY_JSON_LOGS", "").lower() == "true"
+        print(f"{settings.server.log_level} {settings.server.log_file}")
         setup_logging(
-            json_logs=json_logs,
-            log_level=server_options.log_level or settings.server.log_level,
-            log_file=server_options.log_file or settings.server.log_file,
+            json_logs=settings.server.log_format == "json",
+            log_level_name=settings.server.log_level,
+            log_file=settings.server.log_file,
         )
 
         # Re-get logger after logging is configured
@@ -602,7 +640,7 @@ def api(
         )
 
         # Log effective configuration
-        logger.info(
+        logger.debug(
             "configuration_loaded",
             host=settings.server.host,
             port=settings.server.port,
@@ -756,6 +794,8 @@ def claude(
     toolkit = get_rich_toolkit()
 
     try:
+        # Logger will be configured by configuration manager
+        logger = get_logger(__name__)
         # Log CLI command execution start
         logger.info(
             "cli_command_starting",

ccproxy/cli/docker/params.py

@@ -82,8 +82,6 @@ def validate_docker_home(
     if value is None:
         return None
 
-    from pathlib import Path
-
     from ccproxy.config.docker_settings import validate_host_path
 
     try:
@@ -116,8 +114,6 @@ def validate_docker_workspace(
     if value is None:
         return None
 
-    from pathlib import Path
-
     from ccproxy.config.docker_settings import validate_host_path
 
     try:

ccproxy/cli/helpers.py

@@ -1,12 +1,10 @@
 """CLI helper utilities for CCProxy API."""
 
-import logging
 from pathlib import Path
 from typing import Any
 
 from rich_toolkit import RichToolkit, RichToolkitTheme
 from rich_toolkit.styles import TaggedStyle
-from uvicorn.logging import DefaultFormatter
 
 from ccproxy.core.async_utils import patched_typing
 

ccproxy/cli/main.py

@@ -1,34 +1,20 @@
 """Main entry point for CCProxy API Server."""
 
-import os
-import secrets
 from pathlib import Path
-from typing import Annotated, Any, Optional, cast
+from typing import Annotated
 
 import typer
-from click import get_current_context
 from structlog import get_logger
-from typer import Typer
 
 from ccproxy._version import __version__
-from ccproxy.api.middleware.cors import setup_cors_middleware
 from ccproxy.cli.helpers import (
     get_rich_toolkit,
-    is_running_in_docker,
-    warning,
 )
-from ccproxy.config.settings import (
-    ConfigurationError,
-    Settings,
-    config_manager,
-    get_settings,
-)
-from ccproxy.core.async_utils import get_package_dir, get_root_package_name
-from ccproxy.core.logging import setup_logging
 
 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.permission_handler import app as permission_handler_app
+from .commands.serve import api
 
 
 def version_callback(value: bool) -> None:
@@ -98,6 +84,9 @@ app.add_typer(config_app)
 # Register auth command
 app.add_typer(auth_app)
 
+# Register permission handler command
+app.add_typer(permission_handler_app)
+
 
 # Register imported commands
 app.command(name="serve")(api)

ccproxy/cli/options/claude_options.py

@@ -1,7 +1,6 @@
 """Claude-specific CLI options."""
 
 from pathlib import Path
-from typing import Any
 
 import typer
 
@@ -32,6 +31,22 @@ 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:
@@ -62,6 +77,22 @@ def validate_cwd(
     return value
 
 
+def validate_sdk_message_mode(
+    ctx: typer.Context, param: typer.CallbackParam, value: str | None
+) -> str | None:
+    """Validate SDK message mode."""
+    if value is None:
+        return None
+
+    valid_modes = {"forward", "ignore", "formatted"}
+    if value not in valid_modes:
+        raise typer.BadParameter(
+            f"SDK message mode must be one of: {', '.join(valid_modes)}"
+        )
+
+    return value
+
+
 # Factory functions removed - use Annotated syntax directly in commands
 
 
@@ -79,8 +110,11 @@ 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,
     ):
         """Initialize Claude options.
 
@@ -90,13 +124,19 @@ 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
         """
         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

ccproxy/cli/options/core_options.py

@@ -1,9 +1,6 @@
 """Core CLI options for configuration and global settings."""
 
 from pathlib import Path
-from typing import Any
-
-import typer
 
 
 # Factory functions removed - use Annotated syntax directly in commands

ccproxy/cli/options/security_options.py

@@ -1,7 +1,5 @@
 """Security-related CLI options."""
 
-from typing import Any
-
 import typer
 
 

ccproxy/cli/options/server_options.py

@@ -1,7 +1,5 @@
 """Server-related CLI options."""
 
-from typing import Any
-
 import typer
 
 
@@ -49,6 +47,7 @@ class ServerOptions:
         reload: bool | None = None,
         log_level: str | None = None,
         log_file: str | None = None,
+        use_terminal_confirmation_handler: bool | None = None,
     ):
         """Initialize server options.
 
@@ -58,9 +57,11 @@ class ServerOptions:
             reload: Enable auto-reload for development
             log_level: Logging level
             log_file: Path to JSON log file
+            use_terminal_confirmation_handler: Enable terminal UI for confirmation prompts
         """
         self.port = port
         self.host = host
         self.reload = reload
         self.log_level = log_level
         self.log_file = log_file
+        self.use_terminal_confirmation_handler = use_terminal_confirmation_handler

ccproxy/config/auth.py

@@ -1,6 +1,5 @@
 """Authentication and credentials configuration."""
 
-import os
 from pathlib import Path
 from typing import Any
 

ccproxy/config/claude.py

@@ -2,9 +2,11 @@
 
 import os
 import shutil
+from enum import Enum
 from pathlib import Path
 from typing import Any
 
+import structlog
 from pydantic import BaseModel, Field, field_validator
 
 from ccproxy.core.async_utils import get_package_dir, patched_typing
@@ -14,6 +16,31 @@ from ccproxy.core.async_utils import get_package_dir, patched_typing
 with patched_typing():
     from claude_code_sdk import ClaudeCodeOptions  # noqa: E402
 
+logger = structlog.get_logger(__name__)
+
+
+def _create_default_claude_code_options() -> ClaudeCodeOptions:
+    """Create ClaudeCodeOptions with default values."""
+    return ClaudeCodeOptions(
+        mcp_servers={
+            "confirmation": {"type": "sse", "url": "http://127.0.0.1:8000/mcp"}
+        },
+        permission_prompt_tool_name="mcp__confirmation__check_permission",
+    )
+
+
+class SDKMessageMode(str, Enum):
+    """Modes for handling SDK messages from Claude SDK.
+
+    - forward: Forward SDK content blocks directly with original types and metadata
+    - ignore: Skip SDK messages and blocks completely
+    - formatted: Format as XML tags with JSON data in text deltas
+    """
+
+    FORWARD = "forward"
+    IGNORE = "ignore"
+    FORMATTED = "formatted"
+
 
 class ClaudeSettings(BaseModel):
     """Claude-specific configuration settings."""
@@ -24,10 +51,20 @@ class ClaudeSettings(BaseModel):
     )
 
     code_options: ClaudeCodeOptions = Field(
-        default_factory=lambda: ClaudeCodeOptions(),
+        default_factory=_create_default_claude_code_options,
         description="Claude Code SDK options configuration",
     )
 
+    sdk_message_mode: SDKMessageMode = Field(
+        default=SDKMessageMode.FORWARD,
+        description="Mode for handling SDK messages from Claude SDK. Options: forward (direct SDK blocks), ignore (skip blocks), formatted (XML tags with JSON data)",
+    )
+
+    pretty_format: bool = Field(
+        default=True,
+        description="Whether to use pretty formatting (indented JSON, newlines after XML tags, unescaped content). When false: compact JSON, no newlines, escaped content between XML tags",
+    )
+
     @field_validator("cli_path")
     @classmethod
     def validate_claude_cli_path(cls, v: str | None) -> str | None:
@@ -47,12 +84,51 @@ class ClaudeSettings(BaseModel):
     def validate_claude_code_options(cls, v: Any) -> Any:
         """Validate and convert Claude Code options."""
         if v is None:
-            return ClaudeCodeOptions()
+            # Create instance with default values (same as default_factory)
+            return _create_default_claude_code_options()
 
         # If it's already a ClaudeCodeOptions instance, return as-is
         if isinstance(v, ClaudeCodeOptions):
             return v
 
+        # If it's an empty dict, treat it like None and use defaults
+        if isinstance(v, dict) and not v:
+            return _create_default_claude_code_options()
+
+        # For non-empty dicts, merge with defaults instead of replacing them
+        if isinstance(v, dict):
+            # Start with default values
+            defaults = _create_default_claude_code_options()
+
+            # Extract default values as a dict for merging
+            default_values = {
+                "mcp_servers": defaults.mcp_servers.copy(),
+                "permission_prompt_tool_name": defaults.permission_prompt_tool_name,
+            }
+
+            # Add other default attributes if they exist
+            for attr in [
+                "max_thinking_tokens",
+                "allowed_tools",
+                "disallowed_tools",
+                "cwd",
+                "append_system_prompt",
+                "max_turns",
+                "continue_conversation",
+                "permission_mode",
+                "model",
+                "system_prompt",
+            ]:
+                if hasattr(defaults, attr):
+                    default_value = getattr(defaults, attr, None)
+                    if default_value is not None:
+                        default_values[attr] = default_value
+
+            # Merge CLI overrides with defaults (CLI overrides take precedence)
+            merged_values = {**default_values, **v}
+
+            return ClaudeCodeOptions(**merged_values)
+
         # Try to convert to dict if possible
         if hasattr(v, "model_dump"):
             return v.model_dump()

ccproxy/config/discovery.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import Optional
 
 from ccproxy.core.system import get_xdg_config_home
 

ccproxy/config/docker_settings.py

@@ -1,7 +1,6 @@
 """Docker settings configuration for CCProxy API."""
 
 import os
-from typing import Any
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 

ccproxy/config/loader.py

@@ -1,10 +1,7 @@
 """Configuration file loader for ccproxy."""
 
-import os
 from pathlib import Path
-from typing import Any, Optional
-
-from pydantic import BaseModel
+from typing import Any
 
 from ccproxy.config.discovery import find_toml_config_file
 from ccproxy.config.settings import Settings

ccproxy/config/scheduler.py

@@ -82,6 +82,26 @@ class SchedulerSettings(BaseSettings):
         description="Interval in seconds between stats printing",
     )
 
+    # Version checking task settings
+    version_check_enabled: bool = Field(
+        default=True,
+        description="Whether version update checking is enabled",
+    )
+
+    version_check_interval_hours: int = Field(
+        default=12,
+        ge=1,
+        le=168,  # Max 1 week
+        description="Interval in hours between version checks",
+    )
+
+    version_check_startup_max_age_hours: float = Field(
+        default=1.0,
+        ge=0.1,
+        le=24.0,
+        description="Maximum age in hours since last check before running startup check",
+    )
+
     model_config = SettingsConfigDict(
         env_prefix="SCHEDULER__",
         case_sensitive=False,

ccproxy/config/security.py

@@ -1,7 +1,5 @@
 """Security configuration settings."""
 
-from typing import Literal
-
 from pydantic import BaseModel, Field
 
 
@@ -12,3 +10,10 @@ class SecuritySettings(BaseModel):
         default=None,
         description="Bearer token for API authentication (optional)",
     )
+
+    confirmation_timeout_seconds: int = Field(
+        default=30,
+        ge=5,
+        le=300,
+        description="Timeout in seconds for permission confirmation requests (5-300)",
+    )

ccproxy/config/server.py

@@ -60,6 +60,11 @@ class ServerSettings(BaseModel):
         description="Path to JSON log file. If specified, logs will be written to this file in JSON format",
     )
 
+    use_terminal_permission_handler: bool = Field(
+        default=False,
+        description="Enable terminal UI for permission prompts. Set to False to use external handler via SSE (not implemented)",
+    )
+
     @field_validator("log_level")
     @classmethod
     def validate_log_level(cls, v: str) -> str:

ccproxy/config/settings.py

@@ -3,17 +3,15 @@
 import contextlib
 import json
 import os
-import shutil
 import tomllib
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+import structlog
+from pydantic import Field, field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from ccproxy import __version__
-from ccproxy.config.discovery import find_toml_config_file, get_claude_cli_config_dir
-from ccproxy.core.async_utils import format_version, get_package_dir, patched_typing
+from ccproxy.config.discovery import find_toml_config_file
 
 from .auth import AuthSettings
 from .claude import ClaudeSettings
@@ -463,13 +461,20 @@ class ConfigurationManager:
         if cli_args.get("claude_cli_path") is not None:
             claude_settings["cli_path"] = cli_args["claude_cli_path"]
 
+        # Direct Claude settings (not nested in code_options)
+        for key in ["sdk_message_mode"]:
+            if cli_args.get(key) is not None:
+                claude_settings[key] = cli_args[key]
+
         # Claude Code options
         claude_opts = {}
         for key in [
             "max_thinking_tokens",
+            "permission_mode",
             "cwd",
             "max_turns",
             "append_system_prompt",
+            "permission_prompt_tool_name",
             "continue_conversation",
         ]:
             if cli_args.get(key) is not None:
@@ -506,6 +511,8 @@ class ConfigurationManager:
 # Global configuration manager instance
 config_manager = ConfigurationManager()
 
+logger = structlog.get_logger(__name__)
+
 
 def get_settings(config_path: Path | str | None = None) -> Settings:
     """Get the global settings instance with configuration file support.
@@ -525,7 +532,8 @@ def get_settings(config_path: Path | str | None = None) -> Settings:
             with contextlib.suppress(json.JSONDecodeError):
                 cli_overrides = json.loads(cli_overrides_json)
 
-        return Settings.from_config(config_path=config_path, **cli_overrides)
+        settings = Settings.from_config(config_path=config_path, **cli_overrides)
+        return settings
     except Exception as e:
         # If settings can't be loaded (e.g., missing API key),
         # this will be handled by the caller

ccproxy/config/validators.py

@@ -2,7 +2,7 @@
 
 import re
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 from urllib.parse import urlparse
 
 

ccproxy/core/async_utils.py

@@ -465,15 +465,12 @@ def validate_config_with_schema(
     import json
     import subprocess
     import tempfile
-    from typing import Any
 
     # Import tomllib for Python 3.11+ or fallback to tomli
     try:
         import tomllib
     except ImportError:
-        import tomli as tomllib  # type: ignore[import-not-found,no-redef]
-
-    from ccproxy.config.settings import Settings
+        import tomli as tomllib  # type: ignore[no-redef]
 
     config_path = Path()