commit c335b6029ed14e55265668f4c9bb146a84a9c21d · anil.recoil.org/slop

+19 -20

stack/zulip/examples/atom_feed_bot.ml

···

       309
        
             let usage () = "Atom feed bot - use !feed help for commands"

     

       310
        
             let description () = "Bot for managing and posting Atom/RSS feeds to Zulip"

     

       311
        
       

     

       312
       -
             let handle_message ~config:_ ~storage:_ ~identity:_ ~message ~env:_ =

     

       313
       -
               (* Parse message content *)

     

       314
       -
               let content = match message with

     

       315
       -
                 | `O fields ->

     

       316
       -
                     (match List.assoc_opt "content" fields with

     

       317
       -
                      | Some (`String s) -> s

     

       318
       -
                      | _ -> "")

     

       319
       -
                 | _ -> ""

     

       320
       -
               in

     

       321
        
       

     

       322
       -
               (* Check if message starts with !feed *)

     

       323
       -
               if String.starts_with ~prefix:"!feed" content then

     

       324
       -
                 let parts = String.split_on_char ' ' (String.trim content) in

     

       325
       -
                 match parts with

     

       326
       -
                 | _ :: command :: args ->

     

       327
       -
                     let response = handle_command bot_state command args in

     

       328
       -
                     Ok (Bot_handler.Response.reply response)

     

       329
       -
                 | _ ->

     

       330
       -
                     let response = handle_command bot_state "help" [] in

     

       331
       -
                     Ok (Bot_handler.Response.reply response)

     

       332
        
               else

     

       333
       -
                 Ok Bot_handler.Response.none

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       334
        
           end in

     

       335
        
           (module Handler : Bot_handler.S)

     

       336
        
       end

···

       309
        
             let usage () = "Atom feed bot - use !feed help for commands"

     

       310
        
             let description () = "Bot for managing and posting Atom/RSS feeds to Zulip"

     

       311
        
       

     

       312
       +
             let handle_message ~config:_ ~storage:_ ~identity ~message ~env:_ =

     

       313
       +
               (* Get message content using Message accessor *)

     

       314
       +
               let content = Message.content message in

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       315
        
       

     

       316
       +
               (* Check if this is our own message to avoid loops *)

     

       317
       +
               let bot_email = Bot_handler.Identity.email identity in

     

       318
       +
               if Message.is_from_email message ~email:bot_email then

     

       319
       +
                 Ok Bot_handler.Response.None

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       320
        
               else

     

       321
       +
                 (* Check if message starts with !feed *)

     

       322
       +
                 if String.starts_with ~prefix:"!feed" content then

     

       323
       +
                   let parts = String.split_on_char ' ' (String.trim content) in

     

       324
       +
                   match parts with

     

       325
       +
                   | _ :: command :: args ->

     

       326
       +
                       let response = handle_command bot_state command args in

     

       327
       +
                       Ok (Bot_handler.Response.Reply response)

     

       328
       +
                   | _ ->

     

       329
       +
                       let response = handle_command bot_state "help" [] in

     

       330
       +
                       Ok (Bot_handler.Response.Reply response)

     

       331
       +
                 else

     

       332
       +
                   Ok Bot_handler.Response.None

     

       333
        
           end in

     

       334
        
           (module Handler : Bot_handler.S)

     

       335
        
       end

+1 -1

stack/zulip/examples/dune

···

       8
        
        (public_name echo_bot)

     

       9
        
        (name echo_bot)

     

       10
        
        (package zulip_bot)

     

       11
       -
        (libraries zulip zulip_bot eio_main cmdliner logs logs.fmt))

     

       12
        
       

     

       13
        
       (executable

     

       14
        
        (public_name atom_feed_bot)

···

       8
        
        (public_name echo_bot)

     

       9
        
        (name echo_bot)

     

       10
        
        (package zulip_bot)

     

       11
       +
        (libraries zulip zulip_bot eio_main cmdliner logs logs.fmt mirage-crypto-rng.unix))

     

       12
        
       

     

       13
        
       (executable

     

       14
        
        (public_name atom_feed_bot)

+179 -177

stack/zulip/examples/echo_bot.ml

···

       4
        
       

     

       5
        
       open Zulip_bot

     

       6
        
       

     

       7
       -
       let () =  Mirage_crypto_rng_unix.use_default ()

     

       8
       -
       

     

       9
        
       (* Set up logging *)

     

       10
        
       let src = Logs.Src.create "echo_bot" ~doc:"Zulip Echo Bot"

     

       11
        
       module Log = (val Logs.src_log src : Logs.LOG)

     
···

       26
        
         let handle_message ~config:_ ~storage ~identity ~message ~env:_ =

     

       27
        
           Log.debug (fun m -> m "Received message for processing");

     

       28
        
       

     

       29
       -
           (* Parse the incoming message *)

     

       30
       -
           let extract_field fields name =

     

       31
       -
             match List.assoc_opt name fields with

     

       32
       -
             | Some (`String s) ->

     

       33
       -
                 Log.debug (fun m -> m "Extracted field %s: %s" name s);

     

       34
       -
                 Some s

     

       35
       -
             | _ ->

     

       36
       -
                 Log.debug (fun m -> m "Field %s not found or not a string" name);

     

       37
       -
                 None

     

       38
       -
           in

     

       39
       -
       

     

       40
       -
           let extract_int_field fields name =

     

       41
       -
             match List.assoc_opt name fields with

     

       42
       -
             | Some (`Float f) ->

     

       43
       -
                 let i = int_of_float f in

     

       44
       -
                 Log.debug (fun m -> m "Extracted field %s: %d" name i);

     

       45
       -
                 Some i

     

       46
       -
             | _ ->

     

       47
       -
                 Log.debug (fun m -> m "Field %s not found or not a number" name);

     

       48
       -
                 None

     

       49
       -
           in

     

       50
       -
       

     

       51
        
           match message with

     

       52
       -
           | `O fields ->

     

       53
       -
               Log.info (fun m -> m "Processing message with %d fields" (List.length fields));

     

       54
       -
       

     

       55
       -
               (* Extract message details *)

     

       56
       -
               let content = extract_field fields "content" in

     

       57
       -
               let sender_email = extract_field fields "sender_email" in

     

       58
       -
               let sender_full_name = extract_field fields "sender_full_name" in

     

       59
       -
               let message_type = extract_field fields "type" in

     

       60
       -
               let sender_id = extract_int_field fields "sender_id" in

     

       61
       -
               let message_id = extract_int_field fields "id" in

     

       62
       -
       

     

       63
       -
               (* Log message metadata *)

     

       64
       -
               Log.info (fun m ->

     

       65
       -
                 m "Message metadata: type=%s, sender=%s (%s), id=%s"

     

       66
       -
                   (Option.value message_type ~default:"unknown")

     

       67
       -
                   (Option.value sender_full_name ~default:"unknown")

     

       68
       -
                   (Option.value sender_email ~default:"unknown")

     

       69
       -
                   (Option.fold ~none:"none" ~some:string_of_int message_id));

     

       70
        
       

     

       71
        
               (* Check if this is our own message to avoid loops *)

     

       72
        
               let bot_email = Bot_handler.Identity.email identity in

     

       73
       -
               let is_own_message = match sender_email with

     

       74
       -
                 | Some email ->

     

       75
       -
                     let is_own = email = bot_email in

     

       76
       -
                     if is_own then

     

       77
       -
                       Log.debug (fun m -> m "Ignoring own message from %s" email);

     

       78
       -
                     is_own

     

       79
       -
                 | None -> false

     

       80
       -
               in

     

       81
       -
       

     

       82
       -
               if is_own_message then (

     

       83
       -
                 Log.debug (fun m -> m "Skipping response to own message");

     

       84
        
                 Ok Bot_handler.Response.None

     

       85
        
               ) else

     

       86
        
                 (* Process the message content *)

     

       87
       -
                 let response_content = match content, sender_full_name, sender_id with

     

       88
       -
                   | Some msg, Some name, Some id ->

     

       89
       -
                       Log.info (fun m -> m "Processing message from %s (ID: %d): %s" name id msg);

     

       90
        
       

     

       91
       -
                       (* Remove bot mention if present *)

     

       92
       -
                       let mention = "@**" ^ Bot_handler.Identity.mention_name identity ^ "**" in

     

       93
       -
                       let cleaned_msg =

     

       94
       -
                         if String.starts_with ~prefix:mention msg then (

     

       95
       -
                           let cleaned = String.sub msg

     

       96
       -
                             (String.length mention)

     

       97
       -
                             (String.length msg - String.length mention) in

     

       98
       -
                           Log.debug (fun m -> m "Removed bot mention, cleaned message: %s" cleaned);

     

       99
       -
                           String.trim cleaned

     

       100
       -
                         ) else (

     

       101
       -
                           Log.debug (fun m -> m "No bot mention to remove");

     

       102
       -
                           String.trim msg

     

       103
       -
                         )

     

       104
       -
                       in

     

       105
        
       

     

       106
       -
                       (* Create echo response *)

     

       107
       -
                       let response =

     

       108
       -
                         let lower_msg = String.lowercase_ascii cleaned_msg in

     

       109
       -
                         if cleaned_msg = "" then

     

       110
       -
                           Printf.sprintf "Hello %s! Send me a message and I'll echo it back!" name

     

       111
       -
                         else if lower_msg = "help" then

     

       112
       -
                           Printf.sprintf "Hi %s! I'm an echo bot with storage. Commands:\n\

     

       113
       -
                                           • `help` - Show this help\n\

     

       114
       -
                                           • `ping` - Test if I'm alive\n\

     

       115
       -
                                           • `store <key> <value>` - Store a value\n\

     

       116
       -
                                           • `get <key>` - Retrieve a value\n\

     

       117
       -
                                           • `delete <key>` - Delete a stored value\n\

     

       118
       -
                                           • `list` - List all stored keys\n\

     

       119
       -
                                           • Any other message - I'll echo it back!" name

     

       120
       -
                         else if lower_msg = "ping" then (

     

       121
       -
                           Log.info (fun m -> m "Responding to ping from %s" name);

     

       122
       -
                           Printf.sprintf "Pong! 🏓 (from %s)" name

     

       123
       -
                         )

     

       124
       -
                         else if String.starts_with ~prefix:"store " lower_msg then (

     

       125
       -
                           (* Parse store command: store <key> <value> *)

     

       126
       -
                           let parts = String.sub cleaned_msg 6 (String.length cleaned_msg - 6) |> String.trim in

     

       127
       -
                           match String.index_opt parts ' ' with

     

       128
       -
                           | Some idx ->

     

       129
       -
                               let key = String.sub parts 0 idx |> String.trim in

     

       130
       -
                               let value = String.sub parts (idx + 1) (String.length parts - idx - 1) |> String.trim in

     

       131
       -
                               (match Bot_storage.put storage ~key ~value with

     

       132
       -
                                | Ok () ->

     

       133
       -
                                    Log.info (fun m -> m "Stored key=%s value=%s for user %s" key value name);

     

       134
       -
                                    Printf.sprintf "✅ Stored: `%s` = `%s`" key value

     

       135
       -
                                | Error e ->

     

       136
       -
                                    Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.Error.message e));

     

       137
       -
                                    Printf.sprintf "❌ Failed to store: %s" (Zulip.Error.message e))

     

       138
       -
                           | None ->

     

       139
       -
                               "Usage: `store <key> <value>` - Example: `store name John`"

     

       140
       -
                         )

     

       141
       -
                         else if String.starts_with ~prefix:"get " lower_msg then (

     

       142
       -
                           (* Parse get command: get <key> *)

     

       143
       -
                           let key = String.sub cleaned_msg 4 (String.length cleaned_msg - 4) |> String.trim in

     

       144
       -
                           match Bot_storage.get storage ~key with

     

       145
       -
                           | Some value ->

     

       146
       -
                               Log.info (fun m -> m "Retrieved key=%s value=%s for user %s" key value name);

     

       147
       -
                               Printf.sprintf "📦 `%s` = `%s`" key value

     

       148
       -
                           | None ->

     

       149
       -
                               Log.info (fun m -> m "Key not found: %s" key);

     

       150
       -
                               Printf.sprintf "❓ Key not found: `%s`" key

     

       151
       -
                         )

     

       152
       -
                         else if String.starts_with ~prefix:"delete " lower_msg then (

     

       153
       -
                           (* Parse delete command: delete <key> *)

     

       154
       -
                           let key = String.sub cleaned_msg 7 (String.length cleaned_msg - 7) |> String.trim in

     

       155
       -
                           match Bot_storage.remove storage ~key with

     

       156
       -
                           | Ok () ->

     

       157
       -
                               Log.info (fun m -> m "Deleted key=%s for user %s" key name);

     

       158
       -
                               Printf.sprintf "🗑️ Deleted key: `%s`" key

     

       159
       -
                           | Error e ->

     

       160
       -
                               Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.Error.message e));

     

       161
       -
                               Printf.sprintf "❌ Failed to delete: %s" (Zulip.Error.message e)

     

       162
       -
                         )

     

       163
       -
                         else if lower_msg = "list" then (

     

       164
       -
                           (* List all stored keys *)

     

       165
       -
                           match Bot_storage.keys storage with

     

       166
       -
                           | Ok keys when keys = [] ->

     

       167
       -
                               "📭 No keys stored yet. Use `store <key> <value>` to add data!"

     

       168
       -
                           | Ok keys ->

     

       169
       -
                               let key_list = String.concat "\n" (List.map (fun k -> "• `" ^ k ^ "`") keys) in

     

       170
       -
                               Printf.sprintf "📋 Stored keys:\n%s\n\nUse `get <key>` to retrieve values." key_list

     

       171
       -
                           | Error e ->

     

       172
       -
                               Printf.sprintf "❌ Failed to list keys: %s" (Zulip.Error.message e)

     

       173
       -
                         )

     

       174
       -
                         else

     

       175
       -
                           Printf.sprintf "Echo from %s: %s" name cleaned_msg

     

       176
       -
                       in

     

       177
        
       

     

       178
       -
                       Log.debug (fun m -> m "Generated response: %s" response);

     

       179
       -
                       response

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180
        
       

     

       181
       -
                   | Some msg, None, _ ->

     

       182
       -
                       Log.warn (fun m -> m "Message without sender name: %s" msg);

     

       183
       -
                       Printf.sprintf "Echo: %s" msg

     

       184
        
       

     

       185
       -
                   | None, _, _ ->

     

       186
       -
                       Log.warn (fun m -> m "Received message without content");

     

       187
       -
                       "I couldn't understand that message."

     

       188
        
       

     

       189
       -
                   | _ ->

     

       190
       -
                       Log.warn (fun m -> m "Incomplete message data");

     

       191
       -
                       "I couldn't process that message properly."

     

       192
       -
                 in

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       193
        
       

     

       194
       -
                 (* Determine response type based on original message type *)

     

       195
       -
                 let response = match message_type with

     

       196
       -
                   | Some "private" ->

     

       197
       -
                       Log.info (fun m -> m "Sending private reply: %s" response_content);

     

       198
       -
                       Bot_handler.Response.Reply response_content

     

       199
       -
                   | Some "stream" ->

     

       200
       -
                       Log.info (fun m -> m "Sending stream reply: %s" response_content);

     

       201
       -
                       Bot_handler.Response.Reply response_content

     

       202
       -
                   | Some other ->

     

       203
       -
                       Log.warn (fun m -> m "Unknown message type: %s" other);

     

       204
       -
                       Bot_handler.Response.None

     

       205
       -
                   | None ->

     

       206
       -
                       Log.warn (fun m -> m "No message type specified");

     

       207
       -
                       Bot_handler.Response.None

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       208
        
                 in

     

       209
        
       

     

       210
       -
                 Ok response

     

       0
        
       
     

       0
        
       
     

       211
        
       

     

       212
       -
           | other ->

     

       213
       -
               Log.err (fun m -> m "Received non-object message: %s"

     

       214
       -
                 (match other with

     

       215
       -
                  | `A _ -> "array"

     

       216
       -
                  | `Bool _ -> "bool"

     

       217
       -
                  | `Float _ -> "float"

     

       218
       -
                  | `String _ -> "string"

     

       219
       -
                  | `Null -> "null"

     

       220
       -
                  | _ -> "unknown"));

     

       221
        
               Ok Bot_handler.Response.None

     

       222
        
       end

     

       223
        
       

     
···

       362
        
         Cmd.v info Term.(const (run_echo_bot) $ config_file $ verbosity_term $ const env)

     

       363
        
       

     

       364
        
       let () =

     

       0
        
       
     

       0
        
       
     

       365
        
         Eio_main.run @@ fun env ->

     

       366
        
         exit (Cmd.eval (bot_cmd env))

···

       4
        
       

     

       5
        
       open Zulip_bot

     

       6
        
       

     

       0
        
       
     

       0
        
       
     

       7
        
       (* Set up logging *)

     

       8
        
       let src = Logs.Src.create "echo_bot" ~doc:"Zulip Echo Bot"

     

       9
        
       module Log = (val Logs.src_log src : Logs.LOG)

     
···

       24
        
         let handle_message ~config:_ ~storage ~identity ~message ~env:_ =

     

       25
        
           Log.debug (fun m -> m "Received message for processing");

     

       26
        
       

     

       27
       +
           (* Use the new Message type for cleaner handling *)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       28
        
           match message with

     

       29
       +
           | Message.Private { common; display_recipient = _ } ->

     

       30
       +
               Log.info (fun m -> m "Processing private message from %s (ID: %d)"

     

       31
       +
                 common.sender_email common.id);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       

     

       33
        
               (* Check if this is our own message to avoid loops *)

     

       34
        
               let bot_email = Bot_handler.Identity.email identity in

     

       35
       +
               if common.sender_email = bot_email then (

     

       36
       +
                 Log.debug (fun m -> m "Ignoring own message");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
                 Ok Bot_handler.Response.None

     

       38
        
               ) else

     

       39
        
                 (* Process the message content *)

     

       40
       +
                 let sender_name = common.sender_full_name in

     

       41
       +
                 let sender_id = common.sender_id in

     

       42
       +
                 let msg = common.content in

     

       43
        
       

     

       44
       +
                 Log.info (fun m -> m "Processing message from %s (ID: %d): %s" sender_name sender_id msg);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
       

     

       46
       +
                 (* Remove bot mention using Message utility *)

     

       47
       +
                 let bot_email = Bot_handler.Identity.email identity in

     

       48
       +
                 let cleaned_msg = Message.strip_mention message ~user_email:bot_email in

     

       49
       +
                 Log.debug (fun m -> m "Cleaned message: %s" cleaned_msg);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       50
        
       

     

       51
       +
                 (* Create echo response *)

     

       52
       +
                 let response_content =

     

       53
       +
                   let lower_msg = String.lowercase_ascii cleaned_msg in

     

       54
       +
                   if cleaned_msg = "" then

     

       55
       +
                     Printf.sprintf "Hello %s! Send me a message and I'll echo it back!" sender_name

     

       56
       +
                   else if lower_msg = "help" then

     

       57
       +
                     Printf.sprintf "Hi %s! I'm an echo bot with storage. Commands:\n\

     

       58
       +
                                     • `help` - Show this help\n\

     

       59
       +
                                     • `ping` - Test if I'm alive\n\

     

       60
       +
                                     • `store <key> <value>` - Store a value\n\

     

       61
       +
                                     • `get <key>` - Retrieve a value\n\

     

       62
       +
                                     • `delete <key>` - Delete a stored value\n\

     

       63
       +
                                     • `list` - List all stored keys\n\

     

       64
       +
                                     • Any other message - I'll echo it back!" sender_name

     

       65
       +
                   else if lower_msg = "ping" then (

     

       66
       +
                     Log.info (fun m -> m "Responding to ping from %s" sender_name);

     

       67
       +
                     Printf.sprintf "Pong! 🏓 (from %s)" sender_name

     

       68
       +
                   )

     

       69
       +
                   else if String.starts_with ~prefix:"store " lower_msg then (

     

       70
       +
                     (* Parse store command: store <key> <value> *)

     

       71
       +
                     let parts = String.sub cleaned_msg 6 (String.length cleaned_msg - 6) |> String.trim in

     

       72
       +
                     match String.index_opt parts ' ' with

     

       73
       +
                     | Some idx ->

     

       74
       +
                         let key = String.sub parts 0 idx |> String.trim in

     

       75
       +
                         let value = String.sub parts (idx + 1) (String.length parts - idx - 1) |> String.trim in

     

       76
       +
                         (match Bot_storage.put storage ~key ~value with

     

       77
       +
                          | Ok () ->

     

       78
       +
                              Log.info (fun m -> m "Stored key=%s value=%s for user %s" key value sender_name);

     

       79
       +
                              Printf.sprintf "✅ Stored: `%s` = `%s`" key value

     

       80
       +
                          | Error e ->

     

       81
       +
                              Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.Error.message e));

     

       82
       +
                              Printf.sprintf "❌ Failed to store: %s" (Zulip.Error.message e))

     

       83
       +
                     | None ->

     

       84
       +
                         "Usage: `store <key> <value>` - Example: `store name John`"

     

       85
       +
                   )

     

       86
       +
                   else if String.starts_with ~prefix:"get " lower_msg then (

     

       87
       +
                     (* Parse get command: get <key> *)

     

       88
       +
                     let key = String.sub cleaned_msg 4 (String.length cleaned_msg - 4) |> String.trim in

     

       89
       +
                     match Bot_storage.get storage ~key with

     

       90
       +
                     | Some value ->

     

       91
       +
                         Log.info (fun m -> m "Retrieved key=%s value=%s for user %s" key value sender_name);

     

       92
       +
                         Printf.sprintf "📦 `%s` = `%s`" key value

     

       93
       +
                     | None ->

     

       94
       +
                         Log.info (fun m -> m "Key not found: %s" key);

     

       95
       +
                         Printf.sprintf "❓ Key not found: `%s`" key

     

       96
       +
                   )

     

       97
       +
                   else if String.starts_with ~prefix:"delete " lower_msg then (

     

       98
       +
                     (* Parse delete command: delete <key> *)

     

       99
       +
                     let key = String.sub cleaned_msg 7 (String.length cleaned_msg - 7) |> String.trim in

     

       100
       +
                     match Bot_storage.remove storage ~key with

     

       101
       +
                     | Ok () ->

     

       102
       +
                         Log.info (fun m -> m "Deleted key=%s for user %s" key sender_name);

     

       103
       +
                         Printf.sprintf "🗑️ Deleted key: `%s`" key

     

       104
       +
                     | Error e ->

     

       105
       +
                         Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.Error.message e));

     

       106
       +
                         Printf.sprintf "❌ Failed to delete: %s" (Zulip.Error.message e)

     

       107
       +
                   )

     

       108
       +
                   else if lower_msg = "list" then (

     

       109
       +
                     (* List all stored keys *)

     

       110
       +
                     match Bot_storage.keys storage with

     

       111
       +
                     | Ok keys when keys = [] ->

     

       112
       +
                         "📭 No keys stored yet. Use `store <key> <value>` to add data!"

     

       113
       +
                     | Ok keys ->

     

       114
       +
                         let key_list = String.concat "\n" (List.map (fun k -> "• `" ^ k ^ "`") keys) in

     

       115
       +
                         Printf.sprintf "📋 Stored keys:\n%s\n\nUse `get <key>` to retrieve values." key_list

     

       116
       +
                     | Error e ->

     

       117
       +
                         Printf.sprintf "❌ Failed to list keys: %s" (Zulip.Error.message e)

     

       118
       +
                   )

     

       119
       +
                   else

     

       120
       +
                     Printf.sprintf "Echo from %s: %s" sender_name cleaned_msg

     

       121
       +
                 in

     

       122
        
       

     

       123
       +
                 Log.debug (fun m -> m "Generated response: %s" response_content);

     

       124
       +
                 Log.info (fun m -> m "Sending private reply");

     

       125
       +
                 Ok (Bot_handler.Response.Reply response_content)

     

       126
        
       

     

       127
       +
           | Message.Stream { common; display_recipient; subject; _ } ->

     

       128
       +
               Log.info (fun m -> m "Processing stream message from %s in %s/%s"

     

       129
       +
                 common.sender_email display_recipient subject);

     

       130
        
       

     

       131
       +
               (* Check if this is our own message to avoid loops *)

     

       132
       +
               let bot_email = Bot_handler.Identity.email identity in

     

       133
       +
               if common.sender_email = bot_email then (

     

       134
       +
                 Log.debug (fun m -> m "Ignoring own message");

     

       135
       +
                 Ok Bot_handler.Response.None

     

       136
       +
               ) else

     

       137
       +
                 (* Process the message content *)

     

       138
       +
                 let sender_name = common.sender_full_name in

     

       139
        
       

     

       140
       +
                 (* Remove bot mention using Message utility *)

     

       141
       +
                 let cleaned_msg = Message.strip_mention message ~user_email:bot_email in

     

       142
       +
       

     

       143
       +
                 (* Create echo response *)

     

       144
       +
                 let response_content =

     

       145
       +
                   let lower_msg = String.lowercase_ascii cleaned_msg in

     

       146
       +
                   if cleaned_msg = "" then

     

       147
       +
                     Printf.sprintf "Hello %s! Send me a message and I'll echo it back!" sender_name

     

       148
       +
                   else if lower_msg = "help" then

     

       149
       +
                     Printf.sprintf "Hi %s! I'm an echo bot with storage. Commands:\n\

     

       150
       +
                                     • `help` - Show this help\n\

     

       151
       +
                                     • `ping` - Test if I'm alive\n\

     

       152
       +
                                     • `store <key> <value>` - Store a value\n\

     

       153
       +
                                     • `get <key>` - Retrieve a value\n\

     

       154
       +
                                     • `delete <key>` - Delete a stored value\n\

     

       155
       +
                                     • `list` - List all stored keys\n\

     

       156
       +
                                     • Any other message - I'll echo it back!" sender_name

     

       157
       +
                   else if lower_msg = "ping" then (

     

       158
       +
                     Log.info (fun m -> m "Responding to ping from %s" sender_name);

     

       159
       +
                     Printf.sprintf "Pong! 🏓 (from %s)" sender_name

     

       160
       +
                   )

     

       161
       +
                   else if String.starts_with ~prefix:"store " lower_msg then (

     

       162
       +
                     (* Parse store command: store <key> <value> *)

     

       163
       +
                     let parts = String.sub cleaned_msg 6 (String.length cleaned_msg - 6) |> String.trim in

     

       164
       +
                     match String.index_opt parts ' ' with

     

       165
       +
                     | Some idx ->

     

       166
       +
                         let key = String.sub parts 0 idx |> String.trim in

     

       167
       +
                         let value = String.sub parts (idx + 1) (String.length parts - idx - 1) |> String.trim in

     

       168
       +
                         (match Bot_storage.put storage ~key ~value with

     

       169
       +
                          | Ok () ->

     

       170
       +
                              Log.info (fun m -> m "Stored key=%s value=%s for user %s" key value sender_name);

     

       171
       +
                              Printf.sprintf "✅ Stored: `%s` = `%s`" key value

     

       172
       +
                          | Error e ->

     

       173
       +
                              Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.Error.message e));

     

       174
       +
                              Printf.sprintf "❌ Failed to store: %s" (Zulip.Error.message e))

     

       175
       +
                     | None ->

     

       176
       +
                         "Usage: `store <key> <value>` - Example: `store name John`"

     

       177
       +
                   )

     

       178
       +
                   else if String.starts_with ~prefix:"get " lower_msg then (

     

       179
       +
                     (* Parse get command: get <key> *)

     

       180
       +
                     let key = String.sub cleaned_msg 4 (String.length cleaned_msg - 4) |> String.trim in

     

       181
       +
                     match Bot_storage.get storage ~key with

     

       182
       +
                     | Some value ->

     

       183
       +
                         Log.info (fun m -> m "Retrieved key=%s value=%s for user %s" key value sender_name);

     

       184
       +
                         Printf.sprintf "📦 `%s` = `%s`" key value

     

       185
       +
                     | None ->

     

       186
       +
                         Log.info (fun m -> m "Key not found: %s" key);

     

       187
       +
                         Printf.sprintf "❓ Key not found: `%s`" key

     

       188
       +
                   )

     

       189
       +
                   else if String.starts_with ~prefix:"delete " lower_msg then (

     

       190
       +
                     (* Parse delete command: delete <key> *)

     

       191
       +
                     let key = String.sub cleaned_msg 7 (String.length cleaned_msg - 7) |> String.trim in

     

       192
       +
                     match Bot_storage.remove storage ~key with

     

       193
       +
                     | Ok () ->

     

       194
       +
                         Log.info (fun m -> m "Deleted key=%s for user %s" key sender_name);

     

       195
       +
                         Printf.sprintf "🗑️ Deleted key: `%s`" key

     

       196
       +
                     | Error e ->

     

       197
       +
                         Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.Error.message e));

     

       198
       +
                         Printf.sprintf "❌ Failed to delete: %s" (Zulip.Error.message e)

     

       199
       +
                   )

     

       200
       +
                   else if lower_msg = "list" then (

     

       201
       +
                     (* List all stored keys *)

     

       202
       +
                     match Bot_storage.keys storage with

     

       203
       +
                     | Ok keys when keys = [] ->

     

       204
       +
                         "📭 No keys stored yet. Use `store <key> <value>` to add data!"

     

       205
       +
                     | Ok keys ->

     

       206
       +
                         let key_list = String.concat "\n" (List.map (fun k -> "• `" ^ k ^ "`") keys) in

     

       207
       +
                         Printf.sprintf "📋 Stored keys:\n%s\n\nUse `get <key>` to retrieve values." key_list

     

       208
       +
                     | Error e ->

     

       209
       +
                         Printf.sprintf "❌ Failed to list keys: %s" (Zulip.Error.message e)

     

       210
       +
                   )

     

       211
       +
                   else

     

       212
       +
                     Printf.sprintf "Echo from %s: %s" sender_name cleaned_msg

     

       213
        
                 in

     

       214
        
       

     

       215
       +
                 Log.debug (fun m -> m "Generated response: %s" response_content);

     

       216
       +
                 Log.info (fun m -> m "Sending stream reply");

     

       217
       +
                 Ok (Bot_handler.Response.Reply response_content)

     

       218
        
       

     

       219
       +
           | Message.Unknown _ ->

     

       220
       +
               Log.err (fun m -> m "Received unknown message format");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       221
        
               Ok Bot_handler.Response.None

     

       222
        
       end

     

       223
        
       

     
···

       362
        
         Cmd.v info Term.(const (run_echo_bot) $ config_file $ verbosity_term $ const env)

     

       363
        
       

     

       364
        
       let () =

     

       365
       +
         (* Initialize the cryptographic RNG for the application *)

     

       366
       +
         Mirage_crypto_rng_unix.use_default ();

     

       367
        
         Eio_main.run @@ fun env ->

     

       368
        
         exit (Cmd.eval (bot_cmd env))

+123

stack/zulip/examples/test_realtime_bot.ml

···

       1
       +
       (* Test script to verify real-time bot event processing *)

     

       2
       +
       

     

       3
       +
       open Zulip_bot

     

       4
       +
       

     

       5
       +
       (* Logging setup *)

     

       6
       +
       let src = Logs.Src.create "test_realtime_bot" ~doc:"Test real-time bot"

     

       7
       +
       module Log = (val Logs.src_log src : Logs.LOG)

     

       8
       +
       

     

       9
       +
       (* Simple test bot that logs everything *)

     

       10
       +
       module Test_bot_handler : Bot_handler.S = struct

     

       11
       +
         let initialize _config =

     

       12
       +
           Log.info (fun m -> m "Bot initialized");

     

       13
       +
           Ok ()

     

       14
       +
       

     

       15
       +
         let usage () = "Test Bot - Verifies real-time event processing"

     

       16
       +
       

     

       17
       +
         let description () = "A test bot that logs all messages received"

     

       18
       +
       

     

       19
       +
         let handle_message ~config:_ ~storage ~identity:_ ~message ~env:_ =

     

       20
       +
           Log.info (fun m -> m "Received message");

     

       21
       +
       

     

       22
       +
           (* Extract and log message details *)

     

       23
       +
           let content = Bot_handler.Message_context.content message in

     

       24
       +
           let sender = Bot_handler.Message_context.sender_email message in

     

       25
       +
           let is_direct = Bot_handler.Message_context.is_direct message in

     

       26
       +
       

     

       27
       +
           Log.info (fun m -> m "Content: %s"

     

       28
       +
             (Option.value content ~default:"<none>"));

     

       29
       +
           Log.info (fun m -> m "Sender: %s"

     

       30
       +
             (Option.value sender ~default:"<unknown>"));

     

       31
       +
           Log.info (fun m -> m "Direct: %b" is_direct);

     

       32
       +
       

     

       33
       +
           (* Test storage *)

     

       34
       +
           let test_key = "last_message" in

     

       35
       +
           let test_value = Option.value content ~default:"" in

     

       36
       +
       

     

       37
       +
           (match Bot_storage.put storage ~key:test_key ~value:test_value with

     

       38
       +
            | Ok () -> Log.info (fun m -> m "Stored message in bot storage")

     

       39
       +
            | Error e -> Log.err (fun m -> m "Storage error: %s" (Zulip.Error.message e)));

     

       40
       +
       

     

       41
       +
           (* Always reply with confirmation *)

     

       42
       +
           let reply = Printf.sprintf "Test bot received: %s"

     

       43
       +
             (Option.value content ~default:"<empty>") in

     

       44
       +
           Ok (Bot_handler.Response.Reply reply)

     

       45
       +
       end

     

       46
       +
       

     

       47
       +
       let run_test verbosity env =

     

       48
       +
         (* Setup logging *)

     

       49
       +
         Logs.set_reporter (Logs_fmt.reporter ());

     

       50
       +
         Logs.set_level (Some (match verbosity with

     

       51
       +
           | 0 -> Logs.Info

     

       52
       +
           | 1 -> Logs.Debug

     

       53
       +
           | _ -> Logs.Debug));

     

       54
       +
       

     

       55
       +
         Log.info (fun m -> m "Real-time Bot Test");

     

       56
       +
         Log.info (fun m -> m "==================");

     

       57
       +
       

     

       58
       +
         (* Load auth *)

     

       59
       +
         let auth = match Zulip.Auth.from_zuliprc () with

     

       60
       +
           | Ok a ->

     

       61
       +
               Log.info (fun m -> m "Loaded auth for: %s" (Zulip.Auth.email a));

     

       62
       +
               Log.info (fun m -> m "Server: %s" (Zulip.Auth.server_url a));

     

       63
       +
               a

     

       64
       +
           | Error e ->

     

       65
       +
               Log.err (fun m -> m "Failed to load .zuliprc: %s" (Zulip.Error.message e));

     

       66
       +
               exit 1

     

       67
       +
         in

     

       68
       +
       

     

       69
       +
         Eio.Switch.run @@ fun sw ->

     

       70
       +
         let client = Zulip.Client.create ~sw env auth in

     

       71
       +
       

     

       72
       +
         (* Create bot components *)

     

       73
       +
         let config = Bot_config.create [] in

     

       74
       +
         let bot_email = Zulip.Auth.email auth in

     

       75
       +
         let storage = Bot_storage.create client ~bot_email in

     

       76
       +
         let identity = Bot_handler.Identity.create

     

       77
       +
           ~full_name:"Test Bot"

     

       78
       +
           ~email:bot_email

     

       79
       +
           ~mention_name:"testbot"

     

       80
       +
         in

     

       81
       +
       

     

       82
       +
         (* Create handler and runner *)

     

       83
       +
         let handler = Bot_handler.create

     

       84
       +
           (module Test_bot_handler)

     

       85
       +
           ~config ~storage ~identity

     

       86
       +
         in

     

       87
       +
         let runner = Bot_runner.create ~env ~client ~handler in

     

       88
       +
       

     

       89
       +
         Log.info (fun m -> m "Starting bot in real-time mode...");

     

       90
       +
         Log.info (fun m -> m "The bot will:");

     

       91
       +
         Log.info (fun m -> m "- Register for message events");

     

       92
       +
         Log.info (fun m -> m "- Poll for new messages");

     

       93
       +
         Log.info (fun m -> m "- Process and reply to messages");

     

       94
       +
         Log.info (fun m -> m "- Store messages in Zulip bot storage");

     

       95
       +
         Log.info (fun m -> m "Press Ctrl+C to stop.");

     

       96
       +
       

     

       97
       +
         (* Run the bot *)

     

       98
       +
         Bot_runner.run_realtime runner

     

       99
       +
       

     

       100
       +
       (* Command-line interface *)

     

       101
       +
       open Cmdliner

     

       102
       +
       

     

       103
       +
       let verbosity =

     

       104
       +
         let doc = "Increase verbosity (can be used multiple times)" in

     

       105
       +
         let verbosity_flags = Arg.(value & flag_all & info ["v"; "verbose"] ~doc) in

     

       106
       +
         Term.(const List.length $ verbosity_flags)

     

       107
       +
       

     

       108
       +
       let main_cmd =

     

       109
       +
         let doc = "Test real-time bot for Zulip" in

     

       110
       +
         let man = [

     

       111
       +
           `S Manpage.s_description;

     

       112
       +
           `P "This bot tests real-time event processing with the Zulip API. \

     

       113
       +
               It will echo received messages and store them in bot storage.";

     

       114
       +
           `P "The bot requires a configured ~/.zuliprc file with API credentials.";

     

       115
       +
         ] in

     

       116
       +
         let info = Cmd.info "test_realtime_bot" ~version:"1.0.0" ~doc ~man in

     

       117
       +
         let run verbosity =

     

       118
       +
           Eio_main.run (run_test verbosity)

     

       119
       +
         in

     

       120
       +
         let term = Term.(const run $ verbosity) in

     

       121
       +
         Cmd.v info term

     

       122
       +
       

     

       123
       +
       let () = exit (Cmd.eval main_cmd)

+2 -31

stack/zulip/lib/zulip_bot/lib/bot_handler.ml

···

       24
        
         let mention_name t = t.mention_name

     

       25
        
       end

     

       26
        
       

     

       27
       -
       module Message_context = struct

     

       28
       -
         type t = Zulip.Error.json

     

       29
       -
       

     

       30
       -
         let of_json json = json

     

       31
       -
         let create json = json  (* Add create as alias for of_json *)

     

       32
       -
       

     

       33
       -
         let sender_email t =

     

       34
       -
           match t with

     

       35
       -
           | `O fields ->

     

       36
       -
               (match List.assoc_opt "sender_email" fields with

     

       37
       -
                | Some (`String s) -> Some s

     

       38
       -
                | _ -> None)

     

       39
       -
           | _ -> None

     

       40
       -
       

     

       41
       -
         let content t =

     

       42
       -
           match t with

     

       43
       -
           | `O fields ->

     

       44
       -
               (match List.assoc_opt "content" fields with

     

       45
       -
                | Some (`String s) -> Some s

     

       46
       -
                | _ -> None)

     

       47
       -
           | _ -> None

     

       48
       -
       

     

       49
       -
         let is_direct t =

     

       50
       -
           match t with

     

       51
       -
           | `O fields ->

     

       52
       -
               (match List.assoc_opt "type" fields with

     

       53
       -
                | Some (`String "direct") -> true

     

       54
       -
                | _ -> false)

     

       55
       -
           | _ -> false

     

       56
       -
       end

     

       57
        
       

     

       58
        
       (** Module signature for bot implementations *)

     

       59
        
       module type Bot_handler = sig

     
···

       64
        
           config:Bot_config.t ->

     

       65
        
           storage:Bot_storage.t ->

     

       66
        
           identity:Identity.t ->

     

       67
       -
           message:Message_context.t ->

     

       68
        
           env:_ ->

     

       69
        
           (Response.t, Zulip.Error.t) result

     

       70
        
       end

     
···

       90
        
           ~identity:t.identity

     

       91
        
           ~message

     

       92
        
           ~env

     

       0
        
       
     

       93
        
       

     

       94
        
       let identity t = t.identity

     

       95
        
       let usage t =

···

       24
        
         let mention_name t = t.mention_name

     

       25
        
       end

     

       26
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
        
       (** Module signature for bot implementations *)

     

       29
        
       module type Bot_handler = sig

     
···

       34
        
           config:Bot_config.t ->

     

       35
        
           storage:Bot_storage.t ->

     

       36
        
           identity:Identity.t ->

     

       37
       +
           message:Message.t ->

     

       38
        
           env:_ ->

     

       39
        
           (Response.t, Zulip.Error.t) result

     

       40
        
       end

     
···

       60
        
           ~identity:t.identity

     

       61
        
           ~message

     

       62
        
           ~env

     

       63
       +
       

     

       64
        
       

     

       65
        
       let identity t = t.identity

     

       66
        
       let usage t =

+3 -12

stack/zulip/lib/zulip_bot/lib/bot_handler.mli

···

       24
        
         val mention_name : t -> string

     

       25
        
       end

     

       26
        
       

     

       27
       -
       (** Message context passed to bot handlers *)

     

       28
       -
       module Message_context : sig

     

       29
       -
         type t = Zulip.Error.json

     

       30
       -
       

     

       31
       -
         val of_json : Zulip.Error.json -> t

     

       32
       -
         val create : Zulip.Error.json -> t  (* Alias for of_json *)

     

       33
       -
         val sender_email : t -> string option

     

       34
       -
         val content : t -> string option

     

       35
       -
         val is_direct : t -> bool

     

       36
       -
       end

     

       37
        
       

     

       38
        
       (** Module signature for bot implementations *)

     

       39
        
       module type Bot_handler = sig

     
···

       51
        
           config:Bot_config.t ->

     

       52
        
           storage:Bot_storage.t ->

     

       53
        
           identity:Identity.t ->

     

       54
       -
           message:Message_context.t ->

     

       55
        
           env:_ ->

     

       56
        
           (Response.t, Zulip.Error.t) result

     

       57
        
       end

     
···

       71
        
         t

     

       72
        
       

     

       73
        
       (** Process an incoming message with EIO environment *)

     

       74
       -
       val handle_message_with_env : t -> _ -> Message_context.t -> (Response.t, Zulip.Error.t) result

     

       0
        
       
     

       75
        
       

     

       76
        
       (** Get bot identity *)

     

       77
        
       val identity : t -> Identity.t

···

       24
        
         val mention_name : t -> string

     

       25
        
       end

     

       26
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
        
       (** Module signature for bot implementations *)

     

       29
        
       module type Bot_handler = sig

     
···

       41
        
           config:Bot_config.t ->

     

       42
        
           storage:Bot_storage.t ->

     

       43
        
           identity:Identity.t ->

     

       44
       +
           message:Message.t ->

     

       45
        
           env:_ ->

     

       46
        
           (Response.t, Zulip.Error.t) result

     

       47
        
       end

     
···

       61
        
         t

     

       62
        
       

     

       63
        
       (** Process an incoming message with EIO environment *)

     

       64
       +
       val handle_message_with_env : t -> _ -> Message.t -> (Response.t, Zulip.Error.t) result

     

       65
       +
       

     

       66
        
       

     

       67
        
       (** Get bot identity *)

     

       68
        
       val identity : t -> Identity.t

+86 -77

stack/zulip/lib/zulip_bot/lib/bot_runner.ml

···

       2
        
       let src = Logs.Src.create "zulip_bot.runner" ~doc:"Zulip bot runner"

     

       3
        
       module Log = (val Logs.src_log src : Logs.LOG)

     

       4
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       type 'env t = {

     

       6
        
         client : Zulip.Client.t;

     

       7
        
         handler : Bot_handler.t;

     
···

       33
        
             let event_data = Zulip.Event.data event in

     

       34
        
       

     

       35
        
             (* Extract the actual message from the event *)

     

       36
       -
             let message, flags =

     

       37
        
               match event_data with

     

       38
        
               | `O fields ->

     

       39
        
                   let msg = match List.assoc_opt "message" fields with

     
···

       48
        
               | _ -> (event_data, [])

     

       49
        
             in

     

       50
        
       

     

       51
       -
             (* Check if mentioned *)

     

       52
       -
             let is_mentioned = List.exists (function `String "mentioned" -> true | _ -> false) flags in

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53
        
       

     

       54
       -
             (* Check if it's a private message *)

     

       55
       -
             let is_private =

     

       56
       -
               match message with

     

       57
       -
               | `O fields ->

     

       58
       -
                   (match List.assoc_opt "type" fields with

     

       59
       -
                    | Some (`String "private") -> true

     

       60
       -
                    | _ -> false)

     

       61
       -
               | _ -> false

     

       62
       -
             in

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
       

     

       64
       -
             (* Log what we found *)

     

       65
       -
             Log.info (fun m -> m "Message check: mentioned=%b, private=%b" is_mentioned is_private);

     

       0
        
       
     

       66
        
       

     

       67
       -
             (* Only process if bot was mentioned or it's a private message *)

     

       68
       -
             if is_mentioned || is_private then (

     

       69
       -
               Log.info (fun m -> m "Bot should respond to this message");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       70
        
       

     

       71
       -
               (* Create message context and handle *)

     

       72
       -
               let context = Bot_handler.Message_context.create message in

     

       73
       -
               match Bot_handler.handle_message_with_env t.handler t.env context with

     

       74
       -
               | Ok (Bot_handler.Response.Reply content) ->

     

       75
       -
                   Log.debug (fun m -> m "Bot is sending reply: %s" content);

     

       76
       -
                   (* Send reply back *)

     

       77
       -
                   let message_to_send =

     

       78
       -
                     match message with

     

       79
       -
                     | `O fields ->

     

       80
       -
                         let message_type =

     

       81
       -
                           match List.assoc_opt "type" fields with

     

       82
       -
                           | Some (`String "private") -> `Direct

     

       83
       -
                           | _ -> `Channel

     

       84
       -
                         in

     

       85
       -
                         let to_ =

     

       86
       -
                           match message_type with

     

       87
       -
                           | `Direct ->

     

       88
       -
                               (* For private messages, reply to the sender *)

     

       89
       -
                               (match List.assoc_opt "sender_email" fields with

     

       90
       -
                                | Some (`String email) ->

     

       91
       -
                                    Log.debug (fun m -> m "Replying to sender: %s" email);

     

       92
       -
                                    [email]

     

       93
       -
                                | _ ->

     

       94
       -
                                    Log.warn (fun m -> m "Could not find sender_email");

     

       95
       -
                                    [])

     

       96
       -
                           | `Channel ->

     

       97
       -
                               (* Reply to channel *)

     

       98
       -
                               (match List.assoc_opt "display_recipient" fields with

     

       99
       -
                                | Some (`String channel) -> [channel]

     

       100
       -
                                | _ -> [])

     

       101
       -
                         in

     

       102
       -
                         let topic =

     

       103
       -
                           match List.assoc_opt "subject" fields with

     

       104
       -
                           | Some (`String topic) -> Some topic

     

       105
       -
                           | _ -> None

     

       106
       -
                         in

     

       107
       -
                         Zulip.Message.create ~type_:message_type ~to_ ~content ?topic ()

     

       108
       -
                     | _ ->

     

       109
       -
                         (* Fallback: can't determine where to reply *)

     

       110
       -
                         Log.warn (fun m -> m "Could not determine message structure for reply");

     

       111
       -
                         Zulip.Message.create ~type_:`Direct ~to_:[] ~content ()

     

       112
       -
                   in

     

       113
        
       

     

       114
       -
                   (match Zulip.Messages.send t.client message_to_send with

     

       115
       -
                    | Ok resp ->

     

       116
       -
                        Log.info (fun m -> m "Reply sent successfully (id: %d)"

     

       117
       -
                          (Zulip.Message_response.id resp))

     

       118
        
                    | Error e ->

     

       119
       -
                        Log.err (fun m -> m "Error sending reply: %s" (Zulip.Error.message e)))

     

       120
       -
       

     

       121
       -
               | Ok (Bot_handler.Response.None) ->

     

       122
       -
                   Log.info (fun m -> m "Bot handler returned no response")

     

       123
       -
               | Ok _ ->

     

       124
       -
                   Log.info (fun m -> m "Bot handler returned unhandled response type")

     

       125
       -
               | Error e ->

     

       126
       -
                   Log.err (fun m -> m "Error handling message: %s" (Zulip.Error.message e))

     

       127
       -
             ) else (

     

       128
       -
               Log.info (fun m -> m "Not processing message (not mentioned and not private)")

     

       129
       -
             )

     

       130
        
         | _ -> () (* Ignore non-message events for now *)

     

       131
        
       

     

       132
        
       let run_realtime t =

     
···

       214
        
       

     

       215
        
       let handle_webhook t ~webhook_data =

     

       216
        
         (* Process webhook data and route to handler *)

     

       217
       -
         match Bot_handler.handle_message_with_env t.handler t.env webhook_data with

     

       218
       -
         | Ok response -> Ok (Some response)

     

       219
       -
         | Error e -> Error e

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       220
        
       

     

       221
        
       let shutdown t =

     

       222
        
         t.running <- false;

···

       2
        
       let src = Logs.Src.create "zulip_bot.runner" ~doc:"Zulip bot runner"

     

       3
        
       module Log = (val Logs.src_log src : Logs.LOG)

     

       4
        
       

     

       5
       +
       (* Initialize crypto RNG - now done at module load time via Mirage_crypto_rng_unix *)

     

       6
       +
       let () =

     

       7
       +
         try

     

       8
       +
           let _ = Mirage_crypto_rng.generate ~g:(Mirage_crypto_rng.default_generator ()) 0 in

     

       9
       +
           ()

     

       10
       +
         with _ ->

     

       11
       +
           (* Generator not initialized - this will be done by applications using the library *)

     

       12
       +
           ()

     

       13
       +
       

     

       14
       +
       (* Convert Zulip.Error.json to Yojson.Safe.t *)

     

       15
       +
       let rec convert_json : Zulip.Error.json -> Yojson.Safe.t = function

     

       16
       +
         | `Null -> `Null

     

       17
       +
         | `Bool b -> `Bool b

     

       18
       +
         | `Float f -> `Float f

     

       19
       +
         | `String s -> `String s

     

       20
       +
         | `A lst -> `List (List.map convert_json lst)

     

       21
       +
         | `O pairs -> `Assoc (List.map (fun (k, v) -> (k, convert_json v)) pairs)

     

       22
       +
       

     

       23
        
       type 'env t = {

     

       24
        
         client : Zulip.Client.t;

     

       25
        
         handler : Bot_handler.t;

     
···

       51
        
             let event_data = Zulip.Event.data event in

     

       52
        
       

     

       53
        
             (* Extract the actual message from the event *)

     

       54
       +
             let message_json, flags =

     

       55
        
               match event_data with

     

       56
        
               | `O fields ->

     

       57
        
                   let msg = match List.assoc_opt "message" fields with

     
···

       66
        
               | _ -> (event_data, [])

     

       67
        
             in

     

       68
        
       

     

       69
       +
             (* Parse the message JSON into Message.t *)

     

       70
       +
             (match Message.of_json (convert_json message_json) with

     

       71
       +
              | Error err ->

     

       72
       +
                  Log.err (fun m -> m "Failed to parse message JSON: %s" err);

     

       73
       +
              | Ok message ->

     

       74
       +
                  (* Get bot identity for checking mentions *)

     

       75
       +
                  let bot_email = Bot_handler.Identity.email (Bot_handler.identity t.handler) in

     

       76
        
       

     

       77
       +
                  (* Check if mentioned *)

     

       78
       +
                  let is_mentioned =

     

       79
       +
                    List.exists (function `String "mentioned" -> true | _ -> false) flags ||

     

       80
       +
                    Message.is_mentioned message ~user_email:bot_email in

     

       81
       +
       

     

       82
       +
                  (* Check if it's a private message *)

     

       83
       +
                  let is_private = Message.is_private message in

     

       84
       +
       

     

       85
       +
                  (* Don't respond to our own messages *)

     

       86
       +
                  let is_from_self = Message.is_from_email message ~email:bot_email in

     

       87
       +
       

     

       88
       +
                  (* Log what we found *)

     

       89
       +
                  Log.info (fun m -> m "Message check: mentioned=%b, private=%b, from_self=%b"

     

       90
       +
                    is_mentioned is_private is_from_self);

     

       91
        
       

     

       92
       +
                  (* Only process if bot was mentioned or it's a private message, and not from self *)

     

       93
       +
                  if (is_mentioned || is_private) && not is_from_self then (

     

       94
       +
                    Log.info (fun m -> m "Bot should respond to this message");

     

       95
        
       

     

       96
       +
                    (* Handle the message using the new Message.t type *)

     

       97
       +
                    match Bot_handler.handle_message_with_env t.handler t.env message with

     

       98
       +
                    | Ok (Bot_handler.Response.Reply content) ->

     

       99
       +
                        Log.debug (fun m -> m "Bot is sending reply: %s" content);

     

       100
       +
                        (* Send reply back using Message utilities *)

     

       101
       +
                        let message_to_send =

     

       102
       +
                          if Message.is_private message then

     

       103
       +
                            (* Reply to private message *)

     

       104
       +
                            let sender = Message.sender_email message in

     

       105
       +
                            Log.debug (fun m -> m "Replying to sender: %s" sender);

     

       106
       +
                            Zulip.Message.create ~type_:`Direct ~to_:[sender] ~content ()

     

       107
       +
                          else

     

       108
       +
                            (* Reply to stream message *)

     

       109
       +
                            let reply_to = Message.get_reply_to message in

     

       110
       +
                            let topic =

     

       111
       +
                              match message with

     

       112
       +
                              | Message.Stream { subject; _ } -> Some subject

     

       113
       +
                              | _ -> None

     

       114
       +
                            in

     

       115
       +
                            Zulip.Message.create ~type_:`Channel ~to_:[reply_to] ~content ?topic ()

     

       116
       +
                        in

     

       117
        
       

     

       118
       +
                        (match Zulip.Messages.send t.client message_to_send with

     

       119
       +
                         | Ok resp ->

     

       120
       +
                             Log.info (fun m -> m "Reply sent successfully (id: %d)"

     

       121
       +
                               (Zulip.Message_response.id resp))

     

       122
       +
                         | Error e ->

     

       123
       +
                             Log.err (fun m -> m "Error sending reply: %s" (Zulip.Error.message e)))

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       124
        
       

     

       125
       +
                    | Ok (Bot_handler.Response.None) ->

     

       126
       +
                        Log.info (fun m -> m "Bot handler returned no response")

     

       127
       +
                    | Ok _ ->

     

       128
       +
                        Log.info (fun m -> m "Bot handler returned unhandled response type")

     

       129
        
                    | Error e ->

     

       130
       +
                        Log.err (fun m -> m "Error handling message: %s" (Zulip.Error.message e))

     

       131
       +
                  ) else (

     

       132
       +
                    Log.info (fun m -> m "Not processing message (not mentioned and not private)")

     

       133
       +
                  )

     

       134
       +
              )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       135
        
         | _ -> () (* Ignore non-message events for now *)

     

       136
        
       

     

       137
        
       let run_realtime t =

     
···

       219
        
       

     

       220
        
       let handle_webhook t ~webhook_data =

     

       221
        
         (* Process webhook data and route to handler *)

     

       222
       +
         (* Parse the webhook data into Message.t first *)

     

       223
       +
         match Message.of_json (convert_json webhook_data) with

     

       224
       +
         | Error err -> Error (Zulip.Error.create ~code:(Zulip.Error.Other "parse_error") ~msg:("Failed to parse webhook message: " ^ err) ())

     

       225
       +
         | Ok message ->

     

       226
       +
             match Bot_handler.handle_message_with_env t.handler t.env message with

     

       227
       +
             | Ok response -> Ok (Some response)

     

       228
       +
             | Error e -> Error e

     

       229
        
       

     

       230
        
       let shutdown t =

     

       231
        
         t.running <- false;

+2 -1

stack/zulip/lib/zulip_bot/lib/dune

···

       1
        
       (library

     

       2
        
        (public_name zulip_bot)

     

       3
        
        (name zulip_bot)

     

       4
       -
        (libraries zulip unix eio logs))
     

       0

···

       1
        
       (library

     

       2
        
        (public_name zulip_bot)

     

       3
        
        (name zulip_bot)

     

       4
       +
        (libraries zulip unix eio logs mirage-crypto-rng)

     

       5
       +
        (flags (:standard -warn-error -3)))

+296

stack/zulip/lib/zulip_bot/lib/message.ml

···

       1
       +
       open Yojson.Safe.Util

     

       2
       +
       

     

       3
       +
       let logs_src = Logs.Src.create "zulip_bot.message"

     

       4
       +
       module Log = (val Logs.src_log logs_src : Logs.LOG)

     

       5
       +
       

     

       6
       +
       (** User representation *)

     

       7
       +
       module User = struct

     

       8
       +
         type t = {

     

       9
       +
           user_id: int;

     

       10
       +
           email: string;

     

       11
       +
           full_name: string;

     

       12
       +
           short_name: string option;

     

       13
       +
         }

     

       14
       +
       

     

       15
       +
         let user_id t = t.user_id

     

       16
       +
         let email t = t.email

     

       17
       +
         let full_name t = t.full_name

     

       18
       +
         let short_name t = t.short_name

     

       19
       +
       

     

       20
       +
         let of_json json =

     

       21
       +
           try

     

       22
       +
             let user_id = json |> member "user_id" |> to_int in

     

       23
       +
             let email = json |> member "email" |> to_string in

     

       24
       +
             let full_name = json |> member "full_name" |> to_string in

     

       25
       +
             let short_name = json |> member "short_name" |> to_string_option in

     

       26
       +
             Ok { user_id; email; full_name; short_name }

     

       27
       +
           with

     

       28
       +
           | Type_error (msg, _) -> Error ("User JSON parse error: " ^ msg)

     

       29
       +
           | exn -> Error ("User JSON parse error: " ^ Printexc.to_string exn)

     

       30
       +
       end

     

       31
       +
       

     

       32
       +
       (** Reaction representation *)

     

       33
       +
       module Reaction = struct

     

       34
       +
         type t = {

     

       35
       +
           emoji_name: string;

     

       36
       +
           emoji_code: string;

     

       37
       +
           reaction_type: string;

     

       38
       +
           user_id: int;

     

       39
       +
         }

     

       40
       +
       

     

       41
       +
         let emoji_name t = t.emoji_name

     

       42
       +
         let emoji_code t = t.emoji_code

     

       43
       +
         let reaction_type t = t.reaction_type

     

       44
       +
         let user_id t = t.user_id

     

       45
       +
       

     

       46
       +
         let of_json json =

     

       47
       +
           try

     

       48
       +
             let emoji_name = json |> member "emoji_name" |> to_string in

     

       49
       +
             let emoji_code = json |> member "emoji_code" |> to_string in

     

       50
       +
             let reaction_type = json |> member "reaction_type" |> to_string in

     

       51
       +
             let user_id = json |> member "user" |> member "user_id" |> to_int in

     

       52
       +
             Ok { emoji_name; emoji_code; reaction_type; user_id }

     

       53
       +
           with

     

       54
       +
           | Type_error (msg, _) -> Error ("Reaction JSON parse error: " ^ msg)

     

       55
       +
           | exn -> Error ("Reaction JSON parse error: " ^ Printexc.to_string exn)

     

       56
       +
       end

     

       57
       +
       

     

       58
       +
       (** Common message fields *)

     

       59
       +
       type common = {

     

       60
       +
         id: int;

     

       61
       +
         sender_id: int;

     

       62
       +
         sender_email: string;

     

       63
       +
         sender_full_name: string;

     

       64
       +
         sender_short_name: string option;

     

       65
       +
         timestamp: float;

     

       66
       +
         content: string;

     

       67
       +
         content_type: string;

     

       68
       +
         reactions: Reaction.t list;

     

       69
       +
         submessages: Yojson.Safe.t list;

     

       70
       +
         flags: string list;

     

       71
       +
         is_me_message: bool;

     

       72
       +
         client: string;

     

       73
       +
         gravatar_hash: string;

     

       74
       +
         avatar_url: string option;

     

       75
       +
       }

     

       76
       +
       

     

       77
       +
       (** Message types *)

     

       78
       +
       type t =

     

       79
       +
         | Private of {

     

       80
       +
             common: common;

     

       81
       +
             display_recipient: User.t list;

     

       82
       +
           }

     

       83
       +
         | Stream of {

     

       84
       +
             common: common;

     

       85
       +
             display_recipient: string;

     

       86
       +
             stream_id: int;

     

       87
       +
             subject: string;

     

       88
       +
           }

     

       89
       +
         | Unknown of {

     

       90
       +
             common: common;

     

       91
       +
             raw_json: Yojson.Safe.t;

     

       92
       +
           }

     

       93
       +
       

     

       94
       +
       (** Helper function to parse common fields *)

     

       95
       +
       let parse_common json =

     

       96
       +
         try

     

       97
       +
           let id = json |> member "id" |> to_int in

     

       98
       +
           let sender_id = json |> member "sender_id" |> to_int in

     

       99
       +
           let sender_email = json |> member "sender_email" |> to_string in

     

       100
       +
           let sender_full_name = json |> member "sender_full_name" |> to_string in

     

       101
       +
           let sender_short_name = json |> member "sender_short_name" |> to_string_option in

     

       102
       +
           let timestamp = json |> member "timestamp" |> to_float in

     

       103
       +
           let content = json |> member "content" |> to_string in

     

       104
       +
           let content_type = json |> member "content_type" |> to_string_option |> Option.value ~default:"text/html" in

     

       105
       +
       

     

       106
       +
           let reactions =

     

       107
       +
             try

     

       108
       +
               json |> member "reactions" |> to_list |> List.map (fun r ->

     

       109
       +
                 match Reaction.of_json r with

     

       110
       +
                 | Ok reaction -> reaction

     

       111
       +
                 | Error err ->

     

       112
       +
                   Log.warn (fun m -> m "Failed to parse reaction: %s" err);

     

       113
       +
                   failwith "reaction parse error"

     

       114
       +
               )

     

       115
       +
             with

     

       116
       +
             | Type_error _ -> []

     

       117
       +
             | _ -> []

     

       118
       +
           in

     

       119
       +
       

     

       120
       +
           let submessages =

     

       121
       +
             try json |> member "submessages" |> to_list

     

       122
       +
             with Type_error _ -> []

     

       123
       +
           in

     

       124
       +
       

     

       125
       +
           let flags =

     

       126
       +
             try json |> member "flags" |> to_list |> List.map to_string

     

       127
       +
             with Type_error _ -> []

     

       128
       +
           in

     

       129
       +
       

     

       130
       +
           let is_me_message =

     

       131
       +
             try json |> member "is_me_message" |> to_bool

     

       132
       +
             with Type_error _ -> false

     

       133
       +
           in

     

       134
       +
       

     

       135
       +
           let client =

     

       136
       +
             try json |> member "client" |> to_string

     

       137
       +
             with Type_error _ -> ""

     

       138
       +
           in

     

       139
       +
       

     

       140
       +
           let gravatar_hash =

     

       141
       +
             try json |> member "gravatar_hash" |> to_string

     

       142
       +
             with Type_error _ -> ""

     

       143
       +
           in

     

       144
       +
       

     

       145
       +
           let avatar_url = json |> member "avatar_url" |> to_string_option in

     

       146
       +
       

     

       147
       +
           Ok {

     

       148
       +
             id; sender_id; sender_email; sender_full_name; sender_short_name;

     

       149
       +
             timestamp; content; content_type; reactions; submessages; flags;

     

       150
       +
             is_me_message; client; gravatar_hash; avatar_url;

     

       151
       +
           }

     

       152
       +
         with

     

       153
       +
         | Type_error (msg, _) -> Error ("Common fields parse error: " ^ msg)

     

       154
       +
         | exn -> Error ("Common fields parse error: " ^ Printexc.to_string exn)

     

       155
       +
       

     

       156
       +
       (** JSON parsing *)

     

       157
       +
       let of_json json =

     

       158
       +
         Log.debug (fun m -> m "Parsing message JSON: %s" (Yojson.Safe.pretty_to_string json));

     

       159
       +
       

     

       160
       +
         match parse_common json with

     

       161
       +
         | Error err -> Error err

     

       162
       +
         | Ok common ->

     

       163
       +
           try

     

       164
       +
             let msg_type = json |> member "type" |> to_string in

     

       165
       +
             match msg_type with

     

       166
       +
             | "private" ->

     

       167
       +
               let display_recipient_json = json |> member "display_recipient" |> to_list in

     

       168
       +
               let users = List.map (fun user_json ->

     

       169
       +
                 match User.of_json user_json with

     

       170
       +
                 | Ok user -> user

     

       171
       +
                 | Error err ->

     

       172
       +
                   Log.warn (fun m -> m "Failed to parse user in display_recipient: %s" err);

     

       173
       +
                   failwith "user parse error"

     

       174
       +
               ) display_recipient_json in

     

       175
       +
               Ok (Private { common; display_recipient = users })

     

       176
       +
       

     

       177
       +
             | "stream" ->

     

       178
       +
               let display_recipient = json |> member "display_recipient" |> to_string in

     

       179
       +
               let stream_id = json |> member "stream_id" |> to_int in

     

       180
       +
               let subject = json |> member "subject" |> to_string in

     

       181
       +
               Ok (Stream { common; display_recipient; stream_id; subject })

     

       182
       +
       

     

       183
       +
             | unknown_type ->

     

       184
       +
               Log.warn (fun m -> m "Unknown message type: %s" unknown_type);

     

       185
       +
               Ok (Unknown { common; raw_json = json })

     

       186
       +
       

     

       187
       +
           with

     

       188
       +
           | Type_error (msg, _) -> Error ("Message type parse error: " ^ msg)

     

       189
       +
           | exn -> Error ("Message type parse error: " ^ Printexc.to_string exn)

     

       190
       +
       

     

       191
       +
       (** Accessor functions *)

     

       192
       +
       let get_common = function

     

       193
       +
         | Private { common; _ } -> common

     

       194
       +
         | Stream { common; _ } -> common

     

       195
       +
         | Unknown { common; _ } -> common

     

       196
       +
       

     

       197
       +
       let id msg = (get_common msg).id

     

       198
       +
       let sender_id msg = (get_common msg).sender_id

     

       199
       +
       let sender_email msg = (get_common msg).sender_email

     

       200
       +
       let sender_full_name msg = (get_common msg).sender_full_name

     

       201
       +
       let sender_short_name msg = (get_common msg).sender_short_name

     

       202
       +
       let timestamp msg = (get_common msg).timestamp

     

       203
       +
       let content msg = (get_common msg).content

     

       204
       +
       let content_type msg = (get_common msg).content_type

     

       205
       +
       let reactions msg = (get_common msg).reactions

     

       206
       +
       let submessages msg = (get_common msg).submessages

     

       207
       +
       let flags msg = (get_common msg).flags

     

       208
       +
       let is_me_message msg = (get_common msg).is_me_message

     

       209
       +
       let client msg = (get_common msg).client

     

       210
       +
       let gravatar_hash msg = (get_common msg).gravatar_hash

     

       211
       +
       let avatar_url msg = (get_common msg).avatar_url

     

       212
       +
       

     

       213
       +
       (** Helper functions *)

     

       214
       +
       let is_private = function

     

       215
       +
         | Private _ -> true

     

       216
       +
         | _ -> false

     

       217
       +
       

     

       218
       +
       let is_stream = function

     

       219
       +
         | Stream _ -> true

     

       220
       +
         | _ -> false

     

       221
       +
       

     

       222
       +
       let is_from_self msg ~bot_user_id =

     

       223
       +
         sender_id msg = bot_user_id

     

       224
       +
       

     

       225
       +
       let is_from_email msg ~email =

     

       226
       +
         sender_email msg = email

     

       227
       +
       

     

       228
       +
       let get_reply_to = function

     

       229
       +
         | Private { display_recipient; _ } ->

     

       230
       +
           display_recipient

     

       231
       +
           |> List.map User.email

     

       232
       +
           |> String.concat ","

     

       233
       +
         | Stream { display_recipient; _ } -> display_recipient

     

       234
       +
         | Unknown _ -> ""

     

       235
       +
       

     

       236
       +
       (** Utility functions *)

     

       237
       +
       let is_mentioned msg ~user_email =

     

       238
       +
         let content_text = content msg in

     

       239
       +
         let mention_pattern = "@**" ^ user_email ^ "**" in

     

       240
       +
         String.length mention_pattern > 0 &&

     

       241
       +
         let rec search_from pos =

     

       242
       +
           if pos > String.length content_text - String.length mention_pattern then

     

       243
       +
             false

     

       244
       +
           else if String.sub content_text pos (String.length mention_pattern) = mention_pattern then

     

       245
       +
             true

     

       246
       +
           else

     

       247
       +
             search_from (pos + 1)

     

       248
       +
         in

     

       249
       +
         search_from 0

     

       250
       +
       

     

       251
       +
       let strip_mention msg ~user_email =

     

       252
       +
         let content_text = content msg in

     

       253
       +
         let mention_pattern = "@**" ^ user_email ^ "**" in

     

       254
       +
         let re = Re.Perl.compile_pat mention_pattern in

     

       255
       +
         Re.replace_string re ~by:"" content_text |> String.trim

     

       256
       +
       

     

       257
       +
       let extract_command msg =

     

       258
       +
         let content_text = String.trim (content msg) in

     

       259
       +
         if String.length content_text > 0 && content_text.[0] = '!' then

     

       260
       +
           Some (String.sub content_text 1 (String.length content_text - 1))

     

       261
       +
         else

     

       262
       +
           None

     

       263
       +
       

     

       264
       +
       let parse_command msg =

     

       265
       +
         match extract_command msg with

     

       266
       +
         | None -> None

     

       267
       +
         | Some cmd_text ->

     

       268
       +
           let parts = String.split_on_char ' ' cmd_text |> List.filter (fun s -> s <> "") in

     

       269
       +
           match parts with

     

       270
       +
           | [] -> None

     

       271
       +
           | cmd :: args -> Some (cmd, args)

     

       272
       +
       

     

       273
       +
       (** Pretty printing *)

     

       274
       +
       let pp_user fmt user =

     

       275
       +
         Format.fprintf fmt "{ user_id=%d; email=%s; full_name=%s }"

     

       276
       +
           (User.user_id user) (User.email user) (User.full_name user)

     

       277
       +
       

     

       278
       +
       let _pp_reaction fmt reaction =

     

       279
       +
         Format.fprintf fmt "{ emoji_name=%s; user_id=%d }"

     

       280
       +
           (Reaction.emoji_name reaction) (Reaction.user_id reaction)

     

       281
       +
       

     

       282
       +
       let pp fmt = function

     

       283
       +
         | Private { common; display_recipient } ->

     

       284
       +
           Format.fprintf fmt "Private { id=%d; sender=%s; recipients=[%a]; content=%S }"

     

       285
       +
             common.id common.sender_email

     

       286
       +
             (Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ") pp_user)

     

       287
       +
             display_recipient

     

       288
       +
             common.content

     

       289
       +
       

     

       290
       +
         | Stream { common; display_recipient; subject; _ } ->

     

       291
       +
           Format.fprintf fmt "Stream { id=%d; sender=%s; stream=%s; subject=%s; content=%S }"

     

       292
       +
             common.id common.sender_email display_recipient subject common.content

     

       293
       +
       

     

       294
       +
         | Unknown { common; _ } ->

     

       295
       +
           Format.fprintf fmt "Unknown { id=%d; sender=%s; content=%S }"

     

       296
       +
             common.id common.sender_email common.content

+103

stack/zulip/lib/zulip_bot/lib/message.mli

···

       1
       +
       (** Zulip message types and utilities *)

     

       2
       +
       

     

       3
       +
       (** User representation *)

     

       4
       +
       module User : sig

     

       5
       +
         type t = {

     

       6
       +
           user_id: int;

     

       7
       +
           email: string;

     

       8
       +
           full_name: string;

     

       9
       +
           short_name: string option;

     

       10
       +
         }

     

       11
       +
       

     

       12
       +
         val user_id : t -> int

     

       13
       +
         val email : t -> string

     

       14
       +
         val full_name : t -> string

     

       15
       +
         val short_name : t -> string option

     

       16
       +
       end

     

       17
       +
       

     

       18
       +
       (** Reaction representation *)

     

       19
       +
       module Reaction : sig

     

       20
       +
         type t = {

     

       21
       +
           emoji_name: string;

     

       22
       +
           emoji_code: string;

     

       23
       +
           reaction_type: string;

     

       24
       +
           user_id: int;

     

       25
       +
         }

     

       26
       +
       

     

       27
       +
         val emoji_name : t -> string

     

       28
       +
         val emoji_code : t -> string

     

       29
       +
         val reaction_type : t -> string

     

       30
       +
         val user_id : t -> int

     

       31
       +
       end

     

       32
       +
       

     

       33
       +
       (** Common message fields *)

     

       34
       +
       type common = {

     

       35
       +
         id: int;

     

       36
       +
         sender_id: int;

     

       37
       +
         sender_email: string;

     

       38
       +
         sender_full_name: string;

     

       39
       +
         sender_short_name: string option;

     

       40
       +
         timestamp: float;

     

       41
       +
         content: string;

     

       42
       +
         content_type: string;

     

       43
       +
         reactions: Reaction.t list;

     

       44
       +
         submessages: Yojson.Safe.t list;

     

       45
       +
         flags: string list;

     

       46
       +
         is_me_message: bool;

     

       47
       +
         client: string;

     

       48
       +
         gravatar_hash: string;

     

       49
       +
         avatar_url: string option;

     

       50
       +
       }

     

       51
       +
       

     

       52
       +
       (** Message types *)

     

       53
       +
       type t =

     

       54
       +
         | Private of {

     

       55
       +
             common: common;

     

       56
       +
             display_recipient: User.t list;

     

       57
       +
           }

     

       58
       +
         | Stream of {

     

       59
       +
             common: common;

     

       60
       +
             display_recipient: string;

     

       61
       +
             stream_id: int;

     

       62
       +
             subject: string;

     

       63
       +
           }

     

       64
       +
         | Unknown of {

     

       65
       +
             common: common;

     

       66
       +
             raw_json: Yojson.Safe.t;

     

       67
       +
           }

     

       68
       +
       

     

       69
       +
       (** Accessor functions *)

     

       70
       +
       val id : t -> int

     

       71
       +
       val sender_id : t -> int

     

       72
       +
       val sender_email : t -> string

     

       73
       +
       val sender_full_name : t -> string

     

       74
       +
       val sender_short_name : t -> string option

     

       75
       +
       val timestamp : t -> float

     

       76
       +
       val content : t -> string

     

       77
       +
       val content_type : t -> string

     

       78
       +
       val reactions : t -> Reaction.t list

     

       79
       +
       val submessages : t -> Yojson.Safe.t list

     

       80
       +
       val flags : t -> string list

     

       81
       +
       val is_me_message : t -> bool

     

       82
       +
       val client : t -> string

     

       83
       +
       val gravatar_hash : t -> string

     

       84
       +
       val avatar_url : t -> string option

     

       85
       +
       

     

       86
       +
       (** Helper functions *)

     

       87
       +
       val is_private : t -> bool

     

       88
       +
       val is_stream : t -> bool

     

       89
       +
       val is_from_self : t -> bot_user_id:int -> bool

     

       90
       +
       val is_from_email : t -> email:string -> bool

     

       91
       +
       val get_reply_to : t -> string

     

       92
       +
       

     

       93
       +
       (** Utility functions *)

     

       94
       +
       val is_mentioned : t -> user_email:string -> bool

     

       95
       +
       val strip_mention : t -> user_email:string -> string

     

       96
       +
       val extract_command : t -> string option

     

       97
       +
       val parse_command : t -> (string * string list) option

     

       98
       +
       

     

       99
       +
       (** JSON parsing *)

     

       100
       +
       val of_json : Yojson.Safe.t -> (t, string) result

     

       101
       +
       

     

       102
       +
       (** Pretty printing *)

     

       103
       +
       val pp : Format.formatter -> t -> unit