commit e37e07bc68aa947d61c79ca956e8b555cdb3e6b6 · anil.recoil.org/slop

stack/zulip/.gitignore

+689

stack/zulip/CLAUDE.md

···

       1
       1
       +
       I would like to build high quality OCaml bindings to the Zulip REST API,

     

       2
       2
       +
       documented at https://zulip.com/api/rest.  As another reference, the Python

     

       3
       3
       +
       `zulip` library from pip is well maintained.

     

       4
       4
       +
       

     

       5
       5
       +
       My target is to use the OCaml EIO direct-style library, with an idiomatic as

     

       6
       6
       +
       possible API that implements it. For JSON parsing, using the jsonm library is

     

       7
       7
       +
       right. For HTTPS, use cohttp-eio with the tls-eio library. You have access to

     

       8
       8
       +
       an OCaml LSP via MCP which provides type hints and other language server

     

       9
       9
       +
       features after you complete a `dune build`.

     

       10
       10
       +
       

     

       11
       11
       +
       # OCaml Zulip Library Design

     

       12
       12
       +
       

     

       13
       13
       +
       Based on analysis of:

     

       14
       14
       +
       - Zulip REST API documentation: https://zulip.com/api/rest

     

       15
       15
       +
       - Python zulip library: https://github.com/zulip/python-zulip-api

     

       16
       16
       +
       - Zulip error handling: https://zulip.com/api/rest-error-handling

     

       17
       17
       +
       - Zulip send message API: https://zulip.com/api/send-message

     

       18
       18
       +
       

     

       19
       19
       +
       ## Overview

     

       20
       20
       +
       The library follows OCaml best practices with abstract types (`type t`) per module, comprehensive constructors/accessors, and proper pretty printers. Each core concept gets its own module with a clean interface.

     

       21
       21
       +
       

     

       22
       22
       +
       ## Module Structure

     

       23
       23
       +
       

     

       24
       24
       +
       ### Authentication (`Zulip.Auth`)

     

       25
       25
       +
       ```ocaml

     

       26
       26
       +
       type t (* abstract *)

     

       27
       27
       +
       

     

       28
       28
       +
       val create : server_url:string -> email:string -> api_key:string -> t

     

       29
       29
       +
       val from_zuliprc : ?path:string -> unit -> (t, Error.t) result

     

       30
       30
       +
       val server_url : t -> string

     

       31
       31
       +
       val email : t -> string

     

       32
       32
       +
       val to_basic_auth_header : t -> string

     

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

     

       34
       34
       +
       ```

     

       35
       35
       +
       

     

       36
       36
       +
       ### Error Handling (`Zulip.Error`)

     

       37
       37
       +
       ```ocaml

     

       38
       38
       +
       type code = 

     

       39
       39
       +
         | Invalid_api_key

     

       40
       40
       +
         | Request_variable_missing

     

       41
       41
       +
         | Bad_request

     

       42
       42
       +
         | User_deactivated

     

       43
       43
       +
         | Realm_deactivated

     

       44
       44
       +
         | Rate_limit_hit

     

       45
       45
       +
         | Other of string

     

       46
       46
       +
       

     

       47
       47
       +
       type t (* abstract *)

     

       48
       48
       +
       

     

       49
       49
       +
       val create : code:code -> msg:string -> ?extra:(string * Jsonm.value) list -> unit -> t

     

       50
       50
       +
       val code : t -> code

     

       51
       51
       +
       val message : t -> string

     

       52
       52
       +
       val extra : t -> (string * Jsonm.value) list

     

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

     

       54
       54
       +
       val of_json : Jsonm.value -> t option

     

       55
       55
       +
       ```

     

       56
       56
       +
       

     

       57
       57
       +
       ### Message Types (`Zulip.Message_type`)

     

       58
       58
       +
       ```ocaml

     

       59
       59
       +
       type t = [ `Direct | `Channel ]

     

       60
       60
       +
       

     

       61
       61
       +
       val to_string : t -> string

     

       62
       62
       +
       val of_string : string -> t option

     

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

     

       64
       64
       +
       ```

     

       65
       65
       +
       

     

       66
       66
       +
       ### Message (`Zulip.Message`)

     

       67
       67
       +
       ```ocaml

     

       68
       68
       +
       type t (* abstract *)

     

       69
       69
       +
       

     

       70
       70
       +
       val create : 

     

       71
       71
       +
         type_:Message_type.t -> 

     

       72
       72
       +
         to_:string list -> 

     

       73
       73
       +
         content:string -> 

     

       74
       74
       +
         ?topic:string -> 

     

       75
       75
       +
         ?queue_id:string -> 

     

       76
       76
       +
         ?local_id:string -> 

     

       77
       77
       +
         ?read_by_sender:bool -> 

     

       78
       78
       +
         unit -> t

     

       79
       79
       +
       

     

       80
       80
       +
       val type_ : t -> Message_type.t

     

       81
       81
       +
       val to_ : t -> string list

     

       82
       82
       +
       val content : t -> string

     

       83
       83
       +
       val topic : t -> string option

     

       84
       84
       +
       val queue_id : t -> string option

     

       85
       85
       +
       val local_id : t -> string option

     

       86
       86
       +
       val read_by_sender : t -> bool

     

       87
       87
       +
       val to_json : t -> Jsonm.value

     

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

     

       89
       89
       +
       ```

     

       90
       90
       +
       

     

       91
       91
       +
       ### Message Response (`Zulip.Message_response`)

     

       92
       92
       +
       ```ocaml

     

       93
       93
       +
       type t (* abstract *)

     

       94
       94
       +
       

     

       95
       95
       +
       val id : t -> int

     

       96
       96
       +
       val automatic_new_visibility_policy : t -> string option

     

       97
       97
       +
       val of_json : Jsonm.value -> (t, Error.t) result

     

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

     

       99
       99
       +
       ```

     

       100
       100
       +
       

     

       101
       101
       +
       ### Client (`Zulip.Client`)

     

       102
       102
       +
       ```ocaml

     

       103
       103
       +
       type t (* abstract *)

     

       104
       104
       +
       

     

       105
       105
       +
       val create : #Eio.Env.t -> Auth.t -> t

     

       106
       106
       +
       val with_client : #Eio.Env.t -> Auth.t -> (t -> 'a) -> 'a

     

       107
       107
       +
       

     

       108
       108
       +
       val request : 

     

       109
       109
       +
         t -> 

     

       110
       110
       +
         method_:[`GET | `POST | `PUT | `DELETE | `PATCH] ->

     

       111
       111
       +
         path:string -> 

     

       112
       112
       +
         ?params:(string * string) list ->

     

       113
       113
       +
         ?body:string ->

     

       114
       114
       +
         unit -> 

     

       115
       115
       +
         (Jsonm.value, Error.t) result

     

       116
       116
       +
       ```

     

       117
       117
       +
       

     

       118
       118
       +
       ### Messages (`Zulip.Messages`)

     

       119
       119
       +
       ```ocaml

     

       120
       120
       +
       val send : Client.t -> Message.t -> (Message_response.t, Error.t) result

     

       121
       121
       +
       val edit : Client.t -> message_id:int -> ?content:string -> ?topic:string -> unit -> (unit, Error.t) result

     

       122
       122
       +
       val delete : Client.t -> message_id:int -> (unit, Error.t) result

     

       123
       123
       +
       val get : Client.t -> message_id:int -> (Jsonm.value, Error.t) result

     

       124
       124
       +
       val get_messages : 

     

       125
       125
       +
         Client.t -> 

     

       126
       126
       +
         ?anchor:string -> 

     

       127
       127
       +
         ?num_before:int -> 

     

       128
       128
       +
         ?num_after:int -> 

     

       129
       129
       +
         ?narrow:string list -> 

     

       130
       130
       +
         unit -> 

     

       131
       131
       +
         (Jsonm.value, Error.t) result

     

       132
       132
       +
       ```

     

       133
       133
       +
       

     

       134
       134
       +
       ### Channel (`Zulip.Channel`)

     

       135
       135
       +
       ```ocaml

     

       136
       136
       +
       type t (* abstract *)

     

       137
       137
       +
       

     

       138
       138
       +
       val create : 

     

       139
       139
       +
         name:string -> 

     

       140
       140
       +
         description:string -> 

     

       141
       141
       +
         ?invite_only:bool -> 

     

       142
       142
       +
         ?history_public_to_subscribers:bool -> 

     

       143
       143
       +
         unit -> t

     

       144
       144
       +
       

     

       145
       145
       +
       val name : t -> string

     

       146
       146
       +
       val description : t -> string

     

       147
       147
       +
       val invite_only : t -> bool

     

       148
       148
       +
       val history_public_to_subscribers : t -> bool

     

       149
       149
       +
       val to_json : t -> Jsonm.value

     

       150
       150
       +
       val of_json : Jsonm.value -> (t, Error.t) result

     

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

     

       152
       152
       +
       ```

     

       153
       153
       +
       

     

       154
       154
       +
       ### Channels (`Zulip.Channels`)

     

       155
       155
       +
       ```ocaml

     

       156
       156
       +
       val create_channel : Client.t -> Channel.t -> (unit, Error.t) result

     

       157
       157
       +
       val delete : Client.t -> name:string -> (unit, Error.t) result

     

       158
       158
       +
       val list : Client.t -> (Channel.t list, Error.t) result

     

       159
       159
       +
       val subscribe : Client.t -> channels:string list -> (unit, Error.t) result

     

       160
       160
       +
       val unsubscribe : Client.t -> channels:string list -> (unit, Error.t) result

     

       161
       161
       +
       ```

     

       162
       162
       +
       

     

       163
       163
       +
       ### User (`Zulip.User`)

     

       164
       164
       +
       ```ocaml

     

       165
       165
       +
       type t (* abstract *)

     

       166
       166
       +
       

     

       167
       167
       +
       val create : 

     

       168
       168
       +
         email:string -> 

     

       169
       169
       +
         full_name:string -> 

     

       170
       170
       +
         ?is_active:bool -> 

     

       171
       171
       +
         ?is_admin:bool -> 

     

       172
       172
       +
         ?is_bot:bool -> 

     

       173
       173
       +
         unit -> t

     

       174
       174
       +
       

     

       175
       175
       +
       val email : t -> string

     

       176
       176
       +
       val full_name : t -> string

     

       177
       177
       +
       val is_active : t -> bool

     

       178
       178
       +
       val is_admin : t -> bool

     

       179
       179
       +
       val is_bot : t -> bool

     

       180
       180
       +
       val to_json : t -> Jsonm.value

     

       181
       181
       +
       val of_json : Jsonm.value -> (t, Error.t) result

     

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

     

       183
       183
       +
       ```

     

       184
       184
       +
       

     

       185
       185
       +
       ### Users (`Zulip.Users`)

     

       186
       186
       +
       ```ocaml

     

       187
       187
       +
       val list : Client.t -> (User.t list, Error.t) result

     

       188
       188
       +
       val get : Client.t -> email:string -> (User.t, Error.t) result

     

       189
       189
       +
       val create_user : Client.t -> email:string -> full_name:string -> (unit, Error.t) result

     

       190
       190
       +
       val deactivate : Client.t -> email:string -> (unit, Error.t) result

     

       191
       191
       +
       ```

     

       192
       192
       +
       

     

       193
       193
       +
       ### Event Type (`Zulip.Event_type`)

     

       194
       194
       +
       ```ocaml

     

       195
       195
       +
       type t = 

     

       196
       196
       +
         | Message

     

       197
       197
       +
         | Subscription 

     

       198
       198
       +
         | User_activity

     

       199
       199
       +
         | Other of string

     

       200
       200
       +
       

     

       201
       201
       +
       val to_string : t -> string

     

       202
       202
       +
       val of_string : string -> t

     

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

     

       204
       204
       +
       ```

     

       205
       205
       +
       

     

       206
       206
       +
       ### Event (`Zulip.Event`)

     

       207
       207
       +
       ```ocaml

     

       208
       208
       +
       type t (* abstract *)

     

       209
       209
       +
       

     

       210
       210
       +
       val id : t -> int

     

       211
       211
       +
       val type_ : t -> Event_type.t

     

       212
       212
       +
       val data : t -> Jsonm.value

     

       213
       213
       +
       val of_json : Jsonm.value -> (t, Error.t) result

     

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

     

       215
       215
       +
       ```

     

       216
       216
       +
       

     

       217
       217
       +
       ### Event Queue (`Zulip.Event_queue`)

     

       218
       218
       +
       ```ocaml

     

       219
       219
       +
       type t (* abstract *)

     

       220
       220
       +
       

     

       221
       221
       +
       val register : 

     

       222
       222
       +
         Client.t -> 

     

       223
       223
       +
         ?event_types:Event_type.t list -> 

     

       224
       224
       +
         unit -> 

     

       225
       225
       +
         (t, Error.t) result

     

       226
       226
       +
       

     

       227
       227
       +
       val id : t -> string

     

       228
       228
       +
       val get_events : t -> Client.t -> ?last_event_id:int -> unit -> (Event.t list, Error.t) result

     

       229
       229
       +
       val delete : t -> Client.t -> (unit, Error.t) result

     

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

     

       231
       231
       +
       ```

     

       232
       232
       +
       

     

       233
       233
       +
       ## EIO Bot Framework Extension

     

       234
       234
       +
       

     

       235
       235
       +
       Based on analysis of the Python bot framework at:

     

       236
       236
       +
       - https://github.com/zulip/python-zulip-api/blob/main/zulip_bots/zulip_bots/lib.py

     

       237
       237
       +
       - https://github.com/zulip/python-zulip-api/blob/main/zulip_botserver/zulip_botserver/server.py

     

       238
       238
       +
       

     

       239
       239
       +
       ### Bot Handler (`Zulip.Bot`)

     

       240
       240
       +
       ```ocaml

     

       241
       241
       +
       module Storage : sig

     

       242
       242
       +
         type t (* abstract *)

     

       243
       243
       +
         

     

       244
       244
       +
         val create : Client.t -> t

     

       245
       245
       +
         val get : t -> key:string -> string option

     

       246
       246
       +
         val put : t -> key:string -> value:string -> unit

     

       247
       247
       +
         val contains : t -> key:string -> bool

     

       248
       248
       +
       end

     

       249
       249
       +
       

     

       250
       250
       +
       module Identity : sig

     

       251
       251
       +
         type t (* abstract *)

     

       252
       252
       +
         

     

       253
       253
       +
         val full_name : t -> string

     

       254
       254
       +
         val email : t -> string

     

       255
       255
       +
         val mention_name : t -> string

     

       256
       256
       +
       end

     

       257
       257
       +
       

     

       258
       258
       +
       type handler = {

     

       259
       259
       +
         handle_message : 

     

       260
       260
       +
           client:Client.t ->

     

       261
       261
       +
           message:Jsonm.value ->

     

       262
       262
       +
           response:(Message.t -> unit) ->

     

       263
       263
       +
           unit;

     

       264
       264
       +
         

     

       265
       265
       +
         usage : unit -> string;

     

       266
       266
       +
         description : unit -> string;

     

       267
       267
       +
       }

     

       268
       268
       +
       

     

       269
       269
       +
       type t (* abstract *)

     

       270
       270
       +
       

     

       271
       271
       +
       val create : 

     

       272
       272
       +
         Client.t -> 

     

       273
       273
       +
         handler:handler ->

     

       274
       274
       +
         ?storage:Storage.t ->

     

       275
       275
       +
         unit -> t

     

       276
       276
       +
       

     

       277
       277
       +
       val identity : t -> Identity.t

     

       278
       278
       +
       val storage : t -> Storage.t

     

       279
       279
       +
       val handle_message : t -> Jsonm.value -> unit

     

       280
       280
       +
       val send_reply : t -> original_message:Jsonm.value -> content:string -> unit

     

       281
       281
       +
       val send_message : t -> Message.t -> unit

     

       282
       282
       +
       ```

     

       283
       283
       +
       

     

       284
       284
       +
       ### Bot Server (`Zulip.Bot_server`)

     

       285
       285
       +
       ```ocaml

     

       286
       286
       +
       module Config : sig

     

       287
       287
       +
         type bot_config = {

     

       288
       288
       +
           email : string;

     

       289
       289
       +
           api_key : string;

     

       290
       290
       +
           token : string; (* webhook token *)

     

       291
       291
       +
           server_url : string;

     

       292
       292
       +
           module_name : string;

     

       293
       293
       +
         }

     

       294
       294
       +
         

     

       295
       295
       +
         type t (* abstract *)

     

       296
       296
       +
         

     

       297
       297
       +
         val create : bot_configs:bot_config list -> ?host:string -> ?port:int -> unit -> t

     

       298
       298
       +
         val from_file : string -> (t, Error.t) result

     

       299
       299
       +
         val from_env : string -> (t, Error.t) result

     

       300
       300
       +
         val host : t -> string

     

       301
       301
       +
         val port : t -> int

     

       302
       302
       +
         val bot_configs : t -> bot_config list

     

       303
       303
       +
       end

     

       304
       304
       +
       

     

       305
       305
       +
       type t (* abstract *)

     

       306
       306
       +
       

     

       307
       307
       +
       val create : #Eio.Env.t -> Config.t -> (t, Error.t) result

     

       308
       308
       +
       

     

       309
       309
       +
       val run : t -> unit

     

       310
       310
       +
       (* Starts the server using EIO structured concurrency *)

     

       311
       311
       +
       

     

       312
       312
       +
       val with_server : #Eio.Env.t -> Config.t -> (t -> 'a) -> ('a, Error.t) result

     

       313
       313
       +
       (* Resource-safe server management *)

     

       314
       314
       +
       ```

     

       315
       315
       +
       

     

       316
       316
       +
       ### Bot Registry (`Zulip.Bot_registry`)

     

       317
       317
       +
       ```ocaml

     

       318
       318
       +
       type bot_module = {

     

       319
       319
       +
         name : string;

     

       320
       320
       +
         handler : Bot.handler;

     

       321
       321
       +
         create_instance : Client.t -> Bot.t;

     

       322
       322
       +
       }

     

       323
       323
       +
       

     

       324
       324
       +
       type t (* abstract *)

     

       325
       325
       +
       

     

       326
       326
       +
       val create : unit -> t

     

       327
       327
       +
       val register : t -> bot_module -> unit

     

       328
       328
       +
       val get_handler : t -> email:string -> Bot.t option

     

       329
       329
       +
       val list_bots : t -> string list

     

       330
       330
       +
       

     

       331
       331
       +
       (* Dynamic module loading *)

     

       332
       332
       +
       val load_from_file : string -> (bot_module, Error.t) result

     

       333
       333
       +
       val load_from_directory : string -> (bot_module list, Error.t) result

     

       334
       334
       +
       ```

     

       335
       335
       +
       

     

       336
       336
       +
       ### Webhook Handler (`Zulip.Webhook`)

     

       337
       337
       +
       ```ocaml

     

       338
       338
       +
       type webhook_event = {

     

       339
       339
       +
         bot_email : string;

     

       340
       340
       +
         token : string;

     

       341
       341
       +
         message : Jsonm.value;

     

       342
       342
       +
         trigger : [`Direct_message | `Mention];

     

       343
       343
       +
       }

     

       344
       344
       +
       

     

       345
       345
       +
       type response = {

     

       346
       346
       +
         content : string option;

     

       347
       347
       +
         message_type : Message_type.t option;

     

       348
       348
       +
         to_ : string list option;

     

       349
       349
       +
         topic : string option;

     

       350
       350
       +
       }

     

       351
       351
       +
       

     

       352
       352
       +
       val parse_webhook : string -> (webhook_event, Error.t) result

     

       353
       353
       +
       val handle_webhook : Bot_registry.t -> webhook_event -> (response option, Error.t) result

     

       354
       354
       +
       ```

     

       355
       355
       +
       

     

       356
       356
       +
       ### Structured Concurrency Design

     

       357
       357
       +
       

     

       358
       358
       +
       The EIO-based server uses structured concurrency to manage multiple bots safely:

     

       359
       359
       +
       

     

       360
       360
       +
       ```ocaml

     

       361
       361
       +
       (* Example server implementation using EIO *)

     

       362
       362
       +
       let run_server env config =

     

       363
       363
       +
         let registry = Bot_registry.create () in

     

       364
       364
       +
         

     

       365
       365
       +
         (* Load and register all configured bots concurrently *)

     

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

     

       367
       367
       +
         

     

       368
       368
       +
         (* Start each bot in its own fiber *)

     

       369
       369
       +
         List.iter (fun bot_config ->

     

       370
       370
       +
           Eio.Fiber.fork ~sw (fun () ->

     

       371
       371
       +
             let auth = Auth.create 

     

       372
       372
       +
               ~server_url:bot_config.server_url

     

       373
       373
       +
               ~email:bot_config.email 

     

       374
       374
       +
               ~api_key:bot_config.api_key in

     

       375
       375
       +
             

     

       376
       376
       +
             Client.with_client env auth @@ fun client ->

     

       377
       377
       +
             

     

       378
       378
       +
             (* Load bot module *)

     

       379
       379
       +
             match Bot_registry.load_from_file bot_config.module_name with

     

       380
       380
       +
             | Ok bot_module ->

     

       381
       381
       +
                 let bot = bot_module.create_instance client in

     

       382
       382
       +
                 Bot_registry.register registry bot_module;

     

       383
       383
       +
                 

     

       384
       384
       +
                 (* Keep bot alive and handle events *)

     

       385
       385
       +
                 Event_loop.run client bot

     

       386
       386
       +
             | Error e ->

     

       387
       387
       +
                 Printf.eprintf "Failed to load bot %s: %s\n" 

     

       388
       388
       +
                   bot_config.email (Error.message e)

     

       389
       389
       +
           )

     

       390
       390
       +
         ) (Config.bot_configs config);

     

       391
       391
       +
         

     

       392
       392
       +
         (* Start HTTP server for webhooks *)

     

       393
       393
       +
         let server_addr = `Tcp (Eio.Net.Ipaddr.V4.loopback, Config.port config) in

     

       394
       394
       +
         Eio.Net.run_server env#net server_addr ~on_error:raise @@ fun flow _addr ->

     

       395
       395
       +
           

     

       396
       396
       +
           (* Handle each webhook request concurrently *)

     

       397
       397
       +
           Eio.Switch.run @@ fun req_sw ->

     

       398
       398
       +
           Eio.Fiber.fork ~sw:req_sw (fun () ->

     

       399
       399
       +
             handle_http_request registry flow

     

       400
       400
       +
           )

     

       401
       401
       +
       ```

     

       402
       402
       +
       

     

       403
       403
       +
       ### Event Loop (`Zulip.Event_loop`)

     

       404
       404
       +
       ```ocaml

     

       405
       405
       +
       type t (* abstract *)

     

       406
       406
       +
       

     

       407
       407
       +
       val create : Client.t -> Bot.t -> t

     

       408
       408
       +
       

     

       409
       409
       +
       val run : Client.t -> Bot.t -> unit

     

       410
       410
       +
       (* Runs the event loop using real-time events API *)

     

       411
       411
       +
       

     

       412
       412
       +
       val run_webhook_mode : Client.t -> Bot.t -> unit  

     

       413
       413
       +
       (* Runs in webhook mode, waiting for HTTP callbacks *)

     

       414
       414
       +
       

     

       415
       415
       +
       (* For advanced use cases *)

     

       416
       416
       +
       val with_event_loop : 

     

       417
       417
       +
         Client.t -> 

     

       418
       418
       +
         Bot.t -> 

     

       419
       419
       +
         (Event_queue.t -> unit) -> 

     

       420
       420
       +
         unit

     

       421
       421
       +
       ```

     

       422
       422
       +
       

     

       423
       423
       +
       ## Key EIO Advantages

     

       424
       424
       +
       

     

       425
       425
       +
       1. **Structured Concurrency**: Each bot runs in its own fiber with proper cleanup

     

       426
       426
       +
       2. **Resource Safety**: Automatic cleanup of connections, event queues, and HTTP servers

     

       427
       427
       +
       3. **Backpressure**: Natural flow control through EIO's cooperative scheduling

     

       428
       428
       +
       4. **Error Isolation**: Bot failures don't crash the entire server

     

       429
       429
       +
       5. **Graceful Shutdown**: Structured teardown of all resources

     

       430
       430
       +
       

     

       431
       431
       +
       ## Design Principles

     

       432
       432
       +
       

     

       433
       433
       +
       1. **Abstract Types**: Each major concept has its own module with abstract `type t`

     

       434
       434
       +
       2. **Constructors**: Clear `create` functions with optional parameters

     

       435
       435
       +
       3. **Accessors**: All fields accessible via dedicated functions

     

       436
       436
       +
       4. **Pretty Printing**: Every type has a `pp` function for debugging

     

       437
       437
       +
       5. **JSON Conversion**: Bidirectional JSON conversion where appropriate

     

       438
       438
       +
       6. **Error Handling**: Consistent `(_, Error.t) result` return types

     

       439
       439
       +
       

     

       440
       440
       +
       ## Authentication Strategy

     

       441
       441
       +
       

     

       442
       442
       +
       - Support zuliprc files and direct credential passing

     

       443
       443
       +
       - Abstract `Auth.t` prevents credential leakage

     

       444
       444
       +
       - HTTP Basic Auth with proper encoding

     

       445
       445
       +
       

     

       446
       446
       +
       ## EIO Integration

     

       447
       447
       +
       

     

       448
       448
       +
       - All operations use EIO's direct-style async

     

       449
       449
       +
       - Resource-safe client management with `with_client`

     

       450
       450
       +
       - Proper cleanup of connections and event queues

     

       451
       451
       +
       

     

       452
       452
       +
       ## Example Usage

     

       453
       453
       +
       

     

       454
       454
       +
       ### Simple Message Sending

     

       455
       455
       +
       ```ocaml

     

       456
       456
       +
       let () =

     

       457
       457
       +
         Eio_main.run @@ fun env ->

     

       458
       458
       +
         let auth = Zulip.Auth.create 

     

       459
       459
       +
           ~server_url:"https://example.zulipchat.com"

     

       460
       460
       +
           ~email:"bot@example.com" 

     

       461
       461
       +
           ~api_key:"your-api-key" in

     

       462
       462
       +
         

     

       463
       463
       +
         Zulip.Client.with_client env auth @@ fun client ->

     

       464
       464
       +
         

     

       465
       465
       +
         let message = Zulip.Message.create 

     

       466
       466
       +
           ~type_:`Channel

     

       467
       467
       +
           ~to_:["general"]

     

       468
       468
       +
           ~content:"Hello from OCaml!"

     

       469
       469
       +
           ~topic:"Bots" 

     

       470
       470
       +
           () in

     

       471
       471
       +
         

     

       472
       472
       +
         match Zulip.Messages.send client message with

     

       473
       473
       +
         | Ok response -> 

     

       474
       474
       +
             Printf.printf "Message sent with ID: %d\n" 

     

       475
       475
       +
               (Zulip.Message_response.id response)

     

       476
       476
       +
         | Error error -> 

     

       477
       477
       +
             Printf.printf "Error: %s\n" 

     

       478
       478
       +
               (Zulip.Error.message error)

     

       479
       479
       +
       ```

     

       480
       480
       +
       

     

       481
       481
       +
       ### Simple Bot

     

       482
       482
       +
       ```ocaml

     

       483
       483
       +
       let echo_handler = Zulip.Bot.{

     

       484
       484
       +
         handle_message = (fun ~client ~message ~response ->

     

       485
       485
       +
           let content = extract_content message in

     

       486
       486
       +
           let echo_msg = Message.create 

     

       487
       487
       +
             ~type_:`Direct 

     

       488
       488
       +
             ~to_:[sender_email message]

     

       489
       489
       +
             ~content:("Echo: " ^ content) () in

     

       490
       490
       +
           response echo_msg

     

       491
       491
       +
         );

     

       492
       492
       +
         usage = (fun () -> "Echo bot - repeats your message");

     

       493
       493
       +
         description = (fun () -> "A simple echo bot");

     

       494
       494
       +
       }

     

       495
       495
       +
       

     

       496
       496
       +
       let () =

     

       497
       497
       +
         Eio_main.run @@ fun env ->

     

       498
       498
       +
         let auth = Auth.from_zuliprc () |> Result.get_ok in

     

       499
       499
       +
         

     

       500
       500
       +
         Client.with_client env auth @@ fun client ->

     

       501
       501
       +
         let bot = Bot.create client ~handler:echo_handler () in

     

       502
       502
       +
         Event_loop.run client bot

     

       503
       503
       +
       ```

     

       504
       504
       +
       

     

       505
       505
       +
       ### Multi-Bot Server

     

       506
       506
       +
       ```ocaml

     

       507
       507
       +
       let () =

     

       508
       508
       +
         Eio_main.run @@ fun env ->

     

       509
       509
       +
         let config = Bot_server.Config.from_file "bots.conf" |> Result.get_ok in

     

       510
       510
       +
         

     

       511
       511
       +
         Bot_server.with_server env config @@ fun server ->

     

       512
       512
       +
         Bot_server.run server

     

       513
       513
       +
       ```

     

       514
       514
       +
       

     

       515
       515
       +
       ## Package Dependencies

     

       516
       516
       +
       

     

       517
       517
       +
       - `eio` - Effects-based I/O

     

       518
       518
       +
       - `cohttp-eio` - HTTP client with EIO support  

     

       519
       519
       +
       - `tls-eio` - TLS support for HTTPS

     

       520
       520
       +
       - `jsonm` - Streaming JSON codec

     

       521
       521
       +
       - `uri` - URI parsing and manipulation

     

       522
       522
       +
       - `base64` - Base64 encoding for authentication

     

       523
       523
       +
       

     

       524
       524
       +
       # Architecture Analysis: zulip_bot vs zulip_botserver

     

       525
       525
       +
       

     

       526
       526
       +
       ## Library Separation

     

       527
       527
       +
       

     

       528
       528
       +
       ### `zulip_bot` - Individual Bot Framework

     

       529
       529
       +
       **Purpose**: Library for building and running a single bot instance

     

       530
       530
       +
       

     

       531
       531
       +
       **Key Components**:

     

       532
       532
       +
       - `Bot_handler` - Interface for bot logic with EIO environment access

     

       533
       533
       +
       - `Bot_runner` - Manages lifecycle of one bot (real-time events or webhook mode)

     

       534
       534
       +
       - `Bot_config` - Configuration for a single bot

     

       535
       535
       +
       - `Bot_storage` - Simple in-memory storage for bot state

     

       536
       536
       +
       

     

       537
       537
       +
       **Usage Pattern**:

     

       538
       538
       +
       ```ocaml

     

       539
       539
       +
       (* Run a single bot directly *)

     

       540
       540
       +
       let my_bot = Bot_handler.create (module My_echo_bot) ~config ~storage ~identity in

     

       541
       541
       +
       let runner = Bot_runner.create ~client ~handler:my_bot in

     

       542
       542
       +
       Bot_runner.run_realtime runner  (* Bot connects to Zulip events API directly *)

     

       543
       543
       +
       ```

     

       544
       544
       +
       

     

       545
       545
       +
       ### `zulip_botserver` - Multi-Bot Server Infrastructure  

     

       546
       546
       +
       **Purpose**: HTTP server that manages multiple bots via webhooks

     

       547
       547
       +
       

     

       548
       548
       +
       **Key Components**:

     

       549
       549
       +
       - `Bot_server` - HTTP server receiving webhook events from Zulip

     

       550
       550
       +
       - `Bot_registry` - Manages multiple bot instances  

     

       551
       551
       +
       - `Server_config` - Configuration for multiple bots + server settings

     

       552
       552
       +
       - `Webhook_handler` - Parses incoming webhook requests and routes to appropriate bots

     

       553
       553
       +
       

     

       554
       554
       +
       **Usage Pattern**:

     

       555
       555
       +
       ```ocaml

     

       556
       556
       +
       (* Run a server hosting multiple bots *)

     

       557
       557
       +
       let registry = Bot_registry.create () in

     

       558
       558
       +
       Bot_registry.register registry echo_bot_module;

     

       559
       559
       +
       Bot_registry.register registry weather_bot_module;

     

       560
       560
       +
       

     

       561
       561
       +
       let server = Bot_server.create ~env ~config ~registry in

     

       562
       562
       +
       Bot_server.run server  (* HTTP server waits for webhook calls *)

     

       563
       563
       +
       ```

     

       564
       564
       +
       

     

       565
       565
       +
       ## EIO Environment Requirements

     

       566
       566
       +
       

     

       567
       567
       +
       ### Why Bot Handlers Need Direct EIO Access

     

       568
       568
       +
       

     

       569
       569
       +
       Bot handlers require direct access to the EIO environment for legitimate I/O operations beyond HTTP requests to Zulip:

     

       570
       570
       +
       

     

       571
       571
       +
       1. **Network Operations**: Custom HTTP requests, API calls to external services

     

       572
       572
       +
       2. **File System Operations**: Reading configuration files, CSV dictionaries, logs

     

       573
       573
       +
       3. **Resource Management**: Proper cleanup via structured concurrency

     

       574
       574
       +
       

     

       575
       575
       +
       ### Example: URL Checker Bot

     

       576
       576
       +
       ```ocaml

     

       577
       577
       +
       module Url_checker_bot : Zulip_bot.Bot_handler.Bot_handler = struct

     

       578
       578
       +
         let handle_message ~config ~storage ~identity ~message ~env =

     

       579
       579
       +
           match parse_command message with

     

       580
       580
       +
           | "!check", url ->

     

       581
       581
       +
               (* Direct EIO network access needed *)

     

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

     

       583
       583
       +
               let client = Cohttp_eio.Client.make ~sw env#net in

     

       584
       584
       +
               let response = Cohttp_eio.Client.head ~sw client (Uri.of_string url) in

     

       585
       585
       +
               let status = Cohttp.Code.code_of_status response.status in

     

       586
       586
       +
               Ok (Response.reply ~content:(format_status_message url status))

     

       587
       587
       +
           | _ -> Ok Response.none

     

       588
       588
       +
       end

     

       589
       589
       +
       ```

     

       590
       590
       +
       

     

       591
       591
       +
       ### Example: CSV Dictionary Bot

     

       592
       592
       +
       ```ocaml  

     

       593
       593
       +
       module Csv_dict_bot : Zulip_bot.Bot_handler.Bot_handler = struct

     

       594
       594
       +
         let handle_message ~config ~storage ~identity ~message ~env =

     

       595
       595
       +
           match parse_command message with

     

       596
       596
       +
           | "!lookup", term ->

     

       597
       597
       +
               (* Direct EIO file system access needed *)

     

       598
       598
       +
               let csv_path = Bot_config.get_required config ~key:"csv_file" in

     

       599
       599
       +
               let content = Eio.Path.load env#fs (Eio.Path.parse csv_path) in

     

       600
       600
       +
               let matches = search_csv_content content term in

     

       601
       601
       +
               Ok (Response.reply ~content:(format_matches matches))

     

       602
       602
       +
           | _ -> Ok Response.none

     

       603
       603
       +
       end

     

       604
       604
       +
       ```

     

       605
       605
       +
       

     

       606
       606
       +
       ## Refined Bot Handler Interface

     

       607
       607
       +
       

     

       608
       608
       +
       Based on analysis, the current EIO environment plumbing is **essential** and should be cleaned up:

     

       609
       609
       +
       

     

       610
       610
       +
       ```ocaml

     

       611
       611
       +
       (** Clean bot handler interface with direct EIO access *)

     

       612
       612
       +
       module type Bot_handler = sig

     

       613
       613
       +
         val initialize : Bot_config.t -> (unit, Zulip.Error.t) result

     

       614
       614
       +
         val usage : unit -> string

     

       615
       615
       +
         val description : unit -> string

     

       616
       616
       +
         

     

       617
       617
       +
         (** Handle message with full EIO environment access *)

     

       618
       618
       +
         val handle_message : 

     

       619
       619
       +
           config:Bot_config.t ->

     

       620
       620
       +
           storage:Bot_storage.t ->

     

       621
       621
       +
           identity:Identity.t ->

     

       622
       622
       +
           message:Message_context.t ->

     

       623
       623
       +
           env:#Eio.Env.t ->  (* Essential for custom I/O *)

     

       624
       624
       +
           (Response.t, Zulip.Error.t) result

     

       625
       625
       +
       end

     

       626
       626
       +
       

     

       627
       627
       +
       type t

     

       628
       628
       +
       

     

       629
       629
       +
       (** Single creation interface *)

     

       630
       630
       +
       val create : 

     

       631
       631
       +
         (module Bot_handler) -> 

     

       632
       632
       +
         config:Bot_config.t -> 

     

       633
       633
       +
         storage:Bot_storage.t -> 

     

       634
       634
       +
         identity:Identity.t -> 

     

       635
       635
       +
         t

     

       636
       636
       +
       

     

       637
       637
       +
       (** Single message handler requiring EIO environment *)

     

       638
       638
       +
       val handle_message : t -> #Eio.Env.t -> Message_context.t -> (Response.t, Zulip.Error.t) result

     

       639
       639
       +
       ```

     

       640
       640
       +
       

     

       641
       641
       +
       ## Storage Strategy

     

       642
       642
       +
       

     

       643
       643
       +
       Bot storage can be simplified to in-memory key-value storage since it's server-side:

     

       644
       644
       +
       

     

       645
       645
       +
       ```ocaml

     

       646
       646
       +
       (* In zulip_bot - storage per bot instance *)

     

       647
       647
       +
       module Bot_storage = struct

     

       648
       648
       +
         type t = (string, string) Hashtbl.t  (* Simple in-memory key-value *)

     

       649
       649
       +
         

     

       650
       650
       +
         let create () = Hashtbl.create 16

     

       651
       651
       +
         let get t ~key = Hashtbl.find_opt t key  

     

       652
       652
       +
         let put t ~key ~value = Hashtbl.replace t key value

     

       653
       653
       +
         let contains t ~key = Hashtbl.mem t key

     

       654
       654
       +
       end

     

       655
       655
       +
       

     

       656
       656
       +
       (* In zulip_botserver - storage shared across bots *)

     

       657
       657
       +
       module Server_storage = struct

     

       658
       658
       +
         type t = (string * string, string) Hashtbl.t  (* (bot_email, key) -> value *)

     

       659
       659
       +
         

     

       660
       660
       +
         let create () = Hashtbl.create 64

     

       661
       661
       +
         let get t ~bot_email ~key = Hashtbl.find_opt t (bot_email, key)

     

       662
       662
       +
         let put t ~bot_email ~key ~value = Hashtbl.replace t (bot_email, key) value

     

       663
       663
       +
       end

     

       664
       664
       +
       ```

     

       665
       665
       +
       

     

       666
       666
       +
       ## Interface Cleanup Recommendations

     

       667
       667
       +
       

     

       668
       668
       +
       1. **Remove** the problematic `handle_message` function with mock environment

     

       669
       669
       +
       2. **Keep** `handle_message_with_env` but rename to `handle_message`

     

       670
       670
       +
       3. **Use** `#Eio.Env.t` constraint for clean typing

     

       671
       671
       +
       4. **Document** that bot handlers have full EIO access for custom I/O operations

     

       672
       672
       +
       

     

       673
       673
       +
       This design maintains flexibility for real-world bot functionality while providing clean, type-safe interfaces.

     

       674
       674
       +
       

     

       675
       675
       +
       ## Sources and References

     

       676
       676
       +
       

     

       677
       677
       +
       This design is based on comprehensive analysis of:

     

       678
       678
       +
       

     

       679
       679
       +
       1. **Zulip REST API Documentation**:

     

       680
       680
       +
          - Main API: https://zulip.com/api/rest

     

       681
       681
       +
          - Error Handling: https://zulip.com/api/rest-error-handling  

     

       682
       682
       +
          - Send Message: https://zulip.com/api/send-message

     

       683
       683
       +
       

     

       684
       684
       +
       2. **Python Zulip Library**:

     

       685
       685
       +
          - Main repository: https://github.com/zulip/python-zulip-api

     

       686
       686
       +
          - Bot framework: https://github.com/zulip/python-zulip-api/blob/main/zulip_bots/zulip_bots/lib.py

     

       687
       687
       +
          - Bot server: https://github.com/zulip/python-zulip-api/blob/main/zulip_botserver/zulip_botserver/server.py

     

       688
       688
       +
       

     

       689
       689
       +
       The design adapts these Python patterns to idiomatic OCaml with abstract types, proper error handling, and EIO's structured concurrency for robust, type-safe Zulip integration.

+143

stack/zulip/README.md

···

       1
       1
       +
       # OCaml Zulip Library with Requests

     

       2
       2
       +
       

     

       3
       3
       +
       A complete OCaml implementation of the Zulip REST API using the `requests` HTTP library.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Features

     

       6
       6
       +
       

     

       7
       7
       +
       - ✅ Full Zulip REST API client implementation

     

       8
       8
       +
       - ✅ Uses the modern `requests` library for HTTP communication

     

       9
       9
       +
       - ✅ EIO-based asynchronous operations

     

       10
       10
       +
       - ✅ Bot framework for building interactive bots

     

       11
       11
       +
       - ✅ Support for Atom/RSS feed bots

     

       12
       12
       +
       

     

       13
       13
       +
       ## Installation

     

       14
       14
       +
       

     

       15
       15
       +
       ```bash

     

       16
       16
       +
       dune build

     

       17
       17
       +
       dune install

     

       18
       18
       +
       ```

     

       19
       19
       +
       

     

       20
       20
       +
       ## Configuration

     

       21
       21
       +
       

     

       22
       22
       +
       Create a `~/.zuliprc` file with your Zulip credentials:

     

       23
       23
       +
       

     

       24
       24
       +
       ```ini

     

       25
       25
       +
       [api]

     

       26
       26
       +
       email = bot@example.com

     

       27
       27
       +
       key = your-api-key-here

     

       28
       28
       +
       site = https://your-domain.zulipchat.com

     

       29
       29
       +
       ```

     

       30
       30
       +
       

     

       31
       31
       +
       ## Usage

     

       32
       32
       +
       

     

       33
       33
       +
       ### Basic Client

     

       34
       34
       +
       

     

       35
       35
       +
       ```ocaml

     

       36
       36
       +
       open Eio_main

     

       37
       37
       +
       

     

       38
       38
       +
       let () =

     

       39
       39
       +
         run @@ fun env ->

     

       40
       40
       +
       

     

       41
       41
       +
         (* Load authentication *)

     

       42
       42
       +
         let auth = Zulip.Auth.from_zuliprc () |> Result.get_ok in

     

       43
       43
       +
       

     

       44
       44
       +
         (* Create client *)

     

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

     

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

     

       47
       47
       +
       

     

       48
       48
       +
         (* Send a message *)

     

       49
       49
       +
         let message = Zulip.Message.create

     

       50
       50
       +
           ~type_:`Channel

     

       51
       51
       +
           ~to_:["general"]

     

       52
       52
       +
           ~topic:"Hello"

     

       53
       53
       +
           ~content:"Hello from OCaml!"

     

       54
       54
       +
           ()

     

       55
       55
       +
         in

     

       56
       56
       +
       

     

       57
       57
       +
         match Zulip.Messages.send client message with

     

       58
       58
       +
         | Ok response -> Printf.printf "Sent message %d\n" (Zulip.Message_response.id response)

     

       59
       59
       +
         | Error e -> Printf.eprintf "Error: %s\n" (Zulip.Error.message e)

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       ### Atom Feed Bot

     

       63
       63
       +
       

     

       64
       64
       +
       The library includes a complete Atom/RSS feed bot that can:

     

       65
       65
       +
       - Monitor multiple feeds

     

       66
       66
       +
       - Post updates to specific Zulip channels and topics

     

       67
       67
       +
       - Track which entries have been posted

     

       68
       68
       +
       - Run as a scheduled daemon or interactive bot

     

       69
       69
       +
       

     

       70
       70
       +
       #### Scheduled Mode

     

       71
       71
       +
       

     

       72
       72
       +
       ```bash

     

       73
       73
       +
       # Run the feed bot in scheduled mode

     

       74
       74
       +
       dune exec atom_feed_bot

     

       75
       75
       +
       ```

     

       76
       76
       +
       

     

       77
       77
       +
       #### Interactive Mode

     

       78
       78
       +
       

     

       79
       79
       +
       ```bash

     

       80
       80
       +
       # Run as an interactive bot that responds to commands

     

       81
       81
       +
       dune exec atom_feed_bot interactive

     

       82
       82
       +
       ```

     

       83
       83
       +
       

     

       84
       84
       +
       Bot commands:

     

       85
       85
       +
       - `!feed add <name> <url> <topic>` - Add a new feed

     

       86
       86
       +
       - `!feed remove <name>` - Remove a feed

     

       87
       87
       +
       - `!feed list` - List all feeds

     

       88
       88
       +
       - `!feed fetch <name>` - Manually fetch a feed

     

       89
       89
       +
       - `!feed help` - Show help

     

       90
       90
       +
       

     

       91
       91
       +
       ## Architecture

     

       92
       92
       +
       

     

       93
       93
       +
       ### Core Library (`zulip`)

     

       94
       94
       +
       

     

       95
       95
       +
       - **Auth**: Authentication and credential management

     

       96
       96
       +
       - **Client**: HTTP client using the `requests` library

     

       97
       97
       +
       - **Messages**: Send, edit, and retrieve messages

     

       98
       98
       +
       - **Channels**: Channel/stream management

     

       99
       99
       +
       - **Users**: User management

     

       100
       100
       +
       - **Events**: Real-time event handling

     

       101
       101
       +
       

     

       102
       102
       +
       ### Bot Framework (`zulip_bot`)

     

       103
       103
       +
       

     

       104
       104
       +
       - **Bot_handler**: Interface for bot logic

     

       105
       105
       +
       - **Bot_runner**: Manages bot lifecycle

     

       106
       106
       +
       - **Bot_storage**: State persistence

     

       107
       107
       +
       - **Bot_config**: Configuration management

     

       108
       108
       +
       

     

       109
       109
       +
       ## Key Changes from Original Implementation

     

       110
       110
       +
       

     

       111
       111
       +
       1. **HTTP Library**: Migrated from `cohttp-eio` to the `requests` library

     

       112
       112
       +
       2. **Configuration**: Removed `toml` dependency, uses simple INI parser

     

       113
       113
       +
       3. **Type Safety**: Made Client.t parametric over environment types

     

       114
       114
       +
       4. **Authentication**: Simplified auth handling with built-in INI parser

     

       115
       115
       +
       

     

       116
       116
       +
       ## Examples

     

       117
       117
       +
       

     

       118
       118
       +
       See the `examples/` directory for:

     

       119
       119
       +
       - `test_client.ml` - Basic client functionality test

     

       120
       120
       +
       - `atom_feed_bot.ml` - Complete Atom/RSS feed bot implementation

     

       121
       121
       +
       

     

       122
       122
       +
       ## Testing

     

       123
       123
       +
       

     

       124
       124
       +
       ```bash

     

       125
       125
       +
       # Build the library

     

       126
       126
       +
       dune build

     

       127
       127
       +
       

     

       128
       128
       +
       # Run the test client

     

       129
       129
       +
       dune exec test_client

     

       130
       130
       +
       

     

       131
       131
       +
       # Run the atom feed bot

     

       132
       132
       +
       dune exec atom_feed_bot

     

       133
       133
       +
       ```

     

       134
       134
       +
       

     

       135
       135
       +
       ## Requirements

     

       136
       136
       +
       

     

       137
       137
       +
       - OCaml 4.08+

     

       138
       138
       +
       - Dune 3.0+

     

       139
       139
       +
       - eio

     

       140
       140
       +
       - requests

     

       141
       141
       +
       - jsonm

     

       142
       142
       +
       - uri

     

       143
       143
       +
       - base64

+42

stack/zulip/dune-project

···

       1
       1
       +
       (lang dune 3.0)

     

       2
       2
       +
       

     

       3
       3
       +
       (name ocaml-zulip)

     

       4
       4
       +
       

     

       5
       5
       +
       (package

     

       6
       6
       +
        (name zulip)

     

       7
       7
       +
        (synopsis "OCaml bindings for the Zulip REST API")

     

       8
       8
       +
        (description "High-quality OCaml bindings to the Zulip REST API using EIO for async operations")

     

       9
       9
       +
        (depends

     

       10
       10
       +
         ocaml

     

       11
       11
       +
         dune

     

       12
       12
       +
         eio

     

       13
       13
       +
         requests

     

       14
       14
       +
         jsonm

     

       15
       15
       +
         uri

     

       16
       16
       +
         base64

     

       17
       17
       +
         (alcotest :with-test)

     

       18
       18
       +
         (eio_main :with-test)))

     

       19
       19
       +
       

     

       20
       20
       +
       (package

     

       21
       21
       +
        (name zulip_bot)

     

       22
       22
       +
        (synopsis "OCaml bot framework for Zulip")

     

       23
       23
       +
        (description "Interactive bot framework built on the OCaml Zulip library")

     

       24
       24
       +
        (depends

     

       25
       25
       +
         ocaml

     

       26
       26
       +
         dune

     

       27
       27
       +
         zulip

     

       28
       28
       +
         eio

     

       29
       29
       +
         (alcotest :with-test)))

     

       30
       30
       +
       

     

       31
       31
       +
       (package

     

       32
       32
       +
        (name zulip_botserver)

     

       33
       33
       +
        (synopsis "OCaml bot server for running multiple Zulip bots")

     

       34
       34
       +
        (description "HTTP server for running multiple Zulip bots with webhook support")

     

       35
       35
       +
        (depends

     

       36
       36
       +
         ocaml

     

       37
       37
       +
         dune

     

       38
       38
       +
         zulip

     

       39
       39
       +
         zulip_bot

     

       40
       40
       +
         eio

     

       41
       41
       +
         requests

     

       42
       42
       +
         (alcotest :with-test)))

+167

stack/zulip/examples/README_ECHO_BOT.md

···

       1
       1
       +
       # Zulip Echo Bot

     

       2
       2
       +
       

     

       3
       3
       +
       A simple echo bot that demonstrates the basic functionality of the Zulip bot framework. The bot responds to direct messages and mentions by echoing back the message content.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Features

     

       6
       6
       +
       

     

       7
       7
       +
       - Responds to direct messages

     

       8
       8
       +
       - Responds to @mentions in channels

     

       9
       9
       +
       - Avoids infinite loops by ignoring its own messages

     

       10
       10
       +
       - Simple help command

     

       11
       11
       +
       

     

       12
       12
       +
       ## Prerequisites

     

       13
       13
       +
       

     

       14
       14
       +
       1. A Zulip account and server

     

       15
       15
       +
       2. A bot user created in Zulip (Settings → Bots → Add a new bot)

     

       16
       16
       +
       3. OCaml and dependencies installed

     

       17
       17
       +
       

     

       18
       18
       +
       ## Setup

     

       19
       19
       +
       

     

       20
       20
       +
       ### 1. Create a Bot in Zulip

     

       21
       21
       +
       

     

       22
       22
       +
       1. Go to your Zulip settings

     

       23
       23
       +
       2. Navigate to "Bots" section

     

       24
       24
       +
       3. Click "Add a new bot"

     

       25
       25
       +
       4. Choose "Generic bot" type

     

       26
       26
       +
       5. Give it a name (e.g., "Echo Bot")

     

       27
       27
       +
       6. Note down the bot email and API key

     

       28
       28
       +
       

     

       29
       29
       +
       ### 2. Configure Authentication

     

       30
       30
       +
       

     

       31
       31
       +
       Create a `~/.zuliprc` file with your bot's credentials:

     

       32
       32
       +
       

     

       33
       33
       +
       ```ini

     

       34
       34
       +
       [api]

     

       35
       35
       +
       email=echo-bot@your-domain.zulipchat.com

     

       36
       36
       +
       key=your-bot-api-key

     

       37
       37
       +
       site=https://your-domain.zulipchat.com

     

       38
       38
       +
       ```

     

       39
       39
       +
       

     

       40
       40
       +
       Replace the values with your actual bot credentials.

     

       41
       41
       +
       

     

       42
       42
       +
       ### 3. Build the Bot

     

       43
       43
       +
       

     

       44
       44
       +
       ```bash

     

       45
       45
       +
       # From the zulip directory

     

       46
       46
       +
       dune build

     

       47
       47
       +
       

     

       48
       48
       +
       # Or build just the echo bot

     

       49
       49
       +
       dune build zulip/examples/echo_bot.exe

     

       50
       50
       +
       ```

     

       51
       51
       +
       

     

       52
       52
       +
       ## Running the Bot

     

       53
       53
       +
       

     

       54
       54
       +
       ```bash

     

       55
       55
       +
       # Run from the project root

     

       56
       56
       +
       dune exec echo_bot

     

       57
       57
       +
       

     

       58
       58
       +
       # Or run the built executable directly

     

       59
       59
       +
       ./_build/default/zulip/examples/echo_bot.exe

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       You should see output like:

     

       63
       63
       +
       ```

     

       64
       64
       +
       Starting Zulip Echo Bot...

     

       65
       65
       +
       =============================

     

       66
       66
       +
       

     

       67
       67
       +
       Loaded authentication for: echo-bot@your-domain.zulipchat.com

     

       68
       68
       +
       Server: https://your-domain.zulipchat.com

     

       69
       69
       +
       

     

       70
       70
       +
       Echo bot is running!

     

       71
       71
       +
       Send a direct message or mention @echobot in a channel.

     

       72
       72
       +
       Press Ctrl+C to stop.

     

       73
       73
       +
       ```

     

       74
       74
       +
       

     

       75
       75
       +
       ## Testing the Bot

     

       76
       76
       +
       

     

       77
       77
       +
       ### Direct Message Test

     

       78
       78
       +
       1. Open Zulip

     

       79
       79
       +
       2. Send a direct message to your bot

     

       80
       80
       +
       3. Type: `Hello bot!`

     

       81
       81
       +
       4. The bot should respond: `Echo from [Your Name]: Hello bot!`

     

       82
       82
       +
       

     

       83
       83
       +
       ### Channel Mention Test

     

       84
       84
       +
       1. In any channel, type: `@echobot Hello everyone!`

     

       85
       85
       +
       2. The bot should respond: `Echo from [Your Name]: Hello everyone!`

     

       86
       86
       +
       

     

       87
       87
       +
       ### Help Command

     

       88
       88
       +
       Send `help` to the bot to get usage information.

     

       89
       89
       +
       

     

       90
       90
       +
       ## How It Works

     

       91
       91
       +
       

     

       92
       92
       +
       The echo bot:

     

       93
       93
       +
       1. Connects to Zulip using the real-time events API

     

       94
       94
       +
       2. Listens for messages where it's mentioned or direct messaged

     

       95
       95
       +
       3. Extracts the message content and sender information

     

       96
       96
       +
       4. Sends back an echo of the message

     

       97
       97
       +
       5. Ignores its own messages to prevent loops

     

       98
       98
       +
       

     

       99
       99
       +
       ## Code Structure

     

       100
       100
       +
       

     

       101
       101
       +
       - **Bot Handler Module**: Implements the `Bot_handler.S` signature with message processing logic

     

       102
       102
       +
       - **Message Processing**: Extracts fields from incoming JSON messages

     

       103
       103
       +
       - **Response Generation**: Creates appropriate responses based on message type

     

       104
       104
       +
       - **Identity Management**: Uses bot identity to avoid self-responses

     

       105
       105
       +
       

     

       106
       106
       +
       ## Customization

     

       107
       107
       +
       

     

       108
       108
       +
       You can modify the echo bot to:

     

       109
       109
       +
       - Add more commands (parse for specific keywords)

     

       110
       110
       +
       - Store conversation history (use `Bot_storage`)

     

       111
       111
       +
       - Integrate with external APIs

     

       112
       112
       +
       - Format responses differently

     

       113
       113
       +
       - Add emoji reactions

     

       114
       114
       +
       

     

       115
       115
       +
       ## Troubleshooting

     

       116
       116
       +
       

     

       117
       117
       +
       ### Bot doesn't respond

     

       118
       118
       +
       - Check that the bot is actually running (look for console output)

     

       119
       119
       +
       - Verify the bot has permissions in the channel

     

       120
       120
       +
       - Check that you're mentioning the bot correctly (@botname)

     

       121
       121
       +
       - Look for error messages in the console

     

       122
       122
       +
       

     

       123
       123
       +
       ### Authentication errors

     

       124
       124
       +
       - Verify your `.zuliprc` file has the correct credentials

     

       125
       125
       +
       - Ensure the API key hasn't been regenerated

     

       126
       126
       +
       - Check that the bot user is active in Zulip

     

       127
       127
       +
       

     

       128
       128
       +
       ### Build errors

     

       129
       129
       +
       - Make sure all dependencies are installed: `opam install zulip zulip_bot eio_main`

     

       130
       130
       +
       - Clean and rebuild: `dune clean && dune build`

     

       131
       131
       +
       

     

       132
       132
       +
       ## Next Steps

     

       133
       133
       +
       

     

       134
       134
       +
       Once you have the echo bot working, you can:

     

       135
       135
       +
       1. Extend it with more complex command parsing

     

       136
       136
       +
       2. Add persistent storage for user preferences

     

       137
       137
       +
       3. Integrate with external services

     

       138
       138
       +
       4. Build more sophisticated bots using the same framework

     

       139
       139
       +
       

     

       140
       140
       +
       ## Example Extensions

     

       141
       141
       +
       

     

       142
       142
       +
       ### Adding a Command Parser

     

       143
       143
       +
       ```ocaml

     

       144
       144
       +
       let parse_command content =

     

       145
       145
       +
         match String.split_on_char ' ' content with

     

       146
       146
       +
         | "!echo" :: rest -> Some ("echo", String.concat " " rest)

     

       147
       147
       +
         | "!reverse" :: rest -> Some ("reverse", String.concat " " rest)

     

       148
       148
       +
         | _ -> None

     

       149
       149
       +
       ```

     

       150
       150
       +
       

     

       151
       151
       +
       ### Using Bot Storage

     

       152
       152
       +
       ```ocaml

     

       153
       153
       +
       (* Store user preferences *)

     

       154
       154
       +
       let _ = Bot_storage.put storage ~key:"user_prefs" ~value:"{...}" in

     

       155
       155
       +
       

     

       156
       156
       +
       (* Retrieve later *)

     

       157
       157
       +
       let prefs = Bot_storage.get storage ~key:"user_prefs" in

     

       158
       158
       +
       ```

     

       159
       159
       +
       

     

       160
       160
       +
       ### Sending to Specific Channels

     

       161
       161
       +
       ```ocaml

     

       162
       162
       +
       Bot_handler.Response.ChannelMessage {

     

       163
       163
       +
         channel = "general";

     

       164
       164
       +
         topic = "Bot Updates";

     

       165
       165
       +
         content = "Echo bot is online!";

     

       166
       166
       +
       }

     

       167
       167
       +
       ```

+383

stack/zulip/examples/atom_feed_bot.ml

···

       1
       1
       +
       (* Atom Feed Bot for Zulip

     

       2
       2
       +
          Posts Atom/RSS feed entries to Zulip channels organized by topic *)

     

       3
       3
       +
       

     

       4
       4
       +
       module Feed_parser = struct

     

       5
       5
       +
         type entry = {

     

       6
       6
       +
           title : string;

     

       7
       7
       +
           link : string;

     

       8
       8
       +
           summary : string option;

     

       9
       9
       +
           published : string option;

     

       10
       10
       +
           author : string option;

     

       11
       11
       +
         }

     

       12
       12
       +
       

     

       13
       13
       +
         type feed = {

     

       14
       14
       +
           title : string;

     

       15
       15
       +
           entries : entry list;

     

       16
       16
       +
         }

     

       17
       17
       +
       

     

       18
       18
       +
         (* Simple XML parser for Atom/RSS feeds *)

     

       19
       19
       +
         let parse_xml_element xml element_name =

     

       20
       20
       +
           let open_tag = "<" ^ element_name ^ ">" in

     

       21
       21
       +
           let close_tag = "</" ^ element_name ^ ">" in

     

       22
       22
       +
           try

     

       23
       23
       +
             (* Find the opening tag *)

     

       24
       24
       +
             match String.index_opt xml '<' with

     

       25
       25
       +
             | None -> None

     

       26
       26
       +
             | Some _ ->

     

       27
       27
       +
                 (* Search for the actual open tag in the XML *)

     

       28
       28
       +
                 let pattern = open_tag in

     

       29
       29
       +
                 let pattern_start =

     

       30
       30
       +
                   try Some (String.index (String.lowercase_ascii xml)

     

       31
       31
       +
                               (String.lowercase_ascii pattern).[0])

     

       32
       32
       +
                   with Not_found -> None

     

       33
       33
       +
                 in

     

       34
       34
       +
                 match pattern_start with

     

       35
       35
       +
                 | None -> None

     

       36
       36
       +
                 | Some _ ->

     

       37
       37
       +
                     (* Try to find the content between tags *)

     

       38
       38
       +
                     let rec find_substring str sub start =

     

       39
       39
       +
                       if start + String.length sub > String.length str then

     

       40
       40
       +
                         None

     

       41
       41
       +
                       else if String.sub str start (String.length sub) = sub then

     

       42
       42
       +
                         Some start

     

       43
       43
       +
                       else

     

       44
       44
       +
                         find_substring str sub (start + 1)

     

       45
       45
       +
                     in

     

       46
       46
       +
                     match find_substring xml open_tag 0 with

     

       47
       47
       +
                     | None -> None

     

       48
       48
       +
                     | Some start_pos ->

     

       49
       49
       +
                         let content_start = start_pos + String.length open_tag in

     

       50
       50
       +
                         match find_substring xml close_tag content_start with

     

       51
       51
       +
                         | None -> None

     

       52
       52
       +
                         | Some end_pos ->

     

       53
       53
       +
                             let content = String.sub xml content_start (end_pos - content_start) in

     

       54
       54
       +
                             Some (String.trim content)

     

       55
       55
       +
           with _ -> None

     

       56
       56
       +
       

     

       57
       57
       +
         let parse_entry entry_xml =

     

       58
       58
       +
           let title = parse_xml_element entry_xml "title" in

     

       59
       59
       +
           let link = parse_xml_element entry_xml "link" in

     

       60
       60
       +
           let summary = parse_xml_element entry_xml "summary" in

     

       61
       61
       +
           let published = parse_xml_element entry_xml "published" in

     

       62
       62
       +
           let author = parse_xml_element entry_xml "author" in

     

       63
       63
       +
           match title, link with

     

       64
       64
       +
           | Some t, Some l -> Some { title = t; link = l; summary; published; author }

     

       65
       65
       +
           | _ -> None

     

       66
       66
       +
       

     

       67
       67
       +
         let parse_feed xml =

     

       68
       68
       +
           (* Very basic XML parsing - in production, use a proper XML library *)

     

       69
       69
       +
           let feed_title = parse_xml_element xml "title" |> Option.value ~default:"Unknown Feed" in

     

       70
       70
       +
       

     

       71
       71
       +
           (* Extract entries between <entry> tags (Atom) or <item> tags (RSS) *)

     

       72
       72
       +
           let entries = ref [] in

     

       73
       73
       +
           let rec extract_entries str pos =

     

       74
       74
       +
             try

     

       75
       75
       +
               let entry_start =

     

       76
       76
       +
                 try String.index_from str pos '<'

     

       77
       77
       +
                 with Not_found -> String.length str

     

       78
       78
       +
               in

     

       79
       79
       +
               if entry_start >= String.length str then ()

     

       80
       80
       +
               else

     

       81
       81
       +
                 let tag_end = String.index_from str entry_start '>' in

     

       82
       82
       +
                 let tag = String.sub str (entry_start + 1) (tag_end - entry_start - 1) in

     

       83
       83
       +
                 if tag = "entry" || tag = "item" then

     

       84
       84
       +
                   let entry_end =

     

       85
       85
       +
                     try String.index_from str tag_end '<'

     

       86
       86
       +
                     with Not_found -> String.length str

     

       87
       87
       +
                   in

     

       88
       88
       +
                   let entry_xml = String.sub str entry_start (entry_end - entry_start) in

     

       89
       89
       +
                   (match parse_entry entry_xml with

     

       90
       90
       +
                    | Some e -> entries := e :: !entries

     

       91
       91
       +
                    | None -> ());

     

       92
       92
       +
                   extract_entries str entry_end

     

       93
       93
       +
                 else

     

       94
       94
       +
                   extract_entries str (tag_end + 1)

     

       95
       95
       +
             with _ -> ()

     

       96
       96
       +
           in

     

       97
       97
       +
           extract_entries xml 0;

     

       98
       98
       +
           { title = feed_title; entries = List.rev !entries }

     

       99
       99
       +
       end

     

       100
       100
       +
       

     

       101
       101
       +
       module Feed_bot = struct

     

       102
       102
       +
         type config = {

     

       103
       103
       +
           feeds : (string * string * string) list;  (* URL, channel, topic *)

     

       104
       104
       +
           refresh_interval : float;  (* seconds *)

     

       105
       105
       +
           state_file : string;

     

       106
       106
       +
         }

     

       107
       107
       +
       

     

       108
       108
       +
         type state = {

     

       109
       109
       +
           last_seen : (string, string) Hashtbl.t;  (* feed_url -> last_entry_id *)

     

       110
       110
       +
         }

     

       111
       111
       +
       

     

       112
       112
       +
         let load_state path =

     

       113
       113
       +
           try

     

       114
       114
       +
             let ic = open_in path in

     

       115
       115
       +
             let state = { last_seen = Hashtbl.create 10 } in

     

       116
       116
       +
             (try

     

       117
       117
       +
               while true do

     

       118
       118
       +
                 let line = input_line ic in

     

       119
       119
       +
                 match String.split_on_char '|' line with

     

       120
       120
       +
                 | [url; id] -> Hashtbl.add state.last_seen url id

     

       121
       121
       +
                 | _ -> ()

     

       122
       122
       +
               done

     

       123
       123
       +
             with End_of_file -> ());

     

       124
       124
       +
             close_in ic;

     

       125
       125
       +
             state

     

       126
       126
       +
           with _ -> { last_seen = Hashtbl.create 10 }

     

       127
       127
       +
       

     

       128
       128
       +
         let save_state path state =

     

       129
       129
       +
           let oc = open_out path in

     

       130
       130
       +
           Hashtbl.iter (fun url id ->

     

       131
       131
       +
             output_string oc (url ^ "|" ^ id ^ "\n")

     

       132
       132
       +
           ) state.last_seen;

     

       133
       133
       +
           close_out oc

     

       134
       134
       +
       

     

       135
       135
       +
         let fetch_feed url =

     

       136
       136
       +
           (* In a real implementation, use an HTTP client to fetch the feed *)

     

       137
       137
       +
           (* For now, return a mock feed *)

     

       138
       138
       +
           Feed_parser.{

     

       139
       139
       +
             title = "Mock Feed";

     

       140
       140
       +
             entries = [

     

       141
       141
       +
               { title = "Test Entry";

     

       142
       142
       +
                 link = "https://example.com/1";

     

       143
       143
       +
                 summary = Some "This is a test entry";

     

       144
       144
       +
                 published = Some "2024-01-01T00:00:00Z";

     

       145
       145
       +
                 author = Some "Test Author" }

     

       146
       146
       +
             ]

     

       147
       147
       +
           }

     

       148
       148
       +
       

     

       149
       149
       +
         let format_entry (entry : Feed_parser.entry) =

     

       150
       150
       +
           let lines = [

     

       151
       151
       +
             Printf.sprintf "**[%s](%s)**" entry.title entry.link;

     

       152
       152
       +
           ] in

     

       153
       153
       +
           let lines = match entry.author with

     

       154
       154
       +
             | Some a -> lines @ [Printf.sprintf "*By %s*" a]

     

       155
       155
       +
             | None -> lines

     

       156
       156
       +
           in

     

       157
       157
       +
           let lines = match entry.published with

     

       158
       158
       +
             | Some p -> lines @ [Printf.sprintf "*Published: %s*" p]

     

       159
       159
       +
             | None -> lines

     

       160
       160
       +
           in

     

       161
       161
       +
           let lines = match entry.summary with

     

       162
       162
       +
             | Some s -> lines @ [""; s]

     

       163
       163
       +
             | None -> lines

     

       164
       164
       +
           in

     

       165
       165
       +
           String.concat "\n" lines

     

       166
       166
       +
       

     

       167
       167
       +
         let post_entry client channel topic entry =

     

       168
       168
       +
           let open Feed_parser in

     

       169
       169
       +
           let message = Zulip.Message.create

     

       170
       170
       +
             ~type_:`Channel

     

       171
       171
       +
             ~to_:[channel]

     

       172
       172
       +
             ~topic

     

       173
       173
       +
             ~content:(format_entry entry)

     

       174
       174
       +
             ()

     

       175
       175
       +
           in

     

       176
       176
       +
           match Zulip.Messages.send client message with

     

       177
       177
       +
           | Ok _ -> Printf.printf "Posted: %s\n" entry.title

     

       178
       178
       +
           | Error e -> Printf.eprintf "Error posting: %s\n" (Zulip.Error.message e)

     

       179
       179
       +
       

     

       180
       180
       +
         let process_feed client state (url, channel, topic) =

     

       181
       181
       +
           Printf.printf "Processing feed: %s -> #%s/%s\n" url channel topic;

     

       182
       182
       +
           let feed = fetch_feed url in

     

       183
       183
       +
       

     

       184
       184
       +
           let last_id = Hashtbl.find_opt state.last_seen url in

     

       185
       185
       +
           let new_entries = match last_id with

     

       186
       186
       +
             | Some id ->

     

       187
       187
       +
                 (* Filter entries newer than last_id *)

     

       188
       188
       +
                 List.filter (fun e ->

     

       189
       189
       +
                   Feed_parser.(e.link <> id)

     

       190
       190
       +
                 ) feed.entries

     

       191
       191
       +
             | None -> feed.entries

     

       192
       192
       +
           in

     

       193
       193
       +
       

     

       194
       194
       +
           (* Post new entries *)

     

       195
       195
       +
           List.iter (post_entry client channel topic) new_entries;

     

       196
       196
       +
       

     

       197
       197
       +
           (* Update last seen *)

     

       198
       198
       +
           match feed.entries with

     

       199
       199
       +
           | h :: _ -> Hashtbl.replace state.last_seen url Feed_parser.(h.link)

     

       200
       200
       +
           | [] -> ()

     

       201
       201
       +
       

     

       202
       202
       +
         let run_bot env config =

     

       203
       203
       +
           (* Load authentication *)

     

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

     

       205
       205
       +
             | Ok a -> a

     

       206
       206
       +
             | Error e ->

     

       207
       207
       +
                 Printf.eprintf "Failed to load auth: %s\n" (Zulip.Error.message e);

     

       208
       208
       +
                 exit 1

     

       209
       209
       +
           in

     

       210
       210
       +
       

     

       211
       211
       +
           (* Create client *)

     

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

     

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

     

       214
       214
       +
       

     

       215
       215
       +
           (* Load state *)

     

       216
       216
       +
           let state = load_state config.state_file in

     

       217
       217
       +
       

     

       218
       218
       +
           (* Main loop *)

     

       219
       219
       +
           let rec loop () =

     

       220
       220
       +
             Printf.printf "Checking feeds...\n";

     

       221
       221
       +
             List.iter (process_feed client state) config.feeds;

     

       222
       222
       +
             save_state config.state_file state;

     

       223
       223
       +
       

     

       224
       224
       +
             Printf.printf "Sleeping for %.0f seconds...\n" config.refresh_interval;

     

       225
       225
       +
             Eio.Time.sleep (Eio.Stdenv.clock env) config.refresh_interval;

     

       226
       226
       +
             loop ()

     

       227
       227
       +
           in

     

       228
       228
       +
           loop ()

     

       229
       229
       +
       end

     

       230
       230
       +
       

     

       231
       231
       +
       (* Interactive bot that responds to commands *)

     

       232
       232
       +
       module Interactive_feed_bot = struct

     

       233
       233
       +
         open Zulip_bot

     

       234
       234
       +
       

     

       235
       235
       +
         type t = {

     

       236
       236
       +
           feeds : (string, string * string) Hashtbl.t;  (* name -> (url, topic) *)

     

       237
       237
       +
           mutable default_channel : string;

     

       238
       238
       +
         }

     

       239
       239
       +
       

     

       240
       240
       +
         let create () = {

     

       241
       241
       +
           feeds = Hashtbl.create 10;

     

       242
       242
       +
           default_channel = "general";

     

       243
       243
       +
         }

     

       244
       244
       +
       

     

       245
       245
       +
         let handle_command bot_state command args =

     

       246
       246
       +
           match command with

     

       247
       247
       +
           | "add" ->

     

       248
       248
       +
               (match args with

     

       249
       249
       +
                | name :: url :: topic ->

     

       250
       250
       +
                    let topic_str = String.concat " " topic in

     

       251
       251
       +
                    Hashtbl.replace bot_state.feeds name (url, topic_str);

     

       252
       252
       +
                    Printf.sprintf "Added feed '%s' -> %s (topic: %s)" name url topic_str

     

       253
       253
       +
                | _ -> "Usage: !feed add <name> <url> <topic>")

     

       254
       254
       +
       

     

       255
       255
       +
           | "remove" ->

     

       256
       256
       +
               (match args with

     

       257
       257
       +
                | name :: _ ->

     

       258
       258
       +
                    if Hashtbl.mem bot_state.feeds name then (

     

       259
       259
       +
                      Hashtbl.remove bot_state.feeds name;

     

       260
       260
       +
                      Printf.sprintf "Removed feed '%s'" name

     

       261
       261
       +
                    ) else

     

       262
       262
       +
                      Printf.sprintf "Feed '%s' not found" name

     

       263
       263
       +
                | _ -> "Usage: !feed remove <name>")

     

       264
       264
       +
       

     

       265
       265
       +
           | "list" ->

     

       266
       266
       +
               if Hashtbl.length bot_state.feeds = 0 then

     

       267
       267
       +
                 "No feeds configured"

     

       268
       268
       +
               else

     

       269
       269
       +
                 let lines = Hashtbl.fold (fun name (url, topic) acc ->

     

       270
       270
       +
                   (Printf.sprintf "• **%s**: %s → topic: %s" name url topic) :: acc

     

       271
       271
       +
                 ) bot_state.feeds [] in

     

       272
       272
       +
                 String.concat "\n" lines

     

       273
       273
       +
       

     

       274
       274
       +
           | "fetch" ->

     

       275
       275
       +
               (match args with

     

       276
       276
       +
                | name :: _ ->

     

       277
       277
       +
                    (match Hashtbl.find_opt bot_state.feeds name with

     

       278
       278
       +
                     | Some (url, topic) ->

     

       279
       279
       +
                         Printf.sprintf "Fetching feed '%s' from %s..." name url

     

       280
       280
       +
                     | None ->

     

       281
       281
       +
                         Printf.sprintf "Feed '%s' not found" name)

     

       282
       282
       +
                | _ -> "Usage: !feed fetch <name>")

     

       283
       283
       +
       

     

       284
       284
       +
           | "channel" ->

     

       285
       285
       +
               (match args with

     

       286
       286
       +
                | channel :: _ ->

     

       287
       287
       +
                    bot_state.default_channel <- channel;

     

       288
       288
       +
                    Printf.sprintf "Default channel set to: %s" channel

     

       289
       289
       +
                | _ -> Printf.sprintf "Current default channel: %s" bot_state.default_channel)

     

       290
       290
       +
       

     

       291
       291
       +
           | "help" | _ ->

     

       292
       292
       +
               String.concat "\n" [

     

       293
       293
       +
                 "**Atom Feed Bot Commands:**";

     

       294
       294
       +
                 "• `!feed add <name> <url> <topic>` - Add a new feed";

     

       295
       295
       +
                 "• `!feed remove <name>` - Remove a feed";

     

       296
       296
       +
                 "• `!feed list` - List all configured feeds";

     

       297
       297
       +
                 "• `!feed fetch <name>` - Manually fetch a feed";

     

       298
       298
       +
                 "• `!feed channel <name>` - Set default channel";

     

       299
       299
       +
                 "• `!feed help` - Show this help message";

     

       300
       300
       +
               ]

     

       301
       301
       +
       

     

       302
       302
       +
         let create_handler bot_state =

     

       303
       303
       +
           let module Handler : Bot_handler.S = struct

     

       304
       304
       +
             let initialize _ = Ok ()

     

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

     

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

     

       307
       307
       +
       

     

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

     

       309
       309
       +
               (* Parse message content *)

     

       310
       310
       +
               let content = match message with

     

       311
       311
       +
                 | `O fields ->

     

       312
       312
       +
                     (match List.assoc_opt "content" fields with

     

       313
       313
       +
                      | Some (`String s) -> s

     

       314
       314
       +
                      | _ -> "")

     

       315
       315
       +
                 | _ -> ""

     

       316
       316
       +
               in

     

       317
       317
       +
       

     

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

     

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

     

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

     

       321
       321
       +
                 match parts with

     

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

     

       323
       323
       +
                     let response = handle_command bot_state command args in

     

       324
       324
       +
                     Ok (Bot_handler.Response.reply response)

     

       325
       325
       +
                 | _ ->

     

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

     

       327
       327
       +
                     Ok (Bot_handler.Response.reply response)

     

       328
       328
       +
               else

     

       329
       329
       +
                 Ok Bot_handler.Response.none

     

       330
       330
       +
           end in

     

       331
       331
       +
           (module Handler : Bot_handler.S)

     

       332
       332
       +
       end

     

       333
       333
       +
       

     

       334
       334
       +
       (* Main entry point *)

     

       335
       335
       +
       let () =

     

       336
       336
       +
         if Array.length Sys.argv > 1 && Sys.argv.(1) = "interactive" then (

     

       337
       337
       +
           (* Run as interactive bot *)

     

       338
       338
       +
           Printf.printf "Starting interactive Atom feed bot...\n";

     

       339
       339
       +
           Eio_main.run @@ fun env ->

     

       340
       340
       +
       

     

       341
       341
       +
           let bot_state = Interactive_feed_bot.create () in

     

       342
       342
       +
           let handler = Interactive_feed_bot.create_handler bot_state in

     

       343
       343
       +
       

     

       344
       344
       +
           (* Load auth and create bot runner *)

     

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

     

       346
       346
       +
             | Ok a -> a

     

       347
       347
       +
             | Error e ->

     

       348
       348
       +
                 Printf.eprintf "Failed to load auth: %s\n" (Zulip.Error.message e);

     

       349
       349
       +
                 exit 1

     

       350
       350
       +
           in

     

       351
       351
       +
       

     

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

     

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

     

       354
       354
       +
       

     

       355
       355
       +
           (* Create and run bot *)

     

       356
       356
       +
           let config = Zulip_bot.Bot_config.create [] in

     

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

     

       358
       358
       +
           let storage = Zulip_bot.Bot_storage.create client ~bot_email in

     

       359
       359
       +
           let identity = Zulip_bot.Bot_handler.Identity.create

     

       360
       360
       +
             ~full_name:"Atom Feed Bot"

     

       361
       361
       +
             ~email:bot_email

     

       362
       362
       +
             ~mention_name:"feedbot"

     

       363
       363
       +
           in

     

       364
       364
       +
       

     

       365
       365
       +
           let bot = Zulip_bot.Bot_handler.create handler ~config ~storage ~identity in

     

       366
       366
       +
           let runner = Zulip_bot.Bot_runner.create ~env ~client ~handler:bot in

     

       367
       367
       +
           Zulip_bot.Bot_runner.run_realtime runner

     

       368
       368
       +
         ) else (

     

       369
       369
       +
           (* Run as scheduled fetcher *)

     

       370
       370
       +
           Printf.printf "Starting scheduled Atom feed fetcher...\n";

     

       371
       371
       +
           Eio_main.run @@ fun env ->

     

       372
       372
       +
       

     

       373
       373
       +
           let config = Feed_bot.{

     

       374
       374
       +
             feeds = [

     

       375
       375
       +
               ("https://example.com/feed.xml", "general", "News");

     

       376
       376
       +
               ("https://blog.example.com/atom.xml", "general", "Blog Posts");

     

       377
       377
       +
             ];

     

       378
       378
       +
             refresh_interval = 300.0;  (* 5 minutes *)

     

       379
       379
       +
             state_file = "feed_bot_state.txt";

     

       380
       380
       +
           } in

     

       381
       381
       +
       

     

       382
       382
       +
           Feed_bot.run_bot env config

     

       383
       383
       +
         )

