commit 57d23d2da0c25567c1714aee1bdbbcf48bbca9c3 · anil.recoil.org/slop

+39 -10

claudeio/lib/client.ml

···

       17
       17
        
         | "can_use_tool" ->

     

       18
       18
        
             let tool_name = Json_utils.find_string data ["request"; "tool_name"] in

     

       19
       19
        
             let input = find data ["request"; "input"] in

     

       20
       20
       -
             Log.info (fun m -> m "Permission request for tool '%s' with input: %s" 

     

       20
       20
       +
             Log.info (fun m -> m "Permission request for tool '%s' with input: %s"

     

       21
       21
        
               tool_name (value_to_string input));

     

       22
       22
       -
             let suggestions = 

     

       22
       22
       +
             let suggestions =

     

       23
       23
        
               try

     

       24
       24
        
                 let sugg_json = find data ["request"; "permission_suggestions"] in

     

       25
       25
        
                 match sugg_json with

     

       26
       26
       -
                 | `A _ -> 

     

       26
       26
       +
                 | `A _ ->

     

       27
       27
        
                     (* TODO: Parse permission suggestions *)

     

       28
       28
        
                     []

     

       29
       29
        
                 | _ -> []

     

       30
       30
        
               with Not_found -> []

     

       31
       31
        
             in

     

       32
       32
        
             let context = Permissions.Context.create ~suggestions () in

     

       33
       33
       -
             

     

       33
       33
       +
       

     

       34
       34
        
             Log.info (fun m -> m "Invoking permission callback for tool: %s" tool_name);

     

       35
       35
        
             let result = match t.permission_callback with

     

       36
       36
       -
               | Some callback -> 

     

       36
       36
       +
               | Some callback ->

     

       37
       37
        
                   Log.info (fun m -> m "Using custom permission callback");

     

       38
       38
        
                   callback ~tool_name ~input ~context

     

       39
       39
       -
               | None -> 

     

       39
       39
       +
               | None ->

     

       40
       40
        
                   Log.info (fun m -> m "Using default allow callback");

     

       41
       41
        
                   Permissions.default_allow_callback ~tool_name ~input ~context

     

       42
       42
        
             in

     

       43
       43
       -
             Log.info (fun m -> m "Permission callback returned: %s" 

     

       44
       44
       -
               (match result with 

     

       43
       43
       +
             Log.info (fun m -> m "Permission callback returned: %s"

     

       44
       44
       +
               (match result with

     

       45
       45
        
                | Permissions.Result.Allow _ -> "ALLOW"

     

       46
       46
        
                | Permissions.Result.Deny _ -> "DENY"));

     

       47
       47
       -
             

     

       47
       47
       +
       

     

       48
       48
       +
             (* Convert permission result to CLI format: {"behavior": "allow", "updatedInput": ...} or {"behavior": "deny", "message": ...} *)

     

       49
       49
       +
             let response_data = match result with

     

       50
       50
       +
               | Permissions.Result.Allow { updated_input; updated_permissions = _ } ->

     

       51
       51
       +
                   (* updatedInput is required when allowing - use original input if not modified *)

     

       52
       52
       +
                   let updated_input = match updated_input with

     

       53
       53
       +
                     | Some inp -> inp

     

       54
       54
       +
                     | None -> input  (* Use original input *)

     

       55
       55
       +
                   in

     

       56
       56
       +
                   dict [

     

       57
       57
       +
                     ("behavior", string "allow");

     

       58
       58
       +
                     ("updatedInput", updated_input);

     

       59
       59
       +
                   ]

     

       60
       60
       +
               | Permissions.Result.Deny { message; interrupt = _ } ->

     

       61
       61
       +
                   dict [

     

       62
       62
       +
                     ("behavior", string "deny");

     

       63
       63
       +
                     ("message", string message);

     

       64
       64
       +
                   ]

     

       65
       65
       +
             in

     

       66
       66
       +
       

     

       48
       67
        
             let response = dict [

     

       49
       68
        
               "type", string "control_response";

     

       50
       69
        
               "response", dict [

     

       51
       70
        
                 "subtype", string "success";

     

       52
       71
        
                 "request_id", string (Control.request_id control_msg);

     

       53
       53
       -
                 "response", Permissions.Result.to_json result

     

       72
       72
       +
                 "response", response_data

     

       54
       73
        
               ]

     

       55
       74
        
             ] in

     

       75
       75
       +
             Log.info (fun m -> m "Sending control response: %s" (value_to_string response));

     

       56
       76
        
             Transport.send t.transport response

     

       57
       77
        
         

     

       58
       78
        
         | subtype ->

     
···

       116
       136
        
         loop

     

       117
       137
        
       

     

       118
       138
        
       let create ?(options = Options.default) ~sw ~process_mgr () =

     

       139
       139
       +
         (* Automatically enable permission prompt tool when callback is configured

     

       140
       140
       +
            (matching Python SDK behavior in client.py:104-121) *)

     

       141
       141
       +
         let options =

     

       142
       142
       +
           match Options.permission_callback options with

     

       143
       143
       +
           | Some _ when Options.permission_prompt_tool_name options = None ->

     

       144
       144
       +
               (* Set permission_prompt_tool_name to "stdio" to enable control protocol *)

     

       145
       145
       +
               Options.with_permission_prompt_tool_name "stdio" options

     

       146
       146
       +
           | _ -> options

     

       147
       147
       +
         in

     

       119
       148
        
         let transport = Transport.create ~sw ~process_mgr ~options () in

     

       120
       149
        
         {

     

       121
       150
        
           transport;

+7 -2

claudeio/lib/transport.ml

···

       46
       46
        
         in

     

       47
       47
        
         

     

       48
       48
        
         let cmd = match Options.permission_mode options with

     

       49
       49
       -
           | Some mode -> 

     

       49
       49
       +
           | Some mode ->

     

       50
       50
        
               let mode_str = Permissions.Mode.to_string mode in

     

       51
       51
        
               cmd @ ["--permission-mode"; mode_str]

     

       52
       52
        
           | None -> cmd

     

       53
       53
        
         in

     

       54
       54
       -
         

     

       54
       54
       +
       

     

       55
       55
       +
         let cmd = match Options.permission_prompt_tool_name options with

     

       56
       56
       +
           | Some tool_name -> cmd @ ["--permission-prompt-tool"; tool_name]

     

       57
       57
       +
           | None -> cmd

     

       58
       58
       +
         in

     

       59
       59
       +
       

     

       55
       60
        
         (* Use streaming input mode *)

     

       56
       61
        
         cmd @ ["--input-format"; "stream-json"]

     

       57
       62

+12

claudeio/test/dune

···

       20
       20
        
        (public_name simulated_permissions)

     

       21
       21
        
        (name simulated_permissions)

     

       22
       22
        
        (modules simulated_permissions)

     

       23
       23
       +
        (libraries claude eio_main cmdliner logs logs.fmt fmt.tty fmt.cli logs.cli))

     

       24
       24
       +
       

     

       25
       25
       +
       (executable

     

       26
       26
       +
        (public_name test_permissions)

     

       27
       27
       +
        (name test_permissions)

     

       28
       28
       +
        (modules test_permissions)

     

       29
       29
       +
        (libraries claude eio_main cmdliner logs logs.fmt fmt.tty fmt.cli logs.cli))

     

       30
       30
       +
       

     

       31
       31
       +
       (executable

     

       32
       32
       +
        (public_name simple_permission_test)

     

       33
       33
       +
        (name simple_permission_test)

     

       34
       34
       +
        (modules simple_permission_test)

     

       23
       35
        
        (libraries claude eio_main cmdliner logs logs.fmt fmt.tty fmt.cli logs.cli))

+5 -2

claudeio/test/permission_demo.ml

···

       73
       73
        
           Log.info (fun m -> m "Returning allow result for %s" tool_name);

     

       74
       74
        
           Claude.Permissions.Result.allow ()

     

       75
       75
        
         end else begin

     

       76
       76
       -
           (* Ask user *)

     

       76
       76
       +
           (* Ask user - read from /dev/tty since stdin is connected to Claude process *)

     

       77
       77
        
           Printf.printf "Allow? [y/N/always]: %!";

     

       78
       78
       -
           match read_line () |> String.lowercase_ascii with

     

       78
       78
       +
           let tty = open_in "/dev/tty" in

     

       79
       79
       +
           let response = input_line tty |> String.lowercase_ascii in

     

       80
       80
       +
           close_in tty;

     

       81
       81
       +
           match response with

     

       79
       82
        
           | "y" | "yes" ->

     

       80
       83
        
               Log.app (fun m -> m "→ Allowed (this time only)");

     

       81
       84
        
               Log.info (fun m -> m "User approved %s for this request only" tool_name);