ccproxy-api 0.1.1__tar.gz → 0.1.2__tar.gz

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.2] - 2025-07-22
+
+### Added
+- **Permission Mode Support**: Restored `--permission-mode` option supporting default, acceptEdits, and bypassPermissions modes
+- **Custom Permission Tool**: Restored `--permission-prompt-tool-name` option to specify custom permission tool names
+- **Permission Response Models**: Added `PermissionToolAllowResponse` and `PermissionToolDenyResponse` models with proper JSON serialization
+
+### Changed
+- **Message Formatting**: Modified `MessageConverter.combine_text_parts()` to join text parts with newlines instead of spaces, preserving formatting in multi-line content
+- **Settings Integration**: Enhanced OptionsHandler to apply default Claude options from settings before API parameters
+- **Configuration**: Extended settings to persist permission_mode and permission_prompt_tool_name
+
+### Fixed
+- **Claude SDK Options**: Integrated Settings dependency into ClaudeSDKService to support configuration-based options
+
 ## [0.1.1] - 2025-07-22
 
 ### Added

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccproxy-api
-Version: 0.1.1
+Version: 0.1.2
 Summary: API server that provides an Anthropic and OpenAI compatible interface over Claude Code, allowing to use your Claude OAuth account or over the API.
 License-File: LICENSE
 Requires-Python: >=3.11

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/api/dependencies.py

@@ -22,11 +22,13 @@ SettingsDep = Annotated[Settings, Depends(get_settings)]
 
 
 def get_claude_service(
+    settings: SettingsDep,
     auth_manager: AuthManagerDep,
 ) -> ClaudeSDKService:
     """Get Claude SDK service instance.
 
     Args:
+        settings: Application settings dependency
         auth_manager: Authentication manager dependency
 
     Returns:
@@ -39,6 +41,7 @@ def get_claude_service(
     return ClaudeSDKService(
         auth_manager=auth_manager,
         metrics=metrics,
+        settings=settings,
     )
 
 

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/claude_sdk/converter.py

@@ -109,7 +109,7 @@ class MessageConverter:
         for block in contents:
             text_parts.append(MessageConverter.extract_text_from_content(block))
 
-        return " ".join(text_parts)
+        return "\n".join(text_parts)
 
     @staticmethod
     def convert_to_anthropic_response(

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/claude_sdk/options.py

@@ -2,6 +2,7 @@
 
 from typing import Any
 
+from ccproxy.config.settings import Settings
 from ccproxy.core.async_utils import patched_typing
 
 
@@ -14,8 +15,17 @@ class OptionsHandler:
     Handles creation and management of Claude SDK options.
     """
 
-    @staticmethod
+    def __init__(self, settings: Settings | None = None) -> None:
+        """
+        Initialize options handler.
+
+        Args:
+            settings: Application settings containing default Claude options
+        """
+        self.settings = settings
+
     def create_options(
+        self,
         model: str,
         temperature: float | None = None,
         max_tokens: int | None = None,
@@ -37,6 +47,18 @@ class OptionsHandler:
         """
         options = ClaudeCodeOptions(model=model)
 
+        # First apply settings from configuration if available
+        if self.settings and self.settings.claude.code_options:
+            code_opts = self.settings.claude.code_options
+
+            # Apply settings from configuration
+            for attr_name in dir(code_opts):
+                if not attr_name.startswith("_"):
+                    value = getattr(code_opts, attr_name, None)
+                    if value is not None and hasattr(options, attr_name):
+                        setattr(options, attr_name, value)
+
+        # Then apply API parameters (these override settings)
         if temperature is not None:
             options.temperature = temperature  # type: ignore[attr-defined]
 

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/cli/commands/__init__.py

@@ -2,7 +2,8 @@
 
 from .auth import app as auth_app
 from .config import app as config_app
+from .permission import app as permission_app
 from .serve import api
 
 
-__all__ = ["api", "auth_app", "config_app"]
+__all__ = ["api", "auth_app", "config_app", "permission_app"]

ccproxy_api-0.1.2/ccproxy/cli/commands/permission.py

@@ -0,0 +1,128 @@
+"""MCP permission prompt tool for Claude Code SDK."""
+
+import json
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import typer
+from structlog import get_logger
+
+from ccproxy.config.settings import config_manager
+from ccproxy.models.responses import (
+    PermissionToolAllowResponse,
+    PermissionToolDenyResponse,
+)
+
+
+app = typer.Typer(
+    rich_markup_mode="rich",
+    add_completion=False,
+    no_args_is_help=False,
+    pretty_exceptions_enable=False,
+)
+
+logger = get_logger(__name__)
+
+
+@app.command()
+def permission_tool(
+    tool_name: Annotated[
+        str, typer.Argument(help="Name of the tool to check permissions for")
+    ],
+    tool_input: Annotated[str, typer.Argument(help="JSON string of the tool input")],
+    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:
+    """
+    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-perm "bash" '{"command": "ls -la"}'
+        ccproxy-perm "edit_file" '{"path": "/etc/passwd", "content": "..."}'
+    """
+
+    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}")
+            print(response.model_dump_json(by_alias=True))
+            raise typer.Exit(1) from e
+
+        # Load settings to get permission configuration
+        settings = config_manager.load_settings(config_path=config)
+
+        # 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}"
+                )
+                print(response.model_dump_json(by_alias=True))
+                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"
+            )
+            print(response.model_dump_json(by_alias=True))
+            return
+
+        # Allow the tool call with original input
+        allow_response = PermissionToolAllowResponse(updated_input=input_data)
+        print(allow_response.model_dump_json(by_alias=True))
+
+    except Exception as e:
+        error_response = PermissionToolDenyResponse(
+            message=f"Error processing permission request: {e}"
+        )
+        print(error_response.model_dump_json(by_alias=True))
+        raise typer.Exit(1) from e
+
+
+def main() -> None:
+    """Entry point for ccproxy-perm command."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/cli/commands/serve.py

@@ -35,6 +35,7 @@ from ..options.claude_options import (
     validate_cwd,
     validate_max_thinking_tokens,
     validate_max_turns,
+    validate_permission_mode,
 )
 from ..options.security_options import SecurityOptions, validate_auth_token
 from ..options.server_options import (
@@ -393,6 +394,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 +421,14 @@ 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,
     # Core settings
     docker: Annotated[
         bool,
@@ -536,8 +554,10 @@ 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,
         )
 
         security_options = SecurityOptions(auth_token=auth_token)
@@ -558,7 +578,9 @@ 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,
         )
 

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/cli/main.py

@@ -28,7 +28,7 @@ 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.serve import api
 
 
 def version_callback(value: bool) -> None:

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/cli/options/claude_options.py

@@ -32,6 +32,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:
@@ -79,8 +95,10 @@ 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,
     ):
         """Initialize Claude options.
 
@@ -90,13 +108,17 @@ 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
         """
         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

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/config/settings.py

@@ -467,9 +467,11 @@ class ConfigurationManager:
         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:

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/models/responses.py

@@ -143,6 +143,42 @@ class APIError(BaseModel):
     )
 
 
+class PermissionToolAllowResponse(BaseModel):
+    """Response model for allowed permission tool requests."""
+
+    behavior: Annotated[Literal["allow"], Field(description="Permission behavior")] = (
+        "allow"
+    )
+    updated_input: Annotated[
+        dict[str, Any],
+        Field(
+            description="Updated input parameters for the tool, or original input if unchanged",
+            alias="updatedInput",
+        ),
+    ]
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+
+class PermissionToolDenyResponse(BaseModel):
+    """Response model for denied permission tool requests."""
+
+    behavior: Annotated[Literal["deny"], Field(description="Permission behavior")] = (
+        "deny"
+    )
+    message: Annotated[
+        str,
+        Field(
+            description="Human-readable explanation of why the permission was denied"
+        ),
+    ]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+PermissionToolResponse = PermissionToolAllowResponse | PermissionToolDenyResponse
+
+
 class RateLimitError(APIError):
     """Rate limit error."""
 

{ccproxy_api-0.1.1 → ccproxy_api-0.1.2}/ccproxy/services/claude_sdk_service.py

@@ -18,6 +18,7 @@ from ccproxy.auth.manager import AuthManager
 from ccproxy.claude_sdk.client import ClaudeSDKClient
 from ccproxy.claude_sdk.converter import MessageConverter
 from ccproxy.claude_sdk.options import OptionsHandler
+from ccproxy.config.settings import Settings
 from ccproxy.core.errors import (
     ClaudeProxyError,
     ServiceUnavailableError,
@@ -44,6 +45,7 @@ class ClaudeSDKService:
         sdk_client: ClaudeSDKClient | None = None,
         auth_manager: AuthManager | None = None,
         metrics: PrometheusMetrics | None = None,
+        settings: Settings | None = None,
     ) -> None:
         """
         Initialize Claude SDK service.
@@ -52,12 +54,14 @@ class ClaudeSDKService:
             sdk_client: Claude SDK client instance
             auth_manager: Authentication manager (optional)
             metrics: Prometheus metrics instance (optional)
+            settings: Application settings (optional)
         """
         self.sdk_client = sdk_client or ClaudeSDKClient()
         self.auth_manager = auth_manager
         self.metrics = metrics
+        self.settings = settings
         self.message_converter = MessageConverter()
-        self.options_handler = OptionsHandler()
+        self.options_handler = OptionsHandler(settings=settings)
 
     async def create_completion(
         self,