+20

stack/zulip/examples/bot_config.toml

···

       1
       1
       +
       [weather_bot]

     

       2
       2
       +
       name = "Weather Bot"

     

       3
       3
       +
       default_api_key = "openweather-api-key-12345"

     

       4
       4
       +
       log_level = "info"

     

       5
       5
       +
       cache_duration_minutes = 30

     

       6
       6
       +
       log_file = "/tmp/weather_bot.log"

     

       7
       7
       +
       config_dir = "/tmp/bot_config"

     

       8
       8
       +
       

     

       9
       9
       +
       [logger_bot]

     

       10
       10
       +
       name = "Logger Bot" 

     

       11
       11
       +
       log_file = "/tmp/user_messages.log"

     

       12
       12
       +
       max_log_size_mb = 10

     

       13
       13
       +
       archive_logs = true

     

       14
       14
       +
       log_format = "json"

     

       15
       15
       +
       

     

       16
       16
       +
       [general]

     

       17
       17
       +
       server_url = "https://company.zulipchat.com"

     

       18
       18
       +
       webhook_port = 8080

     

       19
       19
       +
       max_message_length = 2000

     

       20
       20
       +
       rate_limit_per_minute = 60

+44

stack/zulip/examples/bot_example.ml

···

       1
       1
       +
       (* Simple Bot Example using core Zulip library *)

     

       2
       2
       +
       

     

       3
       3
       +
       let () =

     

       4
       4
       +
         Printf.printf "OCaml Zulip Bot Example\n";

     

       5
       5
       +
         Printf.printf "=======================\n\n";

     

       6
       6
       +
         

     

       7
       7
       +
         (* Create test authentication *)

     

       8
       8
       +
         let auth = Zulip.Auth.create 

     

       9
       9
       +
           ~server_url:"https://example.zulipchat.com"

     

       10
       10
       +
           ~email:"bot@example.com" 

     

       11
       11
       +
           ~api_key:"example-api-key" in

     

       12
       12
       +
         

     

       13
       13
       +
         Printf.printf "✅ Created authentication for: %s\n" (Zulip.Auth.email auth);

     

       14
       14
       +
         Printf.printf "✅ Server URL: %s\n" (Zulip.Auth.server_url auth);

     

       15
       15
       +
         

     

       16
       16
       +
         (* Create client *)

     

       17
       17
       +
         let client = Zulip.Client.create () auth in

     

       18
       18
       +
         let client_str = Format.asprintf "%a" Zulip.Client.pp client in

     

       19
       19
       +
         Printf.printf "✅ Created client: %s\n" client_str;

     

       20
       20
       +
         

     

       21
       21
       +
         (* Test message creation *)

     

       22
       22
       +
         let message = Zulip.Message.create

     

       23
       23
       +
           ~type_:`Channel

     

       24
       24
       +
           ~to_:["general"]

     

       25
       25
       +
           ~content:"Hello from OCaml bot!"

     

       26
       26
       +
           ~topic:"Bot Testing"

     

       27
       27
       +
           () in

     

       28
       28
       +
         

     

       29
       29
       +
         Printf.printf "✅ Created message to: %s\n" (String.concat ", " (Zulip.Message.to_ message));

     

       30
       30
       +
         Printf.printf "✅ Message content: %s\n" (Zulip.Message.content message);

     

       31
       31
       +
         Printf.printf "✅ Message topic: %s\n" (match Zulip.Message.topic message with Some t -> t | None -> "none");

     

       32
       32
       +
         

     

       33
       33
       +
         (* Test API call (mock) *)

     

       34
       34
       +
         (match Zulip.Client.request client ~method_:`GET ~path:"/users/me" () with

     

       35
       35
       +
          | Ok response ->

     

       36
       36
       +
              Printf.printf "✅ API request successful: %s\n" 

     

       37
       37
       +
                (match response with 

     

       38
       38
       +
                 | `O fields -> String.concat ", " (List.map fst fields)

     

       39
       39
       +
                 | _ -> "unknown format")

     

       40
       40
       +
          | Error err ->

     

       41
       41
       +
              Printf.printf "❌ API request failed: %s\n" (Zulip.Error.message err));

     

       42
       42
       +
         

     

       43
       43
       +
         Printf.printf "\n🎉 Bot example completed successfully!\n";

     

       44
       44
       +
         Printf.printf "Note: This uses mock responses since we're not connected to a real Zulip server.\n"

stack/zulip/examples/bot_example.mli

···

       1
       1
       +
       (** Example Zulip bot demonstrating the bot framework *)

+17

stack/zulip/examples/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (public_name test_client)

     

       3
       3
       +
        (name test_client)

     

       4
       4
       +
        (package zulip)

     

       5
       5
       +
        (libraries zulip eio_main))

     

       6
       6
       +
       

     

       7
       7
       +
       (executable

     

       8
       8
       +
        (public_name echo_bot)

     

       9
       9
       +
        (name echo_bot)

     

       10
       10
       +
        (package zulip_bot)

     

       11
       11
       +
        (libraries zulip zulip_bot eio_main))

     

       12
       12
       +
       

     

       13
       13
       +
       (executable

     

       14
       14
       +
        (public_name atom_feed_bot)

     

       15
       15
       +
        (name atom_feed_bot)

     

       16
       16
       +
        (package zulip_bot)

     

       17
       17
       +
        (libraries zulip zulip_bot eio_main))

+142

stack/zulip/examples/echo_bot.ml

···

       1
       1
       +
       (* Simple Echo Bot for Zulip

     

       2
       2
       +
          Responds to direct messages and mentions by echoing back the message *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Zulip_bot

     

       5
       5
       +
       

     

       6
       6
       +
       module Echo_bot_handler : Bot_handler.S = struct

     

       7
       7
       +
         let initialize _ = Ok ()

     

       8
       8
       +
       

     

       9
       9
       +
         let usage () =

     

       10
       10
       +
           "Echo Bot - I repeat everything you say to me!"

     

       11
       11
       +
       

     

       12
       12
       +
         let description () =

     

       13
       13
       +
           "A simple echo bot that repeats messages sent to it. \

     

       14
       14
       +
            Send me a direct message or mention me in a channel."

     

       15
       15
       +
       

     

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

     

       17
       17
       +
           (* Parse the incoming message *)

     

       18
       18
       +
           let extract_field fields name =

     

       19
       19
       +
             match List.assoc_opt name fields with

     

       20
       20
       +
             | Some (`String s) -> Some s

     

       21
       21
       +
             | _ -> None

     

       22
       22
       +
           in

     

       23
       23
       +
       

     

       24
       24
       +
           let extract_int_field fields name =

     

       25
       25
       +
             match List.assoc_opt name fields with

     

       26
       26
       +
             | Some (`Float f) -> Some (int_of_float f)

     

       27
       27
       +
             | _ -> None

     

       28
       28
       +
           in

     

       29
       29
       +
       

     

       30
       30
       +
           match message with

     

       31
       31
       +
           | `O fields ->

     

       32
       32
       +
               (* Extract message details *)

     

       33
       33
       +
               let content = extract_field fields "content" in

     

       34
       34
       +
               let sender_email = extract_field fields "sender_email" in

     

       35
       35
       +
               let sender_full_name = extract_field fields "sender_full_name" in

     

       36
       36
       +
               let message_type = extract_field fields "type" in

     

       37
       37
       +
               let _sender_id = extract_int_field fields "sender_id" in

     

       38
       38
       +
       

     

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

     

       40
       40
       +
               let is_own_message = match sender_email with

     

       41
       41
       +
                 | Some email -> email = (Bot_handler.Identity.email identity)

     

       42
       42
       +
                 | None -> false

     

       43
       43
       +
               in

     

       44
       44
       +
       

     

       45
       45
       +
               if is_own_message then

     

       46
       46
       +
                 Ok Bot_handler.Response.None

     

       47
       47
       +
               else

     

       48
       48
       +
                 (* Process the message content *)

     

       49
       49
       +
                 let response_content = match content, sender_full_name with

     

       50
       50
       +
                   | Some msg, Some name ->

     

       51
       51
       +
                       (* Remove bot mention if present *)

     

       52
       52
       +
                       let cleaned_msg =

     

       53
       53
       +
                         let mention = "@**" ^ Bot_handler.Identity.mention_name identity ^ "**" in

     

       54
       54
       +
                         let msg =

     

       55
       55
       +
                           if String.starts_with ~prefix:mention msg then

     

       56
       56
       +
                             String.sub msg (String.length mention) (String.length msg - String.length mention)

     

       57
       57
       +
                           else msg

     

       58
       58
       +
                         in

     

       59
       59
       +
                         String.trim msg

     

       60
       60
       +
                       in

     

       61
       61
       +
       

     

       62
       62
       +
                       (* Create echo response *)

     

       63
       63
       +
                       if cleaned_msg = "" then

     

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

     

       65
       65
       +
                       else if String.lowercase_ascii cleaned_msg = "help" then

     

       66
       66
       +
                         Printf.sprintf "Hi %s! I'm an echo bot. Whatever you say to me, I'll repeat back. \

     

       67
       67
       +
                                         Try sending me any message!" name

     

       68
       68
       +
                       else

     

       69
       69
       +
                         Printf.sprintf "Echo from %s: %s" name cleaned_msg

     

       70
       70
       +
                   | Some msg, None ->

     

       71
       71
       +
                       Printf.sprintf "Echo: %s" msg

     

       72
       72
       +
                   | _ ->

     

       73
       73
       +
                       "I couldn't understand that message."

     

       74
       74
       +
                 in

     

       75
       75
       +
       

     

       76
       76
       +
                 (* Determine response type based on original message type *)

     

       77
       77
       +
                 let response = match message_type with

     

       78
       78
       +
                   | Some "private" ->

     

       79
       79
       +
                       (* For private messages, reply directly *)

     

       80
       80
       +
                       Bot_handler.Response.Reply response_content

     

       81
       81
       +
                   | Some "stream" ->

     

       82
       82
       +
                       (* For stream messages, reply in the same topic *)

     

       83
       83
       +
                       Bot_handler.Response.Reply response_content

     

       84
       84
       +
                   | _ ->

     

       85
       85
       +
                       Bot_handler.Response.None

     

       86
       86
       +
                 in

     

       87
       87
       +
       

     

       88
       88
       +
                 Ok response

     

       89
       89
       +
           | _ ->

     

       90
       90
       +
               Ok Bot_handler.Response.None

     

       91
       91
       +
       end

     

       92
       92
       +
       

     

       93
       93
       +
       let run_echo_bot env =

     

       94
       94
       +
         Printf.printf "Starting Zulip Echo Bot...\n";

     

       95
       95
       +
         Printf.printf "=============================\n\n";

     

       96
       96
       +
       

     

       97
       97
       +
         (* Load authentication from .zuliprc file *)

     

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

     

       99
       99
       +
           | Ok a ->

     

       100
       100
       +
               Printf.printf "Loaded authentication for: %s\n" (Zulip.Auth.email a);

     

       101
       101
       +
               Printf.printf "Server: %s\n\n" (Zulip.Auth.server_url a);

     

       102
       102
       +
               a

     

       103
       103
       +
           | Error e ->

     

       104
       104
       +
               Printf.eprintf "Failed to load .zuliprc: %s\n" (Zulip.Error.message e);

     

       105
       105
       +
               Printf.eprintf "\nPlease create a ~/.zuliprc file with:\n";

     

       106
       106
       +
               Printf.eprintf "[api]\n";

     

       107
       107
       +
               Printf.eprintf "email=bot@example.com\n";

     

       108
       108
       +
               Printf.eprintf "key=your-api-key\n";

     

       109
       109
       +
               Printf.eprintf "site=https://your-domain.zulipchat.com\n";

     

       110
       110
       +
               exit 1

     

       111
       111
       +
         in

     

       112
       112
       +
       

     

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

     

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

     

       115
       115
       +
       

     

       116
       116
       +
         (* Create bot configuration *)

     

       117
       117
       +
         let config = Bot_config.create [] in

     

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

     

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

     

       120
       120
       +
         let identity = Bot_handler.Identity.create

     

       121
       121
       +
           ~full_name:"Echo Bot"

     

       122
       122
       +
           ~email:bot_email

     

       123
       123
       +
           ~mention_name:"echobot"

     

       124
       124
       +
         in

     

       125
       125
       +
       

     

       126
       126
       +
         (* Create and run the bot *)

     

       127
       127
       +
         let handler = Bot_handler.create

     

       128
       128
       +
           (module Echo_bot_handler)

     

       129
       129
       +
           ~config ~storage ~identity

     

       130
       130
       +
         in

     

       131
       131
       +
       

     

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

     

       133
       133
       +
       

     

       134
       134
       +
         Printf.printf "Echo bot is running!\n";

     

       135
       135
       +
         Printf.printf "Send a direct message or mention @echobot in a channel.\n";

     

       136
       136
       +
         Printf.printf "Press Ctrl+C to stop.\n\n";

     

       137
       137
       +
       

     

       138
       138
       +
         (* Run in real-time mode *)

     

       139
       139
       +
         Bot_runner.run_realtime runner

     

       140
       140
       +
       

     

       141
       141
       +
       let () =

     

       142
       142
       +
         Eio_main.run run_echo_bot

+47

stack/zulip/examples/example.ml

···

       1
       1
       +
       open Zulip

     

       2
       2
       +
       

     

       3
       3
       +
       let () =

     

       4
       4
       +
         Printf.printf "OCaml Zulip Library Example\n";

     

       5
       5
       +
         Printf.printf "===========================\n\n";

     

       6
       6
       +
         

     

       7
       7
       +
         (* Create authentication *)

     

       8
       8
       +
         let auth = Auth.create 

     

       9
       9
       +
           ~server_url:"https://example.zulipchat.com"

     

       10
       10
       +
           ~email:"bot@example.com" 

     

       11
       11
       +
           ~api_key:"your-api-key" in

     

       12
       12
       +
         

     

       13
       13
       +
         Printf.printf "Created auth for: %s\n" (Auth.email auth);

     

       14
       14
       +
         Printf.printf "Server URL: %s\n" (Auth.server_url auth);

     

       15
       15
       +
         

     

       16
       16
       +
         (* Create a message *)

     

       17
       17
       +
         let message = Message.create 

     

       18
       18
       +
           ~type_:`Channel

     

       19
       19
       +
           ~to_:["general"]

     

       20
       20
       +
           ~content:"Hello from OCaml Zulip library!"

     

       21
       21
       +
           ~topic:"Test"

     

       22
       22
       +
           () in

     

       23
       23
       +
         

     

       24
       24
       +
         Printf.printf "\nCreated message:\n";

     

       25
       25
       +
         Printf.printf "- Type: %s\n" (Message_type.to_string (Message.type_ message));

     

       26
       26
       +
         Printf.printf "- To: %s\n" (String.concat ", " (Message.to_ message));

     

       27
       27
       +
         Printf.printf "- Content: %s\n" (Message.content message);

     

       28
       28
       +
         Printf.printf "- Topic: %s\n" 

     

       29
       29
       +
           (match Message.topic message with Some t -> t | None -> "None");

     

       30
       30
       +
         

     

       31
       31
       +
         (* Test JSON serialization *)

     

       32
       32
       +
         let json = Message.to_json message in

     

       33
       33
       +
         Printf.printf "\nMessage JSON: %s\n" 

     

       34
       34
       +
           (match json with 

     

       35
       35
       +
            | `O _ -> "JSON object (serialized correctly)" 

     

       36
       36
       +
            | _ -> "Invalid JSON");

     

       37
       37
       +
         

     

       38
       38
       +
         (* Create client (mock) *)

     

       39
       39
       +
         let client = Client.create () auth in

     

       40
       40
       +
         Printf.printf "\nCreated mock client\n";

     

       41
       41
       +
         

     

       42
       42
       +
         (* Test basic client request *)

     

       43
       43
       +
         (match Client.request client ~method_:`GET ~path:"/test" () with

     

       44
       44
       +
          | Ok _ -> Printf.printf "Mock request succeeded\n"

     

       45
       45
       +
          | Error err -> Printf.printf "Mock request failed: %s\n" (Error.message err));

     

       46
       46
       +
         

     

       47
       47
       +
         Printf.printf "\nLibrary is working correctly!\n"

stack/zulip/examples/example.mli

···

       1
       1
       +
       (** Basic Zulip library usage example *)

+16

stack/zulip/examples/example_bot_config.toml

···

       1
       1
       +
       # Bot configuration file

     

       2
       2
       +
       name = "Weather Bot"

     

       3
       3
       +
       description = "A bot that provides weather information"

     

       4
       4
       +
       

     

       5
       5
       +
       [bot]

     

       6
       6
       +
       # Bot-specific settings

     

       7
       7
       +
       api_key = "your-weather-api-key"

     

       8
       8
       +
       default_location = "San Francisco"

     

       9
       9
       +
       units = "metric"

     

       10
       10
       +
       max_forecasts = 5

     

       11
       11
       +
       

     

       12
       12
       +
       [features]

     

       13
       13
       +
       # Feature flags

     

       14
       14
       +
       cache_enabled = true

     

       15
       15
       +
       verbose_logging = false

     

       16
       16
       +
       rate_limit = 60

stack/zulip/examples/example_zuliprc.toml

···

       1
       1
       +
       # Zulip configuration file in TOML format

     

       2
       2
       +
       [api]

     

       3
       3
       +
       email = "bot@example.com"

     

       4
       4
       +
       key = "your-api-key-here"

     

       5
       5
       +
       site = "https://example.zulipchat.com"

     

       6
       6
       +
       

     

       7
       7
       +
       # Optional settings

     

       8
       8
       +
       insecure = false

     

       9
       9
       +
       cert_bundle = "/path/to/cert/bundle.crt"

+75

stack/zulip/examples/test_client.ml

···

       1
       1
       +
       (* Simple test for Zulip client with requests library *)

     

       2
       2
       +
       

     

       3
       3
       +
       let test_auth () =

     

       4
       4
       +
         Printf.printf "Testing Zulip authentication...\n";

     

       5
       5
       +
         match Zulip.Auth.from_zuliprc ~path:"~/.zuliprc" () with

     

       6
       6
       +
         | Ok auth ->

     

       7
       7
       +
             Printf.printf "Successfully loaded auth:\n";

     

       8
       8
       +
             Printf.printf "  Server: %s\n" (Zulip.Auth.server_url auth);

     

       9
       9
       +
             Printf.printf "  Email: %s\n" (Zulip.Auth.email auth);

     

       10
       10
       +
             auth

     

       11
       11
       +
         | Error e ->

     

       12
       12
       +
             Printf.eprintf "Failed to load auth: %s\n" (Zulip.Error.message e);

     

       13
       13
       +
             (* Create a test auth *)

     

       14
       14
       +
             Zulip.Auth.create

     

       15
       15
       +
               ~server_url:"https://example.zulipchat.com"

     

       16
       16
       +
               ~email:"bot@example.com"

     

       17
       17
       +
               ~api_key:"test_api_key"

     

       18
       18
       +
       

     

       19
       19
       +
       let test_message_send env auth =

     

       20
       20
       +
         Printf.printf "\nTesting message send...\n";

     

       21
       21
       +
       

     

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

     

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

     

       24
       24
       +
       

     

       25
       25
       +
         (* Create a test message *)

     

       26
       26
       +
         let message = Zulip.Message.create

     

       27
       27
       +
           ~type_:`Channel

     

       28
       28
       +
           ~to_:["general"]

     

       29
       29
       +
           ~topic:"Test Topic"

     

       30
       30
       +
           ~content:"Hello from OCaml Zulip client using requests library!"

     

       31
       31
       +
           ()

     

       32
       32
       +
         in

     

       33
       33
       +
       

     

       34
       34
       +
         match Zulip.Messages.send client message with

     

       35
       35
       +
         | Ok response ->

     

       36
       36
       +
             Printf.printf "Message sent successfully!\n";

     

       37
       37
       +
             Printf.printf "Message ID: %d\n" (Zulip.Message_response.id response)

     

       38
       38
       +
         | Error e ->

     

       39
       39
       +
             Printf.eprintf "Failed to send message: %s\n" (Zulip.Error.message e)

     

       40
       40
       +
       

     

       41
       41
       +
       let test_fetch_messages env auth =

     

       42
       42
       +
         Printf.printf "\nTesting message fetch...\n";

     

       43
       43
       +
       

     

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

     

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

     

       46
       46
       +
       

     

       47
       47
       +
         match Zulip.Messages.get_messages client ~num_before:5 ~num_after:0 () with

     

       48
       48
       +
         | Ok json ->

     

       49
       49
       +
             Printf.printf "Fetched messages successfully!\n";

     

       50
       50
       +
             (match json with

     

       51
       51
       +
              | `O fields ->

     

       52
       52
       +
                  (match List.assoc_opt "messages" fields with

     

       53
       53
       +
                   | Some (`A messages) ->

     

       54
       54
       +
                       Printf.printf "Got %d messages\n" (List.length messages)

     

       55
       55
       +
                   | _ -> Printf.printf "No messages field found\n")

     

       56
       56
       +
              | _ -> Printf.printf "Unexpected JSON format\n")

     

       57
       57
       +
         | Error e ->

     

       58
       58
       +
             Printf.eprintf "Failed to fetch messages: %s\n" (Zulip.Error.message e)

     

       59
       59
       +
       

     

       60
       60
       +
       let () =

     

       61
       61
       +
         Printf.printf "Zulip OCaml Client Test\n";

     

       62
       62
       +
         Printf.printf "========================\n\n";

     

       63
       63
       +
       

     

       64
       64
       +
         Eio_main.run @@ fun env ->

     

       65
       65
       +
       

     

       66
       66
       +
         (* Test authentication *)

     

       67
       67
       +
         let auth = test_auth () in

     

       68
       68
       +
       

     

       69
       69
       +
         (* Test sending a message *)

     

       70
       70
       +
         test_message_send env auth;

     

       71
       71
       +
       

     

       72
       72
       +
         (* Test fetching messages *)

     

       73
       73
       +
         test_fetch_messages env auth;

     

       74
       74
       +
       

     

       75
       75
       +
         Printf.printf "\nAll tests completed!\n"

+100

stack/zulip/examples/toml_example.ml

···

       1
       1
       +
       open Zulip

     

       2
       2
       +
       

     

       3
       3
       +
       let () =

     

       4
       4
       +
         Printf.printf "OCaml Zulip TOML Support Demo\n";

     

       5
       5
       +
         Printf.printf "=============================\n\n";

     

       6
       6
       +
         

     

       7
       7
       +
         (* Example 1: Create a sample zuliprc TOML file *)

     

       8
       8
       +
         let zuliprc_content = {|

     

       9
       9
       +
       # Zulip API Configuration

     

       10
       10
       +
       [api]

     

       11
       11
       +
       email = "demo@example.com"

     

       12
       12
       +
       key = "demo-api-key-12345"

     

       13
       13
       +
       site = "https://demo.zulipchat.com"

     

       14
       14
       +
       

     

       15
       15
       +
       # Optional settings

     

       16
       16
       +
       insecure = false

     

       17
       17
       +
       cert_bundle = "/etc/ssl/certs/ca-certificates.crt"

     

       18
       18
       +
       |} in

     

       19
       19
       +
         

     

       20
       20
       +
         let zuliprc_file = "demo_zuliprc.toml" in

     

       21
       21
       +
         let oc = open_out zuliprc_file in

     

       22
       22
       +
         output_string oc zuliprc_content;

     

       23
       23
       +
         close_out oc;

     

       24
       24
       +
         

     

       25
       25
       +
         Printf.printf "Created sample zuliprc.toml file:\n%s\n" zuliprc_content;

     

       26
       26
       +
         

     

       27
       27
       +
         (* Test loading auth from TOML *)

     

       28
       28
       +
         (match Auth.from_zuliprc ~path:zuliprc_file () with

     

       29
       29
       +
          | Ok auth ->

     

       30
       30
       +
              Printf.printf "✅ Successfully loaded authentication from TOML:\n";

     

       31
       31
       +
              Printf.printf "   Email: %s\n" (Auth.email auth);

     

       32
       32
       +
              Printf.printf "   Server: %s\n" (Auth.server_url auth);

     

       33
       33
       +
              Printf.printf "   Auth Header: %s\n" (Auth.to_basic_auth_header auth);

     

       34
       34
       +
              

     

       35
       35
       +
              (* Test creating client *)

     

       36
       36
       +
              let client = Client.create () auth in

     

       37
       37
       +
              Printf.printf "✅ Created client successfully\n\n";

     

       38
       38
       +
              

     

       39
       39
       +
              (* Test basic functionality *)

     

       40
       40
       +
              (match Client.request client ~method_:`GET ~path:"/users/me" () with

     

       41
       41
       +
               | Ok _response -> Printf.printf "✅ Mock API request succeeded\n"

     

       42
       42
       +
               | Error err -> Printf.printf "❌ API request failed: %s\n" (Error.message err))

     

       43
       43
       +
          | Error err ->

     

       44
       44
       +
              Printf.printf "❌ Failed to load auth from TOML: %s\n" (Error.message err));

     

       45
       45
       +
         

     

       46
       46
       +
         (* Example 2: Root-level TOML configuration *)

     

       47
       47
       +
         let root_toml_content = {|

     

       48
       48
       +
       email = "root-user@example.com"

     

       49
       49
       +
       key = "root-api-key-67890"

     

       50
       50
       +
       site = "https://root.zulipchat.com"

     

       51
       51
       +
       |} in

     

       52
       52
       +
         

     

       53
       53
       +
         let root_file = "demo_root.toml" in

     

       54
       54
       +
         let oc = open_out root_file in

     

       55
       55
       +
         output_string oc root_toml_content;

     

       56
       56
       +
         close_out oc;

     

       57
       57
       +
         

     

       58
       58
       +
         Printf.printf "\nTesting root-level TOML configuration:\n";

     

       59
       59
       +
         (match Auth.from_zuliprc ~path:root_file () with

     

       60
       60
       +
          | Ok auth ->

     

       61
       61
       +
              Printf.printf "✅ Root-level TOML parsed successfully:\n";

     

       62
       62
       +
              Printf.printf "   Email: %s\n" (Auth.email auth);

     

       63
       63
       +
              Printf.printf "   Server: %s\n" (Auth.server_url auth)

     

       64
       64
       +
          | Error err ->

     

       65
       65
       +
              Printf.printf "❌ Failed to parse root-level TOML: %s\n" (Error.message err));

     

       66
       66
       +
         

     

       67
       67
       +
         (* Example 3: Test error handling with invalid TOML *)

     

       68
       68
       +
         let invalid_toml = {|

     

       69
       69
       +
       [api

     

       70
       70
       +
       email = "invalid@example.com"  # Missing closing bracket

     

       71
       71
       +
       |} in

     

       72
       72
       +
         

     

       73
       73
       +
         let invalid_file = "demo_invalid.toml" in

     

       74
       74
       +
         let oc = open_out invalid_file in

     

       75
       75
       +
         output_string oc invalid_toml;

     

       76
       76
       +
         close_out oc;

     

       77
       77
       +
         

     

       78
       78
       +
         Printf.printf "\nTesting error handling with invalid TOML:\n";

     

       79
       79
       +
         (match Auth.from_zuliprc ~path:invalid_file () with

     

       80
       80
       +
          | Ok _ -> Printf.printf "❌ Should have failed with invalid TOML\n"

     

       81
       81
       +
          | Error err -> Printf.printf "✅ Correctly handled invalid TOML: %s\n" (Error.message err));

     

       82
       82
       +
         

     

       83
       83
       +
         (* Example 4: Test missing file handling *)

     

       84
       84
       +
         Printf.printf "\nTesting missing file handling:\n";

     

       85
       85
       +
         (match Auth.from_zuliprc ~path:"nonexistent.toml" () with

     

       86
       86
       +
          | Ok _ -> Printf.printf "❌ Should have failed with missing file\n"

     

       87
       87
       +
          | Error err -> Printf.printf "✅ Correctly handled missing file: %s\n" (Error.message err));

     

       88
       88
       +
         

     

       89
       89
       +
         (* Clean up *)

     

       90
       90
       +
         List.iter (fun file ->

     

       91
       91
       +
           if Sys.file_exists file then Sys.remove file

     

       92
       92
       +
         ) [zuliprc_file; root_file; invalid_file];

     

       93
       93
       +
         

     

       94
       94
       +
         Printf.printf "\n🎉 TOML support demonstration complete!\n";

     

       95
       95
       +
         Printf.printf "\nFeatures demonstrated:\n";

     

       96
       96
       +
         Printf.printf "• Parse TOML files with [api] section\n";

     

       97
       97
       +
         Printf.printf "• Parse TOML files with root-level configuration\n";

     

       98
       98
       +
         Printf.printf "• Proper error handling for invalid TOML syntax\n";

     

       99
       99
       +
         Printf.printf "• Proper error handling for missing files\n";

     

       100
       100
       +
         Printf.printf "• Integration with existing Zulip client\n"

stack/zulip/examples/toml_example.mli

···

       1
       1
       +
       (** TOML support demonstration for Zulip configuration files *)

stack/zulip/lib/dune

···

       1
       1
       +
       (dirs zulip zulip_bot zulip_botserver)

+83

stack/zulip/lib/zulip/lib/auth.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         server_url : string;

     

       3
       3
       +
         email : string;

     

       4
       4
       +
         api_key : string;

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       let create ~server_url ~email ~api_key = { server_url; email; api_key }

     

       8
       8
       +
       

     

       9
       9
       +
       let from_zuliprc ?(path = "~/.zuliprc") () =

     

       10
       10
       +
         try

     

       11
       11
       +
           (* Expand ~ to home directory *)

     

       12
       12
       +
           let expanded_path =

     

       13
       13
       +
             if String.length path > 0 && path.[0] = '~' then

     

       14
       14
       +
               let home = try Sys.getenv "HOME" with Not_found -> "" in

     

       15
       15
       +
               home ^ String.sub path 1 (String.length path - 1)

     

       16
       16
       +
             else path in

     

       17
       17
       +
       

     

       18
       18
       +
           (* Read file content *)

     

       19
       19
       +
           let content =

     

       20
       20
       +
             let ic = open_in expanded_path in

     

       21
       21
       +
             let content = really_input_string ic (in_channel_length ic) in

     

       22
       22
       +
             close_in ic;

     

       23
       23
       +
             content in

     

       24
       24
       +
       

     

       25
       25
       +
           (* Simple INI-style parser for zuliprc *)

     

       26
       26
       +
           let lines = String.split_on_char '\n' content in

     

       27
       27
       +
           let config = Hashtbl.create 10 in

     

       28
       28
       +
           let current_section = ref "" in

     

       29
       29
       +
       

     

       30
       30
       +
           List.iter (fun line ->

     

       31
       31
       +
             let line = String.trim line in

     

       32
       32
       +
             if String.length line > 0 && line.[0] <> '#' then

     

       33
       33
       +
               if String.length line > 2 && line.[0] = '[' && line.[String.length line - 1] = ']' then

     

       34
       34
       +
                 (* Section header *)

     

       35
       35
       +
                 current_section := String.sub line 1 (String.length line - 2)

     

       36
       36
       +
               else

     

       37
       37
       +
                 (* Key-value pair *)

     

       38
       38
       +
                 match String.index_opt line '=' with

     

       39
       39
       +
                 | Some idx ->

     

       40
       40
       +
                     let key = String.trim (String.sub line 0 idx) in

     

       41
       41
       +
                     let value = String.trim (String.sub line (idx + 1) (String.length line - idx - 1)) in

     

       42
       42
       +
                     let full_key =

     

       43
       43
       +
                       if !current_section = "" || !current_section = "api" then key

     

       44
       44
       +
                       else !current_section ^ "." ^ key

     

       45
       45
       +
                     in

     

       46
       46
       +
                     Hashtbl.add config full_key value

     

       47
       47
       +
                 | None -> ()

     

       48
       48
       +
           ) lines;

     

       49
       49
       +
       

     

       50
       50
       +
           (* Extract required fields *)

     

       51
       51
       +
           let get_value key =

     

       52
       52
       +
             try Some (Hashtbl.find config key)

     

       53
       53
       +
             with Not_found -> None

     

       54
       54
       +
           in

     

       55
       55
       +
       

     

       56
       56
       +
           match get_value "email", get_value "key", get_value "site" with

     

       57
       57
       +
           | Some email, Some api_key, Some server_url ->

     

       58
       58
       +
               (* Ensure server_url has proper protocol *)

     

       59
       59
       +
               let server_url =

     

       60
       60
       +
                 if String.starts_with ~prefix:"http://" server_url ||

     

       61
       61
       +
                    String.starts_with ~prefix:"https://" server_url then

     

       62
       62
       +
                   server_url

     

       63
       63
       +
                 else

     

       64
       64
       +
                   "https://" ^ server_url

     

       65
       65
       +
               in

     

       66
       66
       +
               Ok { server_url; email; api_key }

     

       67
       67
       +
           | _ ->

     

       68
       68
       +
               Error (Error.create ~code:(Other "config_missing")

     

       69
       69
       +
                       ~msg:"Missing required fields: email, key, site in zuliprc" ())

     

       70
       70
       +
         with

     

       71
       71
       +
         | Sys_error msg ->

     

       72
       72
       +
             Error (Error.create ~code:(Other "file_error") ~msg:("Cannot read zuliprc file: " ^ msg) ())

     

       73
       73
       +
         | exn ->

     

       74
       74
       +
             Error (Error.create ~code:(Other "parse_error") ~msg:("Error parsing zuliprc: " ^ Printexc.to_string exn) ())

     

       75
       75
       +
       

     

       76
       76
       +
       let server_url t = t.server_url

     

       77
       77
       +
       let email t = t.email

     

       78
       78
       +
       let to_basic_auth_header t =

     

       79
       79
       +
         match Base64.encode (t.email ^ ":" ^ t.api_key) with

     

       80
       80
       +
         | Ok encoded -> "Basic " ^ encoded

     

       81
       81
       +
         | Error (`Msg msg) -> failwith ("Base64 encoding failed: " ^ msg)

     

       82
       82
       +
       

     

       83
       83
       +
       let pp fmt t = Format.fprintf fmt "Auth{server=%s, email=%s}" t.server_url t.email

stack/zulip/lib/zulip/lib/auth.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val create : server_url:string -> email:string -> api_key:string -> t

     

       4
       4
       +
       val from_zuliprc : ?path:string -> unit -> (t, Error.t) result

     

       5
       5
       +
       val server_url : t -> string

     

       6
       6
       +
       val email : t -> string

     

       7
       7
       +
       val to_basic_auth_header : t -> string

     

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

+50

stack/zulip/lib/zulip/lib/channel.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         name : string;

     

       3
       3
       +
         description : string;

     

       4
       4
       +
         invite_only : bool;

     

       5
       5
       +
         history_public_to_subscribers : bool;

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       let create ~name ~description ?(invite_only = false) ?(history_public_to_subscribers = true) () =

     

       9
       9
       +
         { name; description; invite_only; history_public_to_subscribers }

     

       10
       10
       +
       

     

       11
       11
       +
       let name t = t.name

     

       12
       12
       +
       let description t = t.description

     

       13
       13
       +
       let invite_only t = t.invite_only

     

       14
       14
       +
       let history_public_to_subscribers t = t.history_public_to_subscribers

     

       15
       15
       +
       

     

       16
       16
       +
       let to_json t = 

     

       17
       17
       +
         `O [

     

       18
       18
       +
           ("name", `String t.name);

     

       19
       19
       +
           ("description", `String t.description);

     

       20
       20
       +
           ("invite_only", `Bool t.invite_only);

     

       21
       21
       +
           ("history_public_to_subscribers", `Bool t.history_public_to_subscribers);

     

       22
       22
       +
         ]

     

       23
       23
       +
       

     

       24
       24
       +
       let of_json json = 

     

       25
       25
       +
         try

     

       26
       26
       +
           match json with

     

       27
       27
       +
           | `O fields ->

     

       28
       28
       +
               let get_string key = 

     

       29
       29
       +
                 match List.assoc key fields with 

     

       30
       30
       +
                 | `String s -> s 

     

       31
       31
       +
                 | _ -> failwith ("Expected string for " ^ key) in

     

       32
       32
       +
               let get_bool key default = 

     

       33
       33
       +
                 match List.assoc_opt key fields with 

     

       34
       34
       +
                 | Some (`Bool b) -> b 

     

       35
       35
       +
                 | None -> default

     

       36
       36
       +
                 | _ -> failwith ("Expected bool for " ^ key) in

     

       37
       37
       +
               

     

       38
       38
       +
               let name = get_string "name" in

     

       39
       39
       +
               let description = get_string "description" in

     

       40
       40
       +
               let invite_only = get_bool "invite_only" false in

     

       41
       41
       +
               let history_public_to_subscribers = get_bool "history_public_to_subscribers" true in

     

       42
       42
       +
               

     

       43
       43
       +
               Ok { name; description; invite_only; history_public_to_subscribers }

     

       44
       44
       +
           | _ -> 

     

       45
       45
       +
               Error (Error.create ~code:(Other "json_parse_error") ~msg:"Channel JSON must be an object" ())

     

       46
       46
       +
         with

     

       47
       47
       +
         | exn ->

     

       48
       48
       +
             Error (Error.create ~code:(Other "json_parse_error") ~msg:("Channel JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       49
       49
       +
       

     

       50
       50
       +
       let pp fmt t = Format.fprintf fmt "Channel{name=%s, description=%s}" t.name t.description

+16

stack/zulip/lib/zulip/lib/channel.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val create : 

     

       4
       4
       +
         name:string -> 

     

       5
       5
       +
         description:string -> 

     

       6
       6
       +
         ?invite_only:bool -> 

     

       7
       7
       +
         ?history_public_to_subscribers:bool -> 

     

       8
       8
       +
         unit -> t

     

       9
       9
       +
       

     

       10
       10
       +
       val name : t -> string

     

       11
       11
       +
       val description : t -> string

     

       12
       12
       +
       val invite_only : t -> bool

     

       13
       13
       +
       val history_public_to_subscribers : t -> bool

     

       14
       14
       +
       val to_json : t -> Error.json

     

       15
       15
       +
       val of_json : Error.json -> (t, Error.t) result

     

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

+58

stack/zulip/lib/zulip/lib/channels.ml

···

       1
       1
       +
       let create_channel client channel = 

     

       2
       2
       +
         let body = match Channel.to_json channel with

     

       3
       3
       +
           | `O fields -> 

     

       4
       4
       +
               String.concat "&" (List.map (fun (k, v) -> 

     

       5
       5
       +
                 match v with 

     

       6
       6
       +
                 | `String s -> k ^ "=" ^ Uri.pct_encode s

     

       7
       7
       +
                 | `Bool b -> k ^ "=" ^ string_of_bool b

     

       8
       8
       +
                 | _ -> ""

     

       9
       9
       +
               ) fields)

     

       10
       10
       +
           | _ -> "" in

     

       11
       11
       +
         match Client.request client ~method_:`POST ~path:"/streams" ~body () with

     

       12
       12
       +
         | Ok _json -> Ok ()

     

       13
       13
       +
         | Error err -> Error err

     

       14
       14
       +
       

     

       15
       15
       +
       let delete client ~name = 

     

       16
       16
       +
         let encoded_name = Uri.pct_encode name in

     

       17
       17
       +
         match Client.request client ~method_:`DELETE ~path:("/streams/" ^ encoded_name) () with

     

       18
       18
       +
         | Ok _json -> Ok ()

     

       19
       19
       +
         | Error err -> Error err

     

       20
       20
       +
       

     

       21
       21
       +
       let list client = 

     

       22
       22
       +
         match Client.request client ~method_:`GET ~path:"/streams" () with

     

       23
       23
       +
         | Ok json -> 

     

       24
       24
       +
             (match json with

     

       25
       25
       +
              | `O fields ->

     

       26
       26
       +
                  (match List.assoc_opt "streams" fields with

     

       27
       27
       +
                   | Some (`A channel_list) ->

     

       28
       28
       +
                       let channels = List.fold_left (fun acc channel_json ->

     

       29
       29
       +
                         match Channel.of_json channel_json with

     

       30
       30
       +
                         | Ok channel -> channel :: acc

     

       31
       31
       +
                         | Error _ -> acc

     

       32
       32
       +
                       ) [] channel_list in

     

       33
       33
       +
                       Ok (List.rev channels)

     

       34
       34
       +
                   | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Invalid streams response format" ()))

     

       35
       35
       +
              | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Streams response must be an object" ()))

     

       36
       36
       +
         | Error err -> Error err

     

       37
       37
       +
       

     

       38
       38
       +
       let subscribe client ~channels = 

     

       39
       39
       +
         let channels_json = `A (List.map (fun name -> `String name) channels) in

     

       40
       40
       +
         let body = "subscriptions=" ^ (match channels_json with

     

       41
       41
       +
           | `A items -> "[" ^ String.concat "," (List.map (function 

     

       42
       42
       +
               | `String s -> "\"" ^ s ^ "\""

     

       43
       43
       +
               | _ -> "") items) ^ "]"

     

       44
       44
       +
           | _ -> "[]") in

     

       45
       45
       +
         match Client.request client ~method_:`POST ~path:"/users/me/subscriptions" ~body () with

     

       46
       46
       +
         | Ok _json -> Ok ()

     

       47
       47
       +
         | Error err -> Error err

     

       48
       48
       +
       

     

       49
       49
       +
       let unsubscribe client ~channels = 

     

       50
       50
       +
         let channels_json = `A (List.map (fun name -> `String name) channels) in

     

       51
       51
       +
         let body = "delete=" ^ (match channels_json with

     

       52
       52
       +
           | `A items -> "[" ^ String.concat "," (List.map (function 

     

       53
       53
       +
               | `String s -> "\"" ^ s ^ "\""

     

       54
       54
       +
               | _ -> "") items) ^ "]"

     

       55
       55
       +
           | _ -> "[]") in

     

       56
       56
       +
         match Client.request client ~method_:`DELETE ~path:"/users/me/subscriptions" ~body () with

     

       57
       57
       +
         | Ok _json -> Ok ()

     

       58
       58
       +
         | Error err -> Error err

stack/zulip/lib/zulip/lib/channels.mli

···

       1
       1
       +
       val create_channel : Client.t -> Channel.t -> (unit, Error.t) result

     

       2
       2
       +
       val delete : Client.t -> name:string -> (unit, Error.t) result

     

       3
       3
       +
       val list : Client.t -> (Channel.t list, Error.t) result

     

       4
       4
       +
       val subscribe : Client.t -> channels:string list -> (unit, Error.t) result

     

       5
       5
       +
       val unsubscribe : Client.t -> channels:string list -> (unit, Error.t) result

+137

stack/zulip/lib/zulip/lib/client.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         auth : Auth.t;

     

       3
       3
       +
         session : (float Eio.Time.clock_ty Eio.Resource.t,

     

       4
       4
       +
                    [`Generic | `Unix] Eio.Net.ty Eio.Resource.t) Requests.t;

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       let create ~sw env auth =

     

       8
       8
       +
         let session = Requests.create ~sw

     

       9
       9
       +
           ~default_headers:(Requests.Headers.of_list [

     

       10
       10
       +
             ("Authorization", Auth.to_basic_auth_header auth);

     

       11
       11
       +
             ("User-Agent", "OCaml-Zulip/1.0");

     

       12
       12
       +
           ])

     

       13
       13
       +
           ~follow_redirects:true

     

       14
       14
       +
           ~verify_tls:true

     

       15
       15
       +
           env

     

       16
       16
       +
         in

     

       17
       17
       +
         { auth; session }

     

       18
       18
       +
       

     

       19
       19
       +
       let with_client env auth f =

     

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

     

       21
       21
       +
         let client = create ~sw env auth in

     

       22
       22
       +
         f client

     

       23
       23
       +
       

     

       24
       24
       +
       let request t ~method_ ~path ?params ?body () =

     

       25
       25
       +
         let url = Auth.server_url t.auth ^ path in

     

       26
       26
       +
       

     

       27
       27
       +
         (* Convert params to URL query string if provided *)

     

       28
       28
       +
         let url = match params with

     

       29
       29
       +
           | Some p ->

     

       30
       30
       +
               let uri = Uri.of_string url in

     

       31
       31
       +
               let uri = List.fold_left (fun u (k, v) -> Uri.add_query_param' u (k, v)) uri p in

     

       32
       32
       +
               Uri.to_string uri

     

       33
       33
       +
           | None -> url

     

       34
       34
       +
         in

     

       35
       35
       +
       

     

       36
       36
       +
         (* Prepare request body if provided *)

     

       37
       37
       +
         let body_opt = match body with

     

       38
       38
       +
           | Some json_str -> Some (Requests.Body.of_string Requests.Mime.json json_str)

     

       39
       39
       +
           | None -> None

     

       40
       40
       +
         in

     

       41
       41
       +
       

     

       42
       42
       +
         (* Make the request *)

     

       43
       43
       +
         let response =

     

       44
       44
       +
           match method_ with

     

       45
       45
       +
           | `GET -> Requests.get t.session url

     

       46
       46
       +
           | `POST -> Requests.post t.session ?body:body_opt url

     

       47
       47
       +
           | `PUT -> Requests.put t.session ?body:body_opt url

     

       48
       48
       +
           | `DELETE -> Requests.delete t.session url

     

       49
       49
       +
           | `PATCH -> Requests.patch t.session ?body:body_opt url

     

       50
       50
       +
         in

     

       51
       51
       +
       

     

       52
       52
       +
         (* Parse response *)

     

       53
       53
       +
         let status = Requests.Response.status_code response in

     

       54
       54
       +
         let body_str =

     

       55
       55
       +
           let body_flow = Requests.Response.body response in

     

       56
       56
       +
           let buf = Buffer.create 4096 in

     

       57
       57
       +
           Eio.Flow.copy body_flow (Eio.Flow.buffer_sink buf);

     

       58
       58
       +
           Buffer.contents buf

     

       59
       59
       +
         in

     

       60
       60
       +
       

     

       61
       61
       +
         (* Parse JSON response *)

     

       62
       62
       +
         let decoder = Jsonm.decoder (`String body_str) in

     

       63
       63
       +
         let rec parse_json decoder =

     

       64
       64
       +
           match Jsonm.decode decoder with

     

       65
       65
       +
           | `Lexeme l ->

     

       66
       66
       +
               (match l with

     

       67
       67
       +
                | `Oe -> `O []

     

       68
       68
       +
                | `Os -> parse_object decoder []

     

       69
       69
       +
                | `As -> parse_array decoder []

     

       70
       70
       +
                | `Ae -> `A []

     

       71
       71
       +
                | `Float f -> `Float f

     

       72
       72
       +
                | `String s -> `String s

     

       73
       73
       +
                | `Bool b -> `Bool b

     

       74
       74
       +
                | `Null -> `Null

     

       75
       75
       +
                | `Name _ -> parse_json decoder)

     

       76
       76
       +
           | `Error e -> failwith ("JSON parse error: " ^ (Format.asprintf "%a" Jsonm.pp_error e))

     

       77
       77
       +
           | `Await | `End -> `Null

     

       78
       78
       +
         and parse_object decoder acc =

     

       79
       79
       +
           match Jsonm.decode decoder with

     

       80
       80
       +
           | `Lexeme (`Name key) ->

     

       81
       81
       +
               let value = parse_json decoder in

     

       82
       82
       +
               parse_object decoder ((key, value) :: acc)

     

       83
       83
       +
           | `Lexeme `Oe -> `O (List.rev acc)

     

       84
       84
       +
           | _ -> `O (List.rev acc)

     

       85
       85
       +
         and parse_array decoder acc =

     

       86
       86
       +
           match Jsonm.decode decoder with

     

       87
       87
       +
           | `Lexeme `Ae -> `A (List.rev acc)

     

       88
       88
       +
           | `Lexeme l ->

     

       89
       89
       +
               (match l with

     

       90
       90
       +
                | `Name _ -> parse_array decoder acc

     

       91
       91
       +
                | _ ->

     

       92
       92
       +
                    let reparse l =

     

       93
       93
       +
                      match l with

     

       94
       94
       +
                      | `Float f -> `Float f

     

       95
       95
       +
                      | `String s -> `String s

     

       96
       96
       +
                      | `Bool b -> `Bool b

     

       97
       97
       +
                      | `Null -> `Null

     

       98
       98
       +
                      | `Os -> parse_object decoder []

     

       99
       99
       +
                      | `As -> parse_array decoder []

     

       100
       100
       +
                      | _ -> `Null

     

       101
       101
       +
                    in

     

       102
       102
       +
                    let value = reparse l in

     

       103
       103
       +
                    parse_array decoder (value :: acc))

     

       104
       104
       +
           | _ -> `A (List.rev acc)

     

       105
       105
       +
         in

     

       106
       106
       +
       

     

       107
       107
       +
         let json = parse_json decoder in

     

       108
       108
       +
       

     

       109
       109
       +
         (* Check for Zulip error response *)

     

       110
       110
       +
         match json with

     

       111
       111
       +
         | `O fields ->

     

       112
       112
       +
             (match List.assoc_opt "result" fields with

     

       113
       113
       +
              | Some (`String "error") ->

     

       114
       114
       +
                  let msg = match List.assoc_opt "msg" fields with

     

       115
       115
       +
                    | Some (`String s) -> s

     

       116
       116
       +
                    | _ -> "Unknown error"

     

       117
       117
       +
                  in

     

       118
       118
       +
                  let code = match List.assoc_opt "code" fields with

     

       119
       119
       +
                    | Some (`String s) -> Error.code_of_string s

     

       120
       120
       +
                    | _ -> Error.Other "unknown"

     

       121
       121
       +
                  in

     

       122
       122
       +
                  Error (Error.create ~code ~msg ())

     

       123
       123
       +
              | _ ->

     

       124
       124
       +
                  if status >= 200 && status < 300 then

     

       125
       125
       +
                    Ok json

     

       126
       126
       +
                  else

     

       127
       127
       +
                    Error (Error.create ~code:(Error.Other (string_of_int status))

     

       128
       128
       +
                            ~msg:("HTTP error: " ^ string_of_int status) ()))

     

       129
       129
       +
         | _ ->

     

       130
       130
       +
             if status >= 200 && status < 300 then

     

       131
       131
       +
               Ok json

     

       132
       132
       +
             else

     

       133
       133
       +
               Error (Error.create ~code:(Error.Other "json_parse")

     

       134
       134
       +
                       ~msg:"Invalid JSON response" ())

     

       135
       135
       +
       

     

       136
       136
       +
       let pp fmt t =

     

       137
       137
       +
         Format.fprintf fmt "Client(server=%s)" (Auth.server_url t.auth)

+31

stack/zulip/lib/zulip/lib/client.mli

···

       1
       1
       +
       (** HTTP client for making requests to the Zulip API using the requests library *)

     

       2
       2
       +
       

     

       3
       3
       +
       type t

     

       4
       4
       +
       (** Type representing a Zulip HTTP client *)

     

       5
       5
       +
       

     

       6
       6
       +
       val create : sw:Eio.Switch.t ->

     

       7
       7
       +
         < clock: float Eio.Time.clock_ty Eio.Resource.t;

     

       8
       8
       +
           net: [`Generic | `Unix] Eio.Net.ty Eio.Resource.t;

     

       9
       9
       +
           fs: Eio.Fs.dir_ty Eio.Path.t; .. > -> Auth.t -> t

     

       10
       10
       +
       (** Create a new client with the given switch, environment and authentication.

     

       11
       11
       +
           The environment must have clock, net, and fs capabilities. *)

     

       12
       12
       +
       

     

       13
       13
       +
       val with_client :

     

       14
       14
       +
         < clock: float Eio.Time.clock_ty Eio.Resource.t;

     

       15
       15
       +
           net: [`Generic | `Unix] Eio.Net.ty Eio.Resource.t;

     

       16
       16
       +
           fs: Eio.Fs.dir_ty Eio.Path.t; .. > -> Auth.t -> (t -> 'a) -> 'a

     

       17
       17
       +
       (** Resource-safe client management using structured concurrency.

     

       18
       18
       +
           The environment must have clock, net, and fs capabilities. *)

     

       19
       19
       +
       

     

       20
       20
       +
       val request :

     

       21
       21
       +
         t ->

     

       22
       22
       +
         method_:[`GET | `POST | `PUT | `DELETE | `PATCH] ->

     

       23
       23
       +
         path:string ->

     

       24
       24
       +
         ?params:(string * string) list ->

     

       25
       25
       +
         ?body:string ->

     

       26
       26
       +
         unit ->

     

       27
       27
       +
         (Error.json, Error.t) result

     

       28
       28
       +
       (** Make an HTTP request to the Zulip API using the requests library *)

     

       29
       29
       +
       

     

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

     

       31
       31
       +
       (** Pretty printer for client (shows server URL only, not credentials) *)

stack/zulip/lib/zulip/lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (public_name zulip)

     

       3
       3
       +
        (name zulip)

     

       4
       4
       +
        (libraries eio requests jsonm uri base64))

+62

stack/zulip/lib/zulip/lib/error.ml

···

       1
       1
       +
       type code = 

     

       2
       2
       +
         | Invalid_api_key

     

       3
       3
       +
         | Request_variable_missing

     

       4
       4
       +
         | Bad_request

     

       5
       5
       +
         | User_deactivated

     

       6
       6
       +
         | Realm_deactivated

     

       7
       7
       +
         | Rate_limit_hit

     

       8
       8
       +
         | Other of string

     

       9
       9
       +
       

     

       10
       10
       +
       type json = [`Null | `Bool of bool | `Float of float | `String of string | `A of json list | `O of (string * json) list]

     

       11
       11
       +
       

     

       12
       12
       +
       type t = {

     

       13
       13
       +
         code : code;

     

       14
       14
       +
         message : string;

     

       15
       15
       +
         extra : (string * json) list;

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       let code_of_string s = match s with

     

       19
       19
       +
         | "INVALID_API_KEY" -> Invalid_api_key

     

       20
       20
       +
         | "REQUEST_VARIABLE_MISSING" -> Request_variable_missing

     

       21
       21
       +
         | "BAD_REQUEST" -> Bad_request

     

       22
       22
       +
         | "USER_DEACTIVATED" -> User_deactivated

     

       23
       23
       +
         | "REALM_DEACTIVATED" -> Realm_deactivated

     

       24
       24
       +
         | "RATE_LIMIT_HIT" -> Rate_limit_hit

     

       25
       25
       +
         | s -> Other s

     

       26
       26
       +
       

     

       27
       27
       +
       let create ~code ~msg ?(extra = []) () = { code; message = msg; extra }

     

       28
       28
       +
       let code t = t.code

     

       29
       29
       +
       let message t = t.message

     

       30
       30
       +
       let extra t = t.extra

     

       31
       31
       +
       let pp fmt t = Format.fprintf fmt "Error(%s): %s" 

     

       32
       32
       +
         (match t.code with

     

       33
       33
       +
          | Invalid_api_key -> "INVALID_API_KEY"

     

       34
       34
       +
          | Request_variable_missing -> "REQUEST_VARIABLE_MISSING"

     

       35
       35
       +
          | Bad_request -> "BAD_REQUEST"

     

       36
       36
       +
          | User_deactivated -> "USER_DEACTIVATED"

     

       37
       37
       +
          | Realm_deactivated -> "REALM_DEACTIVATED"

     

       38
       38
       +
          | Rate_limit_hit -> "RATE_LIMIT_HIT"

     

       39
       39
       +
          | Other s -> s) t.message

     

       40
       40
       +
       

     

       41
       41
       +
       let of_json json =

     

       42
       42
       +
         match json with

     

       43
       43
       +
         | `O fields ->

     

       44
       44
       +
             (try

     

       45
       45
       +
               let code_str = match List.assoc "code" fields with

     

       46
       46
       +
                 | `String s -> s

     

       47
       47
       +
                 | _ -> "OTHER" in

     

       48
       48
       +
               let msg = match List.assoc "msg" fields with

     

       49
       49
       +
                 | `String s -> s

     

       50
       50
       +
                 | _ -> "Unknown error" in

     

       51
       51
       +
               let code = match code_str with

     

       52
       52
       +
                 | "INVALID_API_KEY" -> Invalid_api_key

     

       53
       53
       +
                 | "REQUEST_VARIABLE_MISSING" -> Request_variable_missing

     

       54
       54
       +
                 | "BAD_REQUEST" -> Bad_request

     

       55
       55
       +
                 | "USER_DEACTIVATED" -> User_deactivated

     

       56
       56
       +
                 | "REALM_DEACTIVATED" -> Realm_deactivated

     

       57
       57
       +
                 | "RATE_LIMIT_HIT" -> Rate_limit_hit

     

       58
       58
       +
                 | s -> Other s in

     

       59
       59
       +
               let extra = List.filter (fun (k, _) -> k <> "code" && k <> "msg" && k <> "result") fields in

     

       60
       60
       +
               Some (create ~code ~msg ~extra ())

     

       61
       61
       +
             with Not_found -> None)

     

       62
       62
       +
         | _ -> None

+20

stack/zulip/lib/zulip/lib/error.mli

···

       1
       1
       +
       type code = 

     

       2
       2
       +
         | Invalid_api_key

     

       3
       3
       +
         | Request_variable_missing

     

       4
       4
       +
         | Bad_request

     

       5
       5
       +
         | User_deactivated

     

       6
       6
       +
         | Realm_deactivated

     

       7
       7
       +
         | Rate_limit_hit

     

       8
       8
       +
         | Other of string

     

       9
       9
       +
       

     

       10
       10
       +
       type t

     

       11
       11
       +
       

     

       12
       12
       +
       type json = [`Null | `Bool of bool | `Float of float | `String of string | `A of json list | `O of (string * json) list]

     

       13
       13
       +
       

     

       14
       14
       +
       val code_of_string : string -> code

     

       15
       15
       +
       val create : code:code -> msg:string -> ?extra:(string * json) list -> unit -> t

     

       16
       16
       +
       val code : t -> code

     

       17
       17
       +
       val message : t -> string

     

       18
       18
       +
       val extra : t -> (string * json) list

     

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

     

       20
       20
       +
       val of_json : json -> t option

+40

stack/zulip/lib/zulip/lib/event.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         id : int;

     

       3
       3
       +
         type_ : Event_type.t;

     

       4
       4
       +
         data : Error.json;

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       let id t = t.id

     

       8
       8
       +
       let type_ t = t.type_

     

       9
       9
       +
       let data t = t.data

     

       10
       10
       +
       

     

       11
       11
       +
       let of_json json = 

     

       12
       12
       +
         try

     

       13
       13
       +
           match json with

     

       14
       14
       +
           | `O fields ->

     

       15
       15
       +
               let get_int key = 

     

       16
       16
       +
                 match List.assoc key fields with 

     

       17
       17
       +
                 | `Float f -> int_of_float f

     

       18
       18
       +
                 | _ -> failwith ("Expected int for " ^ key) in

     

       19
       19
       +
               let get_string key = 

     

       20
       20
       +
                 match List.assoc key fields with 

     

       21
       21
       +
                 | `String s -> s 

     

       22
       22
       +
                 | _ -> failwith ("Expected string for " ^ key) in

     

       23
       23
       +
               let get_data key = 

     

       24
       24
       +
                 match List.assoc_opt key fields with 

     

       25
       25
       +
                 | Some data -> data 

     

       26
       26
       +
                 | None -> `Null in

     

       27
       27
       +
               

     

       28
       28
       +
               let id = get_int "id" in

     

       29
       29
       +
               let type_str = get_string "type" in

     

       30
       30
       +
               let type_ = Event_type.of_string type_str in

     

       31
       31
       +
               let data = get_data "data" in

     

       32
       32
       +
               

     

       33
       33
       +
               Ok { id; type_; data }

     

       34
       34
       +
           | _ -> 

     

       35
       35
       +
               Error (Error.create ~code:(Other "json_parse_error") ~msg:"Event JSON must be an object" ())

     

       36
       36
       +
         with

     

       37
       37
       +
         | exn ->

     

       38
       38
       +
             Error (Error.create ~code:(Other "json_parse_error") ~msg:("Event JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       39
       39
       +
       

     

       40
       40
       +
       let pp fmt t = Format.fprintf fmt "Event{id=%d, type=%a}" t.id Event_type.pp t.type_

stack/zulip/lib/zulip/lib/event.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val id : t -> int

     

       4
       4
       +
       val type_ : t -> Event_type.t

     

       5
       5
       +
       val data : t -> Error.json

     

       6
       6
       +
       val of_json : Error.json -> (t, Error.t) result

     

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

+51

stack/zulip/lib/zulip/lib/event_queue.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         id : string;

     

       3
       3
       +
       }

     

       4
       4
       +
       

     

       5
       5
       +
       let register client ?event_types () = 

     

       6
       6
       +
         let params = match event_types with

     

       7
       7
       +
           | None -> []

     

       8
       8
       +
           | Some types -> 

     

       9
       9
       +
               let types_str = String.concat "," (List.map Event_type.to_string types) in

     

       10
       10
       +
               [("event_types", "[\"" ^ types_str ^ "\"]")]

     

       11
       11
       +
         in

     

       12
       12
       +
         match Client.request client ~method_:`POST ~path:"/register" ~params () with

     

       13
       13
       +
         | Ok json -> 

     

       14
       14
       +
             (match json with

     

       15
       15
       +
              | `O fields ->

     

       16
       16
       +
                  (match List.assoc_opt "queue_id" fields with

     

       17
       17
       +
                   | Some (`String queue_id) -> Ok { id = queue_id }

     

       18
       18
       +
                   | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Invalid register response: missing queue_id" ()))

     

       19
       19
       +
              | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Register response must be an object" ()))

     

       20
       20
       +
         | Error err -> Error err

     

       21
       21
       +
       

     

       22
       22
       +
       let id t = t.id

     

       23
       23
       +
       

     

       24
       24
       +
       let get_events t client ?last_event_id () = 

     

       25
       25
       +
         let params = [("queue_id", t.id)] @ 

     

       26
       26
       +
           (match last_event_id with

     

       27
       27
       +
            | None -> []

     

       28
       28
       +
            | Some event_id -> [("last_event_id", string_of_int event_id)]) in

     

       29
       29
       +
         match Client.request client ~method_:`GET ~path:"/events" ~params () with

     

       30
       30
       +
         | Ok json -> 

     

       31
       31
       +
             (match json with

     

       32
       32
       +
              | `O fields ->

     

       33
       33
       +
                  (match List.assoc_opt "events" fields with

     

       34
       34
       +
                   | Some (`A event_list) ->

     

       35
       35
       +
                       let events = List.fold_left (fun acc event_json ->

     

       36
       36
       +
                         match Event.of_json event_json with

     

       37
       37
       +
                         | Ok event -> event :: acc

     

       38
       38
       +
                         | Error _ -> acc

     

       39
       39
       +
                       ) [] event_list in

     

       40
       40
       +
                       Ok (List.rev events)

     

       41
       41
       +
                   | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Invalid events response format" ()))

     

       42
       42
       +
              | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Events response must be an object" ()))

     

       43
       43
       +
         | Error err -> Error err

     

       44
       44
       +
       

     

       45
       45
       +
       let delete t client = 

     

       46
       46
       +
         let params = [("queue_id", t.id)] in

     

       47
       47
       +
         match Client.request client ~method_:`DELETE ~path:"/events" ~params () with

     

       48
       48
       +
         | Ok _json -> Ok ()

     

       49
       49
       +
         | Error err -> Error err

     

       50
       50
       +
       

     

       51
       51
       +
       let pp fmt t = Format.fprintf fmt "EventQueue{id=%s}" t.id

+12

stack/zulip/lib/zulip/lib/event_queue.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val register :

     

       4
       4
       +
         Client.t ->

     

       5
       5
       +
         ?event_types:Event_type.t list ->

     

       6
       6
       +
         unit ->

     

       7
       7
       +
         (t, Error.t) result

     

       8
       8
       +
       

     

       9
       9
       +
       val id : t -> string

     

       10
       10
       +
       val get_events : t -> Client.t -> ?last_event_id:int -> unit -> (Event.t list, Error.t) result

     

       11
       11
       +
       val delete : t -> Client.t -> (unit, Error.t) result

     

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

+19

stack/zulip/lib/zulip/lib/event_type.ml

···

       1
       1
       +
       type t = 

     

       2
       2
       +
         | Message

     

       3
       3
       +
         | Subscription 

     

       4
       4
       +
         | User_activity

     

       5
       5
       +
         | Other of string

     

       6
       6
       +
       

     

       7
       7
       +
       let to_string = function

     

       8
       8
       +
         | Message -> "message"

     

       9
       9
       +
         | Subscription -> "subscription"

     

       10
       10
       +
         | User_activity -> "user_activity"

     

       11
       11
       +
         | Other s -> s

     

       12
       12
       +
       

     

       13
       13
       +
       let of_string = function

     

       14
       14
       +
         | "message" -> Message

     

       15
       15
       +
         | "subscription" -> Subscription

     

       16
       16
       +
         | "user_activity" -> User_activity

     

       17
       17
       +
         | s -> Other s

     

       18
       18
       +
       

     

       19
       19
       +
       let pp fmt t = Format.fprintf fmt "%s" (to_string t)

stack/zulip/lib/zulip/lib/event_type.mli

···

       1
       1
       +
       type t = 

     

       2
       2
       +
         | Message

     

       3
       3
       +
         | Subscription 

     

       4
       4
       +
         | User_activity

     

       5
       5
       +
         | Other of string

     

       6
       6
       +
       

     

       7
       7
       +
       val to_string : t -> string

     

       8
       8
       +
       val of_string : string -> t

     

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

+43

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

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         type_ : Message_type.t;

     

       3
       3
       +
         to_ : string list;

     

       4
       4
       +
         content : string;

     

       5
       5
       +
         topic : string option;

     

       6
       6
       +
         queue_id : string option;

     

       7
       7
       +
         local_id : string option;

     

       8
       8
       +
         read_by_sender : bool;

     

       9
       9
       +
       }

     

       10
       10
       +
       

     

       11
       11
       +
       let create ~type_ ~to_ ~content ?topic ?queue_id ?local_id ?(read_by_sender = true) () =

     

       12
       12
       +
         { type_; to_; content; topic; queue_id; local_id; read_by_sender }

     

       13
       13
       +
       

     

       14
       14
       +
       let type_ t = t.type_

     

       15
       15
       +
       let to_ t = t.to_

     

       16
       16
       +
       let content t = t.content

     

       17
       17
       +
       let topic t = t.topic

     

       18
       18
       +
       let queue_id t = t.queue_id

     

       19
       19
       +
       let local_id t = t.local_id

     

       20
       20
       +
       let read_by_sender t = t.read_by_sender

     

       21
       21
       +
       

     

       22
       22
       +
       let to_json t =

     

       23
       23
       +
         let base_fields = [

     

       24
       24
       +
           ("type", `String (Message_type.to_string t.type_));

     

       25
       25
       +
           ("to", `A (List.map (fun s -> `String s) t.to_));

     

       26
       26
       +
           ("content", `String t.content);

     

       27
       27
       +
           ("read_by_sender", `Bool t.read_by_sender);

     

       28
       28
       +
         ] in

     

       29
       29
       +
         let with_topic = match t.topic with

     

       30
       30
       +
           | Some topic -> ("topic", `String topic) :: base_fields

     

       31
       31
       +
           | None -> base_fields in

     

       32
       32
       +
         let with_queue_id = match t.queue_id with

     

       33
       33
       +
           | Some qid -> ("queue_id", `String qid) :: with_topic

     

       34
       34
       +
           | None -> with_topic in

     

       35
       35
       +
         let with_local_id = match t.local_id with

     

       36
       36
       +
           | Some lid -> ("local_id", `String lid) :: with_queue_id

     

       37
       37
       +
           | None -> with_queue_id in

     

       38
       38
       +
         `O with_local_id

     

       39
       39
       +
       

     

       40
       40
       +
       let pp fmt t = Format.fprintf fmt "Message{type=%a, to=%s, content=%s}" 

     

       41
       41
       +
         Message_type.pp t.type_ 

     

       42
       42
       +
         (String.concat "," t.to_) 

     

       43
       43
       +
         t.content

+21

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

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val create : 

     

       4
       4
       +
         type_:Message_type.t -> 

     

       5
       5
       +
         to_:string list -> 

     

       6
       6
       +
         content:string -> 

     

       7
       7
       +
         ?topic:string -> 

     

       8
       8
       +
         ?queue_id:string -> 

     

       9
       9
       +
         ?local_id:string -> 

     

       10
       10
       +
         ?read_by_sender:bool -> 

     

       11
       11
       +
         unit -> t

     

       12
       12
       +
       

     

       13
       13
       +
       val type_ : t -> Message_type.t

     

       14
       14
       +
       val to_ : t -> string list

     

       15
       15
       +
       val content : t -> string

     

       16
       16
       +
       val topic : t -> string option

     

       17
       17
       +
       val queue_id : t -> string option

     

       18
       18
       +
       val local_id : t -> string option

     

       19
       19
       +
       val read_by_sender : t -> bool

     

       20
       20
       +
       val to_json : t -> Error.json

     

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

+33

stack/zulip/lib/zulip/lib/message_response.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         id : int;

     

       3
       3
       +
         automatic_new_visibility_policy : string option;

     

       4
       4
       +
       }

     

       5
       5
       +
       

     

       6
       6
       +
       let id t = t.id

     

       7
       7
       +
       let automatic_new_visibility_policy t = t.automatic_new_visibility_policy

     

       8
       8
       +
       

     

       9
       9
       +
       let of_json json =

     

       10
       10
       +
         match json with

     

       11
       11
       +
         | `O fields ->

     

       12
       12
       +
             (try

     

       13
       13
       +
               let id = match List.assoc "id" fields with

     

       14
       14
       +
                 | `Float f -> int_of_float f

     

       15
       15
       +
                 | `String s -> int_of_string s

     

       16
       16
       +
                 | _ -> failwith "id not found or not a number" in

     

       17
       17
       +
               let automatic_new_visibility_policy = 

     

       18
       18
       +
                 try Some (match List.assoc "automatic_new_visibility_policy" fields with

     

       19
       19
       +
                   | `String s -> s

     

       20
       20
       +
                   | _ -> failwith "invalid visibility policy")

     

       21
       21
       +
                 with Not_found -> None in

     

       22
       22
       +
               Ok { id; automatic_new_visibility_policy }

     

       23
       23
       +
             with

     

       24
       24
       +
             | Failure msg ->

     

       25
       25
       +
                 Error (Error.create ~code:(Other "parse_error") ~msg:("Failed to parse message response: " ^ msg) ())

     

       26
       26
       +
             | Not_found ->

     

       27
       27
       +
                 Error (Error.create ~code:(Other "parse_error") ~msg:"Failed to parse message response: missing field" ())

     

       28
       28
       +
             | _ ->

     

       29
       29
       +
                 Error (Error.create ~code:(Other "parse_error") ~msg:"Failed to parse message response" ()))

     

       30
       30
       +
         | _ ->

     

       31
       31
       +
             Error (Error.create ~code:(Other "parse_error") ~msg:"Expected JSON object for message response" ())

     

       32
       32
       +
       

     

       33
       33
       +
       let pp fmt t = Format.fprintf fmt "MessageResponse{id=%d}" t.id

stack/zulip/lib/zulip/lib/message_response.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val id : t -> int

     

       4
       4
       +
       val automatic_new_visibility_policy : t -> string option

     

       5
       5
       +
       val of_json : Error.json -> (t, Error.t) result

     

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

+12

stack/zulip/lib/zulip/lib/message_type.ml

···

       1
       1
       +
       type t = [ `Direct | `Channel ]

     

       2
       2
       +
       

     

       3
       3
       +
       let to_string = function

     

       4
       4
       +
         | `Direct -> "direct"

     

       5
       5
       +
         | `Channel -> "stream"

     

       6
       6
       +
       

     

       7
       7
       +
       let of_string = function

     

       8
       8
       +
         | "direct" -> Some `Direct

     

       9
       9
       +
         | "stream" -> Some `Channel

     

       10
       10
       +
         | _ -> None

     

       11
       11
       +
       

     

       12
       12
       +
       let pp fmt t = Format.fprintf fmt "%s" (to_string t)

stack/zulip/lib/zulip/lib/message_type.mli

···

       1
       1
       +
       type t = [ `Direct | `Channel ]

     

       2
       2
       +
       

     

       3
       3
       +
       val to_string : t -> string

     

       4
       4
       +
       val of_string : string -> t option

     

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

+46

stack/zulip/lib/zulip/lib/messages.ml

···

       1
       1
       +
       let send client message =

     

       2
       2
       +
         let json = Message.to_json message in

     

       3
       3
       +
         let params = match json with

     

       4
       4
       +
           | `O fields ->

     

       5
       5
       +
               List.fold_left (fun acc (key, value) ->

     

       6
       6
       +
                 let str_value = match value with

     

       7
       7
       +
                   | `String s -> s

     

       8
       8
       +
                   | `Bool true -> "true"

     

       9
       9
       +
                   | `Bool false -> "false"

     

       10
       10
       +
                   | `A arr -> String.concat "," (List.map (function `String s -> s | _ -> "") arr)

     

       11
       11
       +
                   | _ -> ""

     

       12
       12
       +
                 in

     

       13
       13
       +
                 (key, str_value) :: acc

     

       14
       14
       +
               ) [] fields

     

       15
       15
       +
           | _ -> [] in

     

       16
       16
       +
         

     

       17
       17
       +
         match Client.request client ~method_:`POST ~path:"/messages" ~params () with

     

       18
       18
       +
         | Ok response -> Message_response.of_json response

     

       19
       19
       +
         | Error err -> Error err

     

       20
       20
       +
       

     

       21
       21
       +
       let edit client ~message_id ?content ?topic () =

     

       22
       22
       +
         let params = 

     

       23
       23
       +
           (("message_id", string_of_int message_id) ::

     

       24
       24
       +
            (match content with Some c -> [("content", c)] | None -> []) @

     

       25
       25
       +
            (match topic with Some t -> [("topic", t)] | None -> [])) in

     

       26
       26
       +
         

     

       27
       27
       +
         match Client.request client ~method_:`PATCH ~path:("/messages/" ^ string_of_int message_id) ~params () with

     

       28
       28
       +
         | Ok _ -> Ok ()

     

       29
       29
       +
         | Error err -> Error err

     

       30
       30
       +
       

     

       31
       31
       +
       let delete client ~message_id =

     

       32
       32
       +
         match Client.request client ~method_:`DELETE ~path:("/messages/" ^ string_of_int message_id) () with

     

       33
       33
       +
         | Ok _ -> Ok ()

     

       34
       34
       +
         | Error err -> Error err

     

       35
       35
       +
       

     

       36
       36
       +
       let get client ~message_id =

     

       37
       37
       +
         Client.request client ~method_:`GET ~path:("/messages/" ^ string_of_int message_id) ()

     

       38
       38
       +
       

     

       39
       39
       +
       let get_messages client ?anchor ?num_before ?num_after ?narrow () =

     

       40
       40
       +
         let params = 

     

       41
       41
       +
           (match anchor with Some a -> [("anchor", a)] | None -> []) @

     

       42
       42
       +
           (match num_before with Some n -> [("num_before", string_of_int n)] | None -> []) @

     

       43
       43
       +
           (match num_after with Some n -> [("num_after", string_of_int n)] | None -> []) @

     

       44
       44
       +
           (match narrow with Some n -> List.mapi (fun i s -> ("narrow[" ^ string_of_int i ^ "]", s)) n | None -> []) in

     

       45
       45
       +
         

     

       46
       46
       +
         Client.request client ~method_:`GET ~path:"/messages" ~params ()

+12

stack/zulip/lib/zulip/lib/messages.mli

···

       1
       1
       +
       val send : Client.t -> Message.t -> (Message_response.t, Error.t) result

     

       2
       2
       +
       val edit : Client.t -> message_id:int -> ?content:string -> ?topic:string -> unit -> (unit, Error.t) result

     

       3
       3
       +
       val delete : Client.t -> message_id:int -> (unit, Error.t) result

     

       4
       4
       +
       val get : Client.t -> message_id:int -> (Error.json, Error.t) result

     

       5
       5
       +
       val get_messages :

     

       6
       6
       +
         Client.t ->

     

       7
       7
       +
         ?anchor:string ->

     

       8
       8
       +
         ?num_before:int ->

     

       9
       9
       +
         ?num_after:int ->

     

       10
       10
       +
         ?narrow:string list ->

     

       11
       11
       +
         unit ->

     

       12
       12
       +
         (Error.json, Error.t) result

+54

stack/zulip/lib/zulip/lib/user.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         email : string;

     

       3
       3
       +
         full_name : string;

     

       4
       4
       +
         is_active : bool;

     

       5
       5
       +
         is_admin : bool;

     

       6
       6
       +
         is_bot : bool;

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       let create ~email ~full_name ?(is_active = true) ?(is_admin = false) ?(is_bot = false) () =

     

       10
       10
       +
         { email; full_name; is_active; is_admin; is_bot }

     

       11
       11
       +
       

     

       12
       12
       +
       let email t = t.email

     

       13
       13
       +
       let full_name t = t.full_name

     

       14
       14
       +
       let is_active t = t.is_active

     

       15
       15
       +
       let is_admin t = t.is_admin

     

       16
       16
       +
       let is_bot t = t.is_bot

     

       17
       17
       +
       

     

       18
       18
       +
       let to_json t = 

     

       19
       19
       +
         `O [

     

       20
       20
       +
           ("email", `String t.email);

     

       21
       21
       +
           ("full_name", `String t.full_name);

     

       22
       22
       +
           ("is_active", `Bool t.is_active);

     

       23
       23
       +
           ("is_admin", `Bool t.is_admin);

     

       24
       24
       +
           ("is_bot", `Bool t.is_bot);

     

       25
       25
       +
         ]

     

       26
       26
       +
       

     

       27
       27
       +
       let of_json json = 

     

       28
       28
       +
         try

     

       29
       29
       +
           match json with

     

       30
       30
       +
           | `O fields ->

     

       31
       31
       +
               let get_string key = 

     

       32
       32
       +
                 match List.assoc key fields with 

     

       33
       33
       +
                 | `String s -> s 

     

       34
       34
       +
                 | _ -> failwith ("Expected string for " ^ key) in

     

       35
       35
       +
               let get_bool key default = 

     

       36
       36
       +
                 match List.assoc_opt key fields with 

     

       37
       37
       +
                 | Some (`Bool b) -> b 

     

       38
       38
       +
                 | None -> default

     

       39
       39
       +
                 | _ -> failwith ("Expected bool for " ^ key) in

     

       40
       40
       +
               

     

       41
       41
       +
               let email = get_string "email" in

     

       42
       42
       +
               let full_name = get_string "full_name" in

     

       43
       43
       +
               let is_active = get_bool "is_active" true in

     

       44
       44
       +
               let is_admin = get_bool "is_admin" false in

     

       45
       45
       +
               let is_bot = get_bool "is_bot" false in

     

       46
       46
       +
               

     

       47
       47
       +
               Ok { email; full_name; is_active; is_admin; is_bot }

     

       48
       48
       +
           | _ -> 

     

       49
       49
       +
               Error (Error.create ~code:(Other "json_parse_error") ~msg:"User JSON must be an object" ())

     

       50
       50
       +
         with

     

       51
       51
       +
         | exn ->

     

       52
       52
       +
             Error (Error.create ~code:(Other "json_parse_error") ~msg:("User JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       53
       53
       +
       

     

       54
       54
       +
       let pp fmt t = Format.fprintf fmt "User{email=%s, full_name=%s}" t.email t.full_name

+18

stack/zulip/lib/zulip/lib/user.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val create : 

     

       4
       4
       +
         email:string -> 

     

       5
       5
       +
         full_name:string -> 

     

       6
       6
       +
         ?is_active:bool -> 

     

       7
       7
       +
         ?is_admin:bool -> 

     

       8
       8
       +
         ?is_bot:bool -> 

     

       9
       9
       +
         unit -> t

     

       10
       10
       +
       

     

       11
       11
       +
       val email : t -> string

     

       12
       12
       +
       val full_name : t -> string

     

       13
       13
       +
       val is_active : t -> bool

     

       14
       14
       +
       val is_admin : t -> bool

     

       15
       15
       +
       val is_bot : t -> bool

     

       16
       16
       +
       val to_json : t -> Error.json

     

       17
       17
       +
       val of_json : Error.json -> (t, Error.t) result

     

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

+46

stack/zulip/lib/zulip/lib/users.ml

···

       1
       1
       +
       let list client = 

     

       2
       2
       +
         match Client.request client ~method_:`GET ~path:"/users" () with

     

       3
       3
       +
         | Ok json -> 

     

       4
       4
       +
             (match json with

     

       5
       5
       +
              | `O fields ->

     

       6
       6
       +
                  (match List.assoc_opt "members" fields with

     

       7
       7
       +
                   | Some (`A user_list) ->

     

       8
       8
       +
                       let users = List.fold_left (fun acc user_json ->

     

       9
       9
       +
                         match User.of_json user_json with

     

       10
       10
       +
                         | Ok user -> user :: acc

     

       11
       11
       +
                         | Error _ -> acc

     

       12
       12
       +
                       ) [] user_list in

     

       13
       13
       +
                       Ok (List.rev users)

     

       14
       14
       +
                   | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Invalid users response format" ()))

     

       15
       15
       +
              | _ -> Error (Error.create ~code:(Other "api_error") ~msg:"Users response must be an object" ()))

     

       16
       16
       +
         | Error err -> Error err

     

       17
       17
       +
       

     

       18
       18
       +
       let get client ~email = 

     

       19
       19
       +
         match Client.request client ~method_:`GET ~path:("/users/" ^ email) () with

     

       20
       20
       +
         | Ok json -> 

     

       21
       21
       +
             (match User.of_json json with

     

       22
       22
       +
              | Ok user -> Ok user

     

       23
       23
       +
              | Error err -> Error err)

     

       24
       24
       +
         | Error err -> Error err

     

       25
       25
       +
       

     

       26
       26
       +
       let create_user client ~email ~full_name = 

     

       27
       27
       +
         let body_json = `O [

     

       28
       28
       +
           ("email", `String email);

     

       29
       29
       +
           ("full_name", `String full_name);

     

       30
       30
       +
         ] in

     

       31
       31
       +
         let body = match body_json with

     

       32
       32
       +
           | `O fields -> 

     

       33
       33
       +
               String.concat "&" (List.map (fun (k, v) -> 

     

       34
       34
       +
                 match v with 

     

       35
       35
       +
                 | `String s -> k ^ "=" ^ s 

     

       36
       36
       +
                 | _ -> ""

     

       37
       37
       +
               ) fields)

     

       38
       38
       +
           | _ -> "" in

     

       39
       39
       +
         match Client.request client ~method_:`POST ~path:"/users" ~body () with

     

       40
       40
       +
         | Ok _json -> Ok ()

     

       41
       41
       +
         | Error err -> Error err

     

       42
       42
       +
       

     

       43
       43
       +
       let deactivate client ~email = 

     

       44
       44
       +
         match Client.request client ~method_:`DELETE ~path:("/users/" ^ email) () with

     

       45
       45
       +
         | Ok _json -> Ok ()

     

       46
       46
       +
         | Error err -> Error err

stack/zulip/lib/zulip/lib/users.mli

···

       1
       1
       +
       val list : Client.t -> (User.t list, Error.t) result

     

       2
       2
       +
       val get : Client.t -> email:string -> (User.t, Error.t) result

     

       3
       3
       +
       val create_user : Client.t -> email:string -> full_name:string -> (unit, Error.t) result

     

       4
       4
       +
       val deactivate : Client.t -> email:string -> (unit, Error.t) result

+93

stack/zulip/lib/zulip_bot/lib/bot_config.ml

···

       1
       1
       +
       type t = (string, string) Hashtbl.t

     

       2
       2
       +
       

     

       3
       3
       +
       let create pairs =

     

       4
       4
       +
         let config = Hashtbl.create (List.length pairs) in

     

       5
       5
       +
         List.iter (fun (k, v) -> Hashtbl.replace config k v) pairs;

     

       6
       6
       +
         config

     

       7
       7
       +
       

     

       8
       8
       +
       let from_file path =

     

       9
       9
       +
         try

     

       10
       10
       +
           let content =

     

       11
       11
       +
             let ic = open_in path in

     

       12
       12
       +
             let content = really_input_string ic (in_channel_length ic) in

     

       13
       13
       +
             close_in ic;

     

       14
       14
       +
             content in

     

       15
       15
       +
       

     

       16
       16
       +
           (* Simple INI-style parser for config files *)

     

       17
       17
       +
           let lines = String.split_on_char '\n' content in

     

       18
       18
       +
           let config = Hashtbl.create 16 in

     

       19
       19
       +
           let current_section = ref "" in

     

       20
       20
       +
       

     

       21
       21
       +
           List.iter (fun line ->

     

       22
       22
       +
             let line = String.trim line in

     

       23
       23
       +
             if String.length line > 0 && line.[0] <> '#' && line.[0] <> ';' then

     

       24
       24
       +
               if String.length line > 2 && line.[0] = '[' && line.[String.length line - 1] = ']' then

     

       25
       25
       +
                 (* Section header *)

     

       26
       26
       +
                 current_section := String.sub line 1 (String.length line - 2)

     

       27
       27
       +
               else

     

       28
       28
       +
                 (* Key-value pair *)

     

       29
       29
       +
                 match String.index_opt line '=' with

     

       30
       30
       +
                 | Some idx ->

     

       31
       31
       +
                     let key = String.trim (String.sub line 0 idx) in

     

       32
       32
       +
                     let value = String.trim (String.sub line (idx + 1) (String.length line - idx - 1)) in

     

       33
       33
       +
                     (* Remove quotes if present *)

     

       34
       34
       +
                     let value =

     

       35
       35
       +
                       if String.length value >= 2 &&

     

       36
       36
       +
                          ((value.[0] = '"' && value.[String.length value - 1] = '"') ||

     

       37
       37
       +
                           (value.[0] = '\'' && value.[String.length value - 1] = '\'')) then

     

       38
       38
       +
                         String.sub value 1 (String.length value - 2)

     

       39
       39
       +
                       else

     

       40
       40
       +
                         value

     

       41
       41
       +
                     in

     

       42
       42
       +
                     let full_key =

     

       43
       43
       +
                       if !current_section = "" then key

     

       44
       44
       +
                       else if !current_section = "bot" || !current_section = "features" then

     

       45
       45
       +
                         (* For bot and features sections, use flat keys *)

     

       46
       46
       +
                         key

     

       47
       47
       +
                       else

     

       48
       48
       +
                         !current_section ^ "." ^ key

     

       49
       49
       +
                     in

     

       50
       50
       +
                     Hashtbl.replace config full_key value

     

       51
       51
       +
                 | None -> ()

     

       52
       52
       +
           ) lines;

     

       53
       53
       +
       

     

       54
       54
       +
           Ok config

     

       55
       55
       +
         with

     

       56
       56
       +
         | Sys_error msg ->

     

       57
       57
       +
             Error (Zulip.Error.create ~code:(Other "file_error") ~msg:("Cannot read config file: " ^ msg) ())

     

       58
       58
       +
         | exn ->

     

       59
       59
       +
             Error (Zulip.Error.create ~code:(Other "parse_error") ~msg:("Error parsing config: " ^ Printexc.to_string exn) ())

     

       60
       60
       +
       

     

       61
       61
       +
       let from_env ~prefix =

     

       62
       62
       +
         try

     

       63
       63
       +
           let config = Hashtbl.create 16 in

     

       64
       64
       +
           let env_vars = Array.to_list (Unix.environment ()) in

     

       65
       65
       +
       

     

       66
       66
       +
           List.iter (fun env_var ->

     

       67
       67
       +
             match String.split_on_char '=' env_var with

     

       68
       68
       +
             | key :: value_parts when String.length key > String.length prefix &&

     

       69
       69
       +
                                      String.sub key 0 (String.length prefix) = prefix ->

     

       70
       70
       +
                 let config_key = String.sub key (String.length prefix) (String.length key - String.length prefix) in

     

       71
       71
       +
                 let value = String.concat "=" value_parts in

     

       72
       72
       +
                 Hashtbl.replace config config_key value

     

       73
       73
       +
             | _ -> ()

     

       74
       74
       +
           ) env_vars;

     

       75
       75
       +
       

     

       76
       76
       +
           Ok config

     

       77
       77
       +
         with

     

       78
       78
       +
         | exn ->

     

       79
       79
       +
             Error (Zulip.Error.create ~code:(Other "env_error") ~msg:("Error reading environment: " ^ Printexc.to_string exn) ())

     

       80
       80
       +
       

     

       81
       81
       +
       let get t ~key =

     

       82
       82
       +
         Hashtbl.find_opt t key

     

       83
       83
       +
       

     

       84
       84
       +
       let get_required t ~key =

     

       85
       85
       +
         match Hashtbl.find_opt t key with

     

       86
       86
       +
         | Some value -> Ok value

     

       87
       87
       +
         | None -> Error (Zulip.Error.create ~code:(Other "config_missing") ~msg:("Required config key missing: " ^ key) ())

     

       88
       88
       +
       

     

       89
       89
       +
       let has_key t ~key =

     

       90
       90
       +
         Hashtbl.mem t key

     

       91
       91
       +
       

     

       92
       92
       +
       let keys t =

     

       93
       93
       +
         Hashtbl.fold (fun k _ acc -> k :: acc) t []

+24

stack/zulip/lib/zulip_bot/lib/bot_config.mli

···

       1
       1
       +
       (** Configuration management for bots *)

     

       2
       2
       +
       

     

       3
       3
       +
       type t

     

       4
       4
       +
       

     

       5
       5
       +
       (** Create configuration from key-value pairs *)

     

       6
       6
       +
       val create : (string * string) list -> t

     

       7
       7
       +
       

     

       8
       8
       +
       (** Load configuration from file *)

     

       9
       9
       +
       val from_file : string -> (t, Zulip.Error.t) result

     

       10
       10
       +
       

     

       11
       11
       +
       (** Load configuration from environment variables with prefix *)

     

       12
       12
       +
       val from_env : prefix:string -> (t, Zulip.Error.t) result

     

       13
       13
       +
       

     

       14
       14
       +
       (** Get a configuration value *)

     

       15
       15
       +
       val get : t -> key:string -> string option

     

       16
       16
       +
       

     

       17
       17
       +
       (** Get a required configuration value, failing if not present *)

     

       18
       18
       +
       val get_required : t -> key:string -> (string, Zulip.Error.t) result

     

       19
       19
       +
       

     

       20
       20
       +
       (** Check if a key exists in configuration *)

     

       21
       21
       +
       val has_key : t -> key:string -> bool

     

       22
       22
       +
       

     

       23
       23
       +
       (** Get all configuration keys *)

     

       24
       24
       +
       val keys : t -> string list

+110

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

···

       1
       1
       +
       module Response = struct

     

       2
       2
       +
         type t =

     

       3
       3
       +
           | Reply of string

     

       4
       4
       +
           | DirectMessage of { to_: string; content: string }

     

       5
       5
       +
           | ChannelMessage of { channel: string; topic: string; content: string }

     

       6
       6
       +
           | None

     

       7
       7
       +
       

     

       8
       8
       +
         let none = None

     

       9
       9
       +
         let reply content = Reply content

     

       10
       10
       +
         let direct_message ~to_ ~content = DirectMessage { to_; content }

     

       11
       11
       +
         let channel_message ~channel ~topic ~content = ChannelMessage { channel; topic; content }

     

       12
       12
       +
       end

     

       13
       13
       +
       

     

       14
       14
       +
       module Identity = struct

     

       15
       15
       +
         type t = {

     

       16
       16
       +
           full_name : string;

     

       17
       17
       +
           email : string;

     

       18
       18
       +
           mention_name : string;

     

       19
       19
       +
         }

     

       20
       20
       +
       

     

       21
       21
       +
         let create ~full_name ~email ~mention_name = { full_name; email; mention_name }

     

       22
       22
       +
         let full_name t = t.full_name

     

       23
       23
       +
         let email t = t.email

     

       24
       24
       +
         let mention_name t = t.mention_name

     

       25
       25
       +
       end

     

       26
       26
       +
       

     

       27
       27
       +
       module Message_context = struct

     

       28
       28
       +
         type t = Zulip.Error.json

     

       29
       29
       +
       

     

       30
       30
       +
         let of_json json = json

     

       31
       31
       +
       

     

       32
       32
       +
         let sender_email t =

     

       33
       33
       +
           match t with

     

       34
       34
       +
           | `O fields ->

     

       35
       35
       +
               (match List.assoc_opt "sender_email" fields with

     

       36
       36
       +
                | Some (`String s) -> Some s

     

       37
       37
       +
                | _ -> None)

     

       38
       38
       +
           | _ -> None

     

       39
       39
       +
       

     

       40
       40
       +
         let content t =

     

       41
       41
       +
           match t with

     

       42
       42
       +
           | `O fields ->

     

       43
       43
       +
               (match List.assoc_opt "content" fields with

     

       44
       44
       +
                | Some (`String s) -> Some s

     

       45
       45
       +
                | _ -> None)

     

       46
       46
       +
           | _ -> None

     

       47
       47
       +
       

     

       48
       48
       +
         let is_direct t =

     

       49
       49
       +
           match t with

     

       50
       50
       +
           | `O fields ->

     

       51
       51
       +
               (match List.assoc_opt "type" fields with

     

       52
       52
       +
                | Some (`String "direct") -> true

     

       53
       53
       +
                | _ -> false)

     

       54
       54
       +
           | _ -> false

     

       55
       55
       +
       end

     

       56
       56
       +
       

     

       57
       57
       +
       (** Module signature for bot implementations *)

     

       58
       58
       +
       module type Bot_handler = sig

     

       59
       59
       +
         val initialize : Bot_config.t -> (unit, Zulip.Error.t) result

     

       60
       60
       +
         val usage : unit -> string

     

       61
       61
       +
         val description : unit -> string

     

       62
       62
       +
         val handle_message :

     

       63
       63
       +
           config:Bot_config.t ->

     

       64
       64
       +
           storage:Bot_storage.t ->

     

       65
       65
       +
           identity:Identity.t ->

     

       66
       66
       +
           message:Message_context.t ->

     

       67
       67
       +
           env:_ ->

     

       68
       68
       +
           (Response.t, Zulip.Error.t) result

     

       69
       69
       +
       end

     

       70
       70
       +
       

     

       71
       71
       +
       module type S = Bot_handler

     

       72
       72
       +
       

     

       73
       73
       +
       type t = {

     

       74
       74
       +
         module_impl : (module Bot_handler);

     

       75
       75
       +
         config : Bot_config.t;

     

       76
       76
       +
         storage : Bot_storage.t;

     

       77
       77
       +
         identity : Identity.t;

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       let create module_impl ~config ~storage ~identity =

     

       81
       81
       +
         { module_impl; config; storage; identity }

     

       82
       82
       +
       

     

       83
       83
       +
       let handle_message t message =

     

       84
       84
       +
         let module Handler = (val t.module_impl) in

     

       85
       85
       +
         (* Create a mock environment for now - in real usage, this should be passed in *)

     

       86
       86
       +
         let mock_env = object end in

     

       87
       87
       +
         Handler.handle_message

     

       88
       88
       +
           ~config:t.config

     

       89
       89
       +
           ~storage:t.storage

     

       90
       90
       +
           ~identity:t.identity

     

       91
       91
       +
           ~message

     

       92
       92
       +
           ~env:mock_env

     

       93
       93
       +
       

     

       94
       94
       +
       let handle_message_with_env t env message =

     

       95
       95
       +
         let module Handler = (val t.module_impl) in

     

       96
       96
       +
         Handler.handle_message

     

       97
       97
       +
           ~config:t.config

     

       98
       98
       +
           ~storage:t.storage

     

       99
       99
       +
           ~identity:t.identity

     

       100
       100
       +
           ~message

     

       101
       101
       +
           ~env

     

       102
       102
       +
       

     

       103
       103
       +
       let identity t = t.identity

     

       104
       104
       +
       let usage t =

     

       105
       105
       +
         let module Handler = (val t.module_impl) in

     

       106
       106
       +
         Handler.usage ()

     

       107
       107
       +
       

     

       108
       108
       +
       let description t =

     

       109
       109
       +
         let module Handler = (val t.module_impl) in

     

       110
       110
       +
         Handler.description ()

+85

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

···

       1
       1
       +
       (** Bot handler framework for Zulip bots *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Response types that bots can return *)

     

       4
       4
       +
       module Response : sig

     

       5
       5
       +
         type t =

     

       6
       6
       +
           | Reply of string  (** Reply in the same context *)

     

       7
       7
       +
           | DirectMessage of { to_: string; content: string }  (** Send a direct message *)

     

       8
       8
       +
           | ChannelMessage of { channel: string; topic: string; content: string }  (** Send to a channel *)

     

       9
       9
       +
           | None  (** No response *)

     

       10
       10
       +
       

     

       11
       11
       +
         val none : t

     

       12
       12
       +
         val reply : string -> t

     

       13
       13
       +
         val direct_message : to_:string -> content:string -> t

     

       14
       14
       +
         val channel_message : channel:string -> topic:string -> content:string -> t

     

       15
       15
       +
       end

     

       16
       16
       +
       

     

       17
       17
       +
       (** Bot identity information *)

     

       18
       18
       +
       module Identity : sig

     

       19
       19
       +
         type t

     

       20
       20
       +
       

     

       21
       21
       +
         val create : full_name:string -> email:string -> mention_name:string -> t

     

       22
       22
       +
         val full_name : t -> string

     

       23
       23
       +
         val email : t -> string

     

       24
       24
       +
         val mention_name : t -> string

     

       25
       25
       +
       end

     

       26
       26
       +
       

     

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

     

       28
       28
       +
       module Message_context : sig

     

       29
       29
       +
         type t = Zulip.Error.json

     

       30
       30
       +
       

     

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

     

       32
       32
       +
         val sender_email : t -> string option

     

       33
       33
       +
         val content : t -> string option

     

       34
       34
       +
         val is_direct : t -> bool

     

       35
       35
       +
       end

     

       36
       36
       +
       

     

       37
       37
       +
       (** Module signature for bot implementations *)

     

       38
       38
       +
       module type Bot_handler = sig

     

       39
       39
       +
         (** Initialize the bot (called once on startup) *)

     

       40
       40
       +
         val initialize : Bot_config.t -> (unit, Zulip.Error.t) result

     

       41
       41
       +
       

     

       42
       42
       +
         (** Provide usage/help text *)

     

       43
       43
       +
         val usage : unit -> string

     

       44
       44
       +
       

     

       45
       45
       +
         (** Provide bot description *)

     

       46
       46
       +
         val description : unit -> string

     

       47
       47
       +
       

     

       48
       48
       +
         (** Handle an incoming message with EIO environment *)

     

       49
       49
       +
         val handle_message :

     

       50
       50
       +
           config:Bot_config.t ->

     

       51
       51
       +
           storage:Bot_storage.t ->

     

       52
       52
       +
           identity:Identity.t ->

     

       53
       53
       +
           message:Message_context.t ->

     

       54
       54
       +
           env:_ ->

     

       55
       55
       +
           (Response.t, Zulip.Error.t) result

     

       56
       56
       +
       end

     

       57
       57
       +
       

     

       58
       58
       +
       (** Shorter alias for Bot_handler *)

     

       59
       59
       +
       module type S = Bot_handler

     

       60
       60
       +
       

     

       61
       61
       +
       (** Abstract bot handler *)

     

       62
       62
       +
       type t

     

       63
       63
       +
       

     

       64
       64
       +
       (** Create a bot handler from a module *)

     

       65
       65
       +
       val create :

     

       66
       66
       +
         (module Bot_handler) ->

     

       67
       67
       +
         config:Bot_config.t ->

     

       68
       68
       +
         storage:Bot_storage.t ->

     

       69
       69
       +
         identity:Identity.t ->

     

       70
       70
       +
         t

     

       71
       71
       +
       

     

       72
       72
       +
       (** Process an incoming message with the bot *)

     

       73
       73
       +
       val handle_message : t -> Message_context.t -> (Response.t, Zulip.Error.t) result

     

       74
       74
       +
       

     

       75
       75
       +
       (** Process an incoming message with EIO environment *)

     

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

     

       77
       77
       +
       

     

       78
       78
       +
       (** Get bot identity *)

     

       79
       79
       +
       val identity : t -> Identity.t

     

       80
       80
       +
       

     

       81
       81
       +
       (** Get bot usage text *)

     

       82
       82
       +
       val usage : t -> string

     

       83
       83
       +
       

     

       84
       84
       +
       (** Get bot description *)

     

       85
       85
       +
       val description : t -> string

+42

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

···

       1
       1
       +
       type 'env t = {

     

       2
       2
       +
         client : Zulip.Client.t;

     

       3
       3
       +
         handler : Bot_handler.t;

     

       4
       4
       +
         mutable running : bool;

     

       5
       5
       +
         storage : Bot_storage.t;

     

       6
       6
       +
         env : 'env; (* Store EIO environment *)

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       let create ~env ~client ~handler =

     

       10
       10
       +
         let storage = Bot_storage.create client ~bot_email:"temp-bot" in

     

       11
       11
       +
         { client; handler; running = false; storage; env }

     

       12
       12
       +
       

     

       13
       13
       +
       let run_realtime t =

     

       14
       14
       +
         t.running <- true;

     

       15
       15
       +
         Printf.printf "Bot started in real-time mode\n";

     

       16
       16
       +
       

     

       17
       17
       +
         (* In a real implementation, this would:

     

       18
       18
       +
            1. Register event queue with Zulip

     

       19
       19
       +
            2. Poll for events in a loop

     

       20
       20
       +
            3. Process message events through the handler

     

       21
       21
       +
         *)

     

       22
       22
       +
       

     

       23
       23
       +
         (* Mock implementation for now *)

     

       24
       24
       +
         while t.running do

     

       25
       25
       +
           Unix.sleep 1

     

       26
       26
       +
         done

     

       27
       27
       +
       

     

       28
       28
       +
       let run_webhook t =

     

       29
       29
       +
         t.running <- true;

     

       30
       30
       +
         Printf.printf "Bot started in webhook mode\n";

     

       31
       31
       +
         (* Webhook mode would wait for HTTP callbacks *)

     

       32
       32
       +
         ()

     

       33
       33
       +
       

     

       34
       34
       +
       let handle_webhook t ~webhook_data =

     

       35
       35
       +
         (* Process webhook data and route to handler *)

     

       36
       36
       +
         match Bot_handler.handle_message_with_env t.handler t.env webhook_data with

     

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

     

       38
       38
       +
         | Error e -> Error e

     

       39
       39
       +
       

     

       40
       40
       +
       let shutdown t =

     

       41
       41
       +
         t.running <- false;

     

       42
       42
       +
         Printf.printf "Bot shutting down\n"

+25

stack/zulip/lib/zulip_bot/lib/bot_runner.mli

···

       1
       1
       +
       (** Bot execution and lifecycle management *)

     

       2
       2
       +
       

     

       3
       3
       +
       type 'env t

     

       4
       4
       +
       

     

       5
       5
       +
       (** Create a bot runner *)

     

       6
       6
       +
       val create :

     

       7
       7
       +
         env:'env ->

     

       8
       8
       +
         client:Zulip.Client.t ->

     

       9
       9
       +
         handler:Bot_handler.t ->

     

       10
       10
       +
         'env t

     

       11
       11
       +
       

     

       12
       12
       +
       (** Run the bot in real-time mode (using Zulip events API) *)

     

       13
       13
       +
       val run_realtime : 'env t -> unit

     

       14
       14
       +
       

     

       15
       15
       +
       (** Run the bot in webhook mode (for use with bot server) *)

     

       16
       16
       +
       val run_webhook : 'env t -> unit

     

       17
       17
       +
       

     

       18
       18
       +
       (** Process a single webhook event *)

     

       19
       19
       +
       val handle_webhook :

     

       20
       20
       +
         'env t ->

     

       21
       21
       +
         webhook_data:Zulip.Error.json ->

     

       22
       22
       +
         (Bot_handler.Response.t option, Zulip.Error.t) result

     

       23
       23
       +
       

     

       24
       24
       +
       (** Gracefully shutdown the bot *)

     

       25
       25
       +
       val shutdown : 'env t -> unit

+28

stack/zulip/lib/zulip_bot/lib/bot_storage.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         client : Zulip.Client.t;

     

       3
       3
       +
         bot_email : string;

     

       4
       4
       +
         cache : (string, string) Hashtbl.t;

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       let create client ~bot_email = {

     

       8
       8
       +
         client;

     

       9
       9
       +
         bot_email;

     

       10
       10
       +
         cache = Hashtbl.create 16;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       let get t ~key =

     

       14
       14
       +
         Hashtbl.find_opt t.cache key

     

       15
       15
       +
       

     

       16
       16
       +
       let put t ~key ~value =

     

       17
       17
       +
         Hashtbl.replace t.cache key value;

     

       18
       18
       +
         Ok ()

     

       19
       19
       +
       

     

       20
       20
       +
       let contains t ~key =

     

       21
       21
       +
         Hashtbl.mem t.cache key

     

       22
       22
       +
       

     

       23
       23
       +
       let remove t ~key =

     

       24
       24
       +
         Hashtbl.remove t.cache key;

     

       25
       25
       +
         Ok ()

     

       26
       26
       +
       

     

       27
       27
       +
       let keys t =

     

       28
       28
       +
         Ok (Hashtbl.fold (fun k _ acc -> k :: acc) t.cache [])

+21

stack/zulip/lib/zulip_bot/lib/bot_storage.mli

···

       1
       1
       +
       (** Persistent storage interface for bots *)

     

       2
       2
       +
       

     

       3
       3
       +
       type t

     

       4
       4
       +
       

     

       5
       5
       +
       (** Create a new storage instance for a bot *)

     

       6
       6
       +
       val create : Zulip.Client.t -> bot_email:string -> t

     

       7
       7
       +
       

     

       8
       8
       +
       (** Get a value from storage *)

     

       9
       9
       +
       val get : t -> key:string -> string option

     

       10
       10
       +
       

     

       11
       11
       +
       (** Store a value in storage *)

     

       12
       12
       +
       val put : t -> key:string -> value:string -> (unit, Zulip.Error.t) result

     

       13
       13
       +
       

     

       14
       14
       +
       (** Check if a key exists in storage *)

     

       15
       15
       +
       val contains : t -> key:string -> bool

     

       16
       16
       +
       

     

       17
       17
       +
       (** Remove a key from storage *)

     

       18
       18
       +
       val remove : t -> key:string -> (unit, Zulip.Error.t) result

     

       19
       19
       +
       

     

       20
       20
       +
       (** List all keys in storage *)

     

       21
       21
       +
       val keys : t -> (string list, Zulip.Error.t) result

stack/zulip/lib/zulip_bot/lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (public_name zulip_bot)

     

       3
       3
       +
        (name zulip_bot)

     

       4
       4
       +
        (libraries zulip unix eio))

+35

stack/zulip/lib/zulip_botserver/lib/bot_registry.mli

···

       1
       1
       +
       (** Registry for managing multiple bots *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Bot module definition *)

     

       4
       4
       +
       module Bot_module : sig

     

       5
       5
       +
         type t

     

       6
       6
       +
       

     

       7
       7
       +
         val create :

     

       8
       8
       +
           name:string ->

     

       9
       9
       +
           handler:(module Zulip_bot.Bot_handler.Bot_handler) ->

     

       10
       10
       +
           create_config:(Server_config.Bot_config.t -> (Zulip_bot.Bot_config.t, Zulip.Error.t) result) ->

     

       11
       11
       +
           t

     

       12
       12
       +
       

     

       13
       13
       +
         val name : t -> string

     

       14
       14
       +
         val create_handler : t -> Server_config.Bot_config.t -> Zulip.Client.t -> (Zulip_bot.Bot_handler.t, Zulip.Error.t) result

     

       15
       15
       +
       end

     

       16
       16
       +
       

     

       17
       17
       +
       type t

     

       18
       18
       +
       

     

       19
       19
       +
       (** Create a new bot registry *)

     

       20
       20
       +
       val create : unit -> t

     

       21
       21
       +
       

     

       22
       22
       +
       (** Register a bot module *)

     

       23
       23
       +
       val register : t -> Bot_module.t -> unit

     

       24
       24
       +
       

     

       25
       25
       +
       (** Get a bot handler by email *)

     

       26
       26
       +
       val get_bot : t -> email:string -> Zulip_bot.Bot_handler.t option

     

       27
       27
       +
       

     

       28
       28
       +
       (** Load a bot module from file *)

     

       29
       29
       +
       val load_from_file : string -> (Bot_module.t, Zulip.Error.t) result

     

       30
       30
       +
       

     

       31
       31
       +
       (** Load bot modules from directory *)

     

       32
       32
       +
       val load_from_directory : string -> (Bot_module.t list, Zulip.Error.t) result

     

       33
       33
       +
       

     

       34
       34
       +
       (** List all registered bot emails *)

     

       35
       35
       +
       val list_bots : t -> string list

+22

stack/zulip/lib/zulip_botserver/lib/bot_server.mli

···

       1
       1
       +
       (** Main bot server implementation *)

     

       2
       2
       +
       

     

       3
       3
       +
       type t

     

       4
       4
       +
       

     

       5
       5
       +
       (** Create a bot server *)

     

       6
       6
       +
       val create : 

     

       7
       7
       +
         config:Server_config.t ->

     

       8
       8
       +
         registry:Bot_registry.t ->

     

       9
       9
       +
         (t, Zulip.Error.t) result

     

       10
       10
       +
       

     

       11
       11
       +
       (** Start the bot server *)

     

       12
       12
       +
       val run : t -> unit

     

       13
       13
       +
       

     

       14
       14
       +
       (** Stop the bot server gracefully *)

     

       15
       15
       +
       val shutdown : t -> unit

     

       16
       16
       +
       

     

       17
       17
       +
       (** Resource-safe server management *)

     

       18
       18
       +
       val with_server : 

     

       19
       19
       +
         config:Server_config.t ->

     

       20
       20
       +
         registry:Bot_registry.t ->

     

       21
       21
       +
         (t -> 'a) ->

     

       22
       22
       +
         ('a, Zulip.Error.t) result

stack/zulip/lib/zulip_botserver/lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (public_name zulip_botserver)

     

       3
       3
       +
        (name zulip_botserver)

     

       4
       4
       +
        (libraries zulip zulip_bot)

     

       5
       5
       +
        (modules_without_implementation bot_registry bot_server server_config webhook_handler))

+40

stack/zulip/lib/zulip_botserver/lib/server_config.mli

···

       1
       1
       +
       (** Bot server configuration *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Configuration for a single bot *)

     

       4
       4
       +
       module Bot_config : sig

     

       5
       5
       +
         type t

     

       6
       6
       +
         

     

       7
       7
       +
         val create : 

     

       8
       8
       +
           email:string ->

     

       9
       9
       +
           api_key:string ->

     

       10
       10
       +
           server_url:string ->

     

       11
       11
       +
           token:string ->

     

       12
       12
       +
           config_path:string option ->

     

       13
       13
       +
           t

     

       14
       14
       +
           

     

       15
       15
       +
         val email : t -> string

     

       16
       16
       +
         val api_key : t -> string

     

       17
       17
       +
         val server_url : t -> string

     

       18
       18
       +
         val token : t -> string

     

       19
       19
       +
         val config_path : t -> string option

     

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

     

       21
       21
       +
       end

     

       22
       22
       +
       

     

       23
       23
       +
       (** Server configuration *)

     

       24
       24
       +
       type t

     

       25
       25
       +
       

     

       26
       26
       +
       val create : 

     

       27
       27
       +
         ?host:string ->

     

       28
       28
       +
         ?port:int ->

     

       29
       29
       +
         bots:Bot_config.t list ->

     

       30
       30
       +
         unit ->

     

       31
       31
       +
         t

     

       32
       32
       +
       

     

       33
       33
       +
       val from_file : string -> (t, Zulip.Error.t) result

     

       34
       34
       +
       val from_env : unit -> (t, Zulip.Error.t) result

     

       35
       35
       +
       

     

       36
       36
       +
       val host : t -> string

     

       37
       37
       +
       val port : t -> int

     

       38
       38
       +
       val bots : t -> Bot_config.t list

     

       39
       39
       +
       

     

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

+33

stack/zulip/lib/zulip_botserver/lib/webhook_handler.mli

···

       1
       1
       +
       (** Webhook processing for bot server *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Webhook event data *)

     

       4
       4
       +
       module Webhook_event : sig

     

       5
       5
       +
         type trigger = [`Direct_message | `Mention]

     

       6
       6
       +
         

     

       7
       7
       +
         type t

     

       8
       8
       +
         

     

       9
       9
       +
         val create : 

     

       10
       10
       +
           bot_email:string ->

     

       11
       11
       +
           token:string ->

     

       12
       12
       +
           message:Zulip.Error.json ->

     

       13
       13
       +
           trigger:trigger ->

     

       14
       14
       +
           t

     

       15
       15
       +
           

     

       16
       16
       +
         val bot_email : t -> string

     

       17
       17
       +
         val token : t -> string

     

       18
       18
       +
         val message : t -> Zulip.Error.json

     

       19
       19
       +
         val trigger : t -> trigger

     

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

     

       21
       21
       +
       end

     

       22
       22
       +
       

     

       23
       23
       +
       (** Parse webhook data from HTTP request *)

     

       24
       24
       +
       val parse_webhook : string -> (Webhook_event.t, Zulip.Error.t) result

     

       25
       25
       +
       

     

       26
       26
       +
       (** Process webhook with bot registry *)

     

       27
       27
       +
       val handle_webhook : 

     

       28
       28
       +
         Bot_registry.t -> 

     

       29
       29
       +
         Webhook_event.t -> 

     

       30
       30
       +
         (Zulip_bot.Bot_handler.Response.t option, Zulip.Error.t) result

     

       31
       31
       +
       

     

       32
       32
       +
       (** Validate webhook token *)

     

       33
       33
       +
       val validate_token : Server_config.Bot_config.t -> string -> bool