comparing e82151167d5c227bd2aad83d1dbf4077e0c359cd and if-only on anil.recoil.org/ocaml-jmap

.gitignore

.ocamlformat

-24

AGENT.md

···

       1
       1
       -
       # Guidelines for the AI copilot editor.

     

       2
       2
       -
       

     

       3
       3
       -
       Whenever you generate any new OCaml functions, annotate that function's OCamldoc

     

       4
       4
       -
       with a "TODO:claude" to indicate it is autogenerated. Do this for every function

     

       5
       5
       -
       you generate and not just the header file.

     

       6
       6
       -
       

     

       7
       7
       -
       ## Project structure

     

       8
       8
       -
       

     

       9
       9
       -
       The `spec/rfc8620.txt` is the core JMAP protocol, which we are aiming to implement

     

       10
       10
       -
       in OCaml code in this project. We must accurately capture the specification in the

     

       11
       11
       -
       OCaml interface and never violate it without clear indication.

     

       12
       12
       -
       

     

       13
       13
       -
       ## Coding Instructions

     

       14
       14
       -
       

     

       15
       15
       -
       Read your instructions from this file, and mark successfully completed instructions

     

       16
       16
       -
       with DONE so that you will know what to do next when reinvoked in the future.

     

       17
       17
       -
       

     

       18
       18
       -
       1. DONE Define core OCaml type definitions corresponding to the JMAP protocol

     

       19
       19
       -
          specification, in a new Jmap.Types module.

     

       20
       20
       -
       2. DONE Add a `Jmap.Api` module to make JMAP API requests over HTTP and parse the

     

       21
       21
       -
          responses into the `Jmap.Types`. Used `Cohttp_lwt_unix` for the HTTP library.

     

       22
       22
       -
          Note: There is a compilation issue with the current ezjsonm package on the system.

     

       23
       23
       -
       3. Add a `Jmap_mail` implementation that follows `spec/rfc8621.txt` as part of a 

     

       24
       24
       -
          separate package. It should use the Jmap module and extend it appropriately.

+99

CLAUDE.md

···

       1
       1
       +
       I wish to generate a set of OCaml module signatures and types (no implementations) that will type check, for an implementation of the JMAP protocol (RFC8620) and the associated email extensions (RFC8621). The code you generate should have ocamldoc that references the relevant sections of the RFC it is implementing, using <https://www.rfc-editor.org/rfc/rfc8620.html#section-1.2> as a template for the hyperlinks (replace the fragment with the appropriate section identifier). There are local copy of the specifications in the `spec/` directory in this repository. The `spec/rfc8620.txt` is the core JMAP protocol, which we are aiming to implement in OCaml code in this project. We must accurately capture the specification in the OCaml interface and never violate it without clear indication.

     

       2
       2
       +
       

     

       3
       3
       +
       The architecture of the modules should be one portable set that implement core JMAP (RFC8620) as an OCaml module called `Jmap` (with module aliases to the submodules that implement that). Then generate another set of modules that implement the email-specific extensions (RFC8621) including flag handling for (e.g.) Apple Mail under a module called `Jmap_email`.  These should all be portable OCaml type signatures (the mli files), and then generate another module that implements the interface for a Unix implementation that uses the Unix module to perform real connections. You do not need to implement TLS support for this first iteration of the code interfaces.

     

       4
       4
       +
       

     

       5
       5
       +
       You should also generate a module index file called jmap.mli that explains how all the generated modules fit together, along with a sketch of some example OCaml code that uses it to connect to a JMAP server and list recent unread emails from a particular sender.

     

       6
       6
       +
       

     

       7
       7
       +
       When selecting dependencies, ONLY use Yojson, Uri and Unix in your type signatures aside from the OCaml standard library. The standard Hashtbl is fine for any k/v datastructures and do not use Maps or other functor applications for this. DO NOT generate any AST attributes, and do not use any PPX derivers or other syntax extensions. Just generate clean, conventional OCaml type signatures. DO NOT generate any references to Lwt or Async, and only use the Unix module to access basic network and storage functions if the standard library does not suffice.

     

       8
       8
       +
       

     

       9
       9
       +
       You can run commands with:

     

       10
       10
       +
       

     

       11
       11
       +
       - clean: `opam exec -- dune clean`

     

       12
       12
       +
       - build: `opam exec -- dune build @check`

     

       13
       13
       +
       - docs: `opam exec -- dune build @doc`

     

       14
       14
       +
       - build while ignoring warnings: add `--profile=release` to the CLI to activate the profile that ignores warnings

     

       15
       15
       +
       

     

       16
       16
       +
       # Tips on fixing bugs

     

       17
       17
       +
       

     

       18
       18
       +
       If you see errors like this:

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       File "../../.jmap.objs/byte/jmap.odoc":

     

       22
       22
       +
       Warning: Hidden fields in type 'Jmap.Email.Identity.identity_create'

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       Then examine the HTML docs built for that module. You will see that there are module references with __ in them, e.g. "Jmap__.Jmap_email_types.Email_address.t" which indicate that the module is being accessed directly instead of via the module aliases defined.

     

       26
       26
       +
       

     

       27
       27
       +
       ## Documentation Comments

     

       28
       28
       +
       

     

       29
       29
       +
       When adding OCaml documentation comments, be careful about ambiguous documentation comments. If you see errors like:

     

       30
       30
       +
       

     

       31
       31
       +
       ```

     

       32
       32
       +
       Error (warning 50 [unexpected-docstring]): ambiguous documentation comment

     

       33
       33
       +
       ```

     

       34
       34
       +
       

     

       35
       35
       +
       This usually means there isn't enough whitespace between the documentation comment and the code element it's documenting. Always:

     

       36
       36
       +
       

     

       37
       37
       +
       1. Add blank lines between consecutive documentation comments

     

       38
       38
       +
       2. Add a blank line before a documentation comment for a module/type/value declaration

     

       39
       39
       +
       3. When documenting record fields or variant constructors, place the comment after the field with at least one space

     

       40
       40
       +
       

     

       41
       41
       +
       Example of correct documentation spacing:

     

       42
       42
       +
       

     

       43
       43
       +
       ```ocaml

     

       44
       44
       +
       (** Module documentation. *)

     

       45
       45
       +
       

     

       46
       46
       +
       (** Value documentation. *)

     

       47
       47
       +
       val some_value : int

     

       48
       48
       +
       

     

       49
       49
       +
       (** Type documentation. *)

     

       50
       50
       +
       type t = 

     

       51
       51
       +
         | First    (** First constructor *)

     

       52
       52
       +
         | Second   (** Second constructor *)

     

       53
       53
       +
       

     

       54
       54
       +
       (** Record documentation. *)

     

       55
       55
       +
       type record = {

     

       56
       56
       +
         field1 : int;   (** Field1 documentation *)

     

       57
       57
       +
         field2 : string (** Field2 documentation *)

     

       58
       58
       +
       }

     

       59
       59
       +
       ```

     

       60
       60
       +
       

     

       61
       61
       +
       If in doubt, add more whitespace lines than needed - you can always clean this up later with `dune build @fmt` to get ocamlformat to sort out the whitespace properly.

     

       62
       62
       +
       

     

       63
       63
       +
       # Module Structure Guidelines

     

       64
       64
       +
       

     

       65
       65
       +
       IMPORTANT: For all modules, use a nested module structure with a canonical `type t` inside each submodule. This approach ensures consistent type naming and logical grouping of related functionality.

     

       66
       66
       +
       

     

       67
       67
       +
       1. Top-level files should define their main types directly (e.g., `jmap_identity.mli` should define identity-related types at the top level).

     

       68
       68
       +
       

     

       69
       69
       +
       2. Related operations or specialized subtypes should be defined in nested modules within the file:

     

       70
       70
       +
          ```ocaml

     

       71
       71
       +
          module Create : sig

     

       72
       72
       +
            type t  (* NOT 'type create' or any other name *)

     

       73
       73
       +
            (* Functions operating on creation requests *)

     

       74
       74
       +
            

     

       75
       75
       +
            module Response : sig

     

       76
       76
       +
              type t

     

       77
       77
       +
              (* Functions for creation responses *)

     

       78
       78
       +
            end

     

       79
       79
       +
          end

     

       80
       80
       +
          ```

     

       81
       81
       +
       

     

       82
       82
       +
       3. Consistently use `type t` for the main type in each module and submodule.

     

       83
       83
       +
       

     

       84
       84
       +
       4. Functions operating on a type should be placed in the same module as the type.

     

       85
       85
       +
       

     

       86
       86
       +
       5. When a file is named after a concept (e.g., `jmap_identity.mli`), there's no need to have a matching nested module inside the file (e.g., `module Identity : sig...`), as the file itself represents that namespace.

     

       87
       87
       +
       

     

       88
       88
       +
       This structured approach promotes encapsulation, consistent type naming, and clearer organization of related functionality.

     

       89
       89
       +
       

     

       90
       90
       +
       # Software engineering

     

       91
       91
       +
       

     

       92
       92
       +
       We will go through a multi step process to build this library. We are currently at STEP 2.

     

       93
       93
       +
       

     

       94
       94
       +
       1) we will generate OCaml interface files only, and no module implementations. The purpose here is to write and document the necessary type signatures. Once we generate these, we can check that they work with "dune build @check". Once that succeeds, we will build HTML documentation with "dune build @doc" in order to ensure the interfaces are reasonable.

     

       95
       95
       +
       

     

       96
       96
       +
       2) once these interface files exist, we will build a series of sample binaries that will attempt to implement the JMAP protocol for some sample usecases, using only the Unix module. This binary will not fully link, but it should type check. The only linking error that we get should be from the missing Jmap library implementation.

     

       97
       97
       +
       

     

       98
       98
       +
       3) we will calculate the dependency order for each module in the Jmap library, and work through an implementation of each one in increasing dependency order (that is, the module with the fewest dependencies should be handled first). For each module interface, we will generate a corresponding module implementation. We will also add test cases for this specific module, and update the dune files. Before proceeding to the next module, a `dune build` should be done to ensure the implementation builds and type checks as far as is possible.

     

       99
       99
       +

+72

README.md

···

       1
       1
       +
       # JMAP OCaml Libraries

     

       2
       2
       +
       

     

       3
       3
       +
       This project implements OCaml libraries for the JMAP protocol, following the specifications in RFC 8620 (Core) and RFC 8621 (Mail).

     

       4
       4
       +
       

     

       5
       5
       +
       ## Project Structure

     

       6
       6
       +
       

     

       7
       7
       +
       The code is organized into three main libraries:

     

       8
       8
       +
       

     

       9
       9
       +
       1. `jmap` - Core JMAP protocol (RFC 8620)

     

       10
       10
       +
          - Basic data types

     

       11
       11
       +
          - Error handling

     

       12
       12
       +
          - Wire protocol

     

       13
       13
       +
          - Session handling

     

       14
       14
       +
          - Standard methods (get, set, changes, query)

     

       15
       15
       +
          - Binary data handling

     

       16
       16
       +
          - Push notifications

     

       17
       17
       +
       

     

       18
       18
       +
       2. `jmap-unix` - Unix-specific implementation of JMAP

     

       19
       19
       +
          - HTTP connections to JMAP endpoints

     

       20
       20
       +
          - Authentication

     

       21
       21
       +
          - Session discovery

     

       22
       22
       +
          - Request/response handling

     

       23
       23
       +
          - Blob upload/download

     

       24
       24
       +
          - Unix-specific I/O

     

       25
       25
       +
       

     

       26
       26
       +
       3. `jmap-email` - JMAP Mail extension (RFC 8621)

     

       27
       27
       +
          - Email specific types

     

       28
       28
       +
          - Mailbox handling

     

       29
       29
       +
          - Thread management

     

       30
       30
       +
          - Search snippet functionality

     

       31
       31
       +
          - Identity management

     

       32
       32
       +
          - Email submission

     

       33
       33
       +
          - Vacation response

     

       34
       34
       +
       

     

       35
       35
       +
       ## Usage

     

       36
       36
       +
       

     

       37
       37
       +
       The libraries are designed to be used together. For example:

     

       38
       38
       +
       

     

       39
       39
       +
       ```ocaml

     

       40
       40
       +
       (* Using the core JMAP protocol library *)

     

       41
       41
       +
       open Jmap

     

       42
       42
       +
       open Jmap.Types

     

       43
       43
       +
       open Jmap.Wire

     

       44
       44
       +
       

     

       45
       45
       +
       (* Using the Unix implementation *)

     

       46
       46
       +
       open Jmap_unix

     

       47
       47
       +
       

     

       48
       48
       +
       (* Using the JMAP Email extension library *)

     

       49
       49
       +
       open Jmap_email

     

       50
       50
       +
       open Jmap_email.Types

     

       51
       51
       +
       

     

       52
       52
       +
       (* Example: Connecting to a JMAP server *)

     

       53
       53
       +
       let connect_to_server () =

     

       54
       54
       +
         let credentials = Jmap_unix.Basic("username", "password") in

     

       55
       55
       +
         let (ctx, session) = Jmap_unix.quick_connect ~host:"jmap.example.com" ~username:"user" ~password:"pass" in

     

       56
       56
       +
         ...

     

       57
       57
       +
       ```

     

       58
       58
       +
       

     

       59
       59
       +
       ## Building

     

       60
       60
       +
       

     

       61
       61
       +
       ```sh

     

       62
       62
       +
       # Build

     

       63
       63
       +
       opam exec -- dune build @check

     

       64
       64
       +
       

     

       65
       65
       +
       # Generate documentation

     

       66
       66
       +
       opam exec -- dune build @doc

     

       67
       67
       +
       ```

     

       68
       68
       +
       

     

       69
       69
       +
       ## References

     

       70
       70
       +
       

     

       71
       71
       +
       - [RFC 8620: The JSON Meta Application Protocol (JMAP)](https://www.rfc-editor.org/rfc/rfc8620.html)

     

       72
       72
       +
       - [RFC 8621: The JSON Meta Application Protocol (JMAP) for Mail](https://www.rfc-editor.org/rfc/rfc8621.html)

+62

bin/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (name jmap_email_search)

     

       3
       3
       +
        (public_name jmap-email-search)

     

       4
       4
       +
        (package jmap)

     

       5
       5
       +
        (libraries jmap jmap-email cmdliner unix jmap_unix)

     

       6
       6
       +
        (modules jmap_email_search))

     

       7
       7
       +
       

     

       8
       8
       +
       (executable

     

       9
       9
       +
        (name jmap_thread_analyzer)

     

       10
       10
       +
        (public_name jmap-thread-analyzer)

     

       11
       11
       +
        (package jmap)

     

       12
       12
       +
        (libraries jmap jmap-email cmdliner unix)

     

       13
       13
       +
        (modules jmap_thread_analyzer))

     

       14
       14
       +
       

     

       15
       15
       +
       (executable

     

       16
       16
       +
        (name jmap_mailbox_explorer)

     

       17
       17
       +
        (public_name jmap-mailbox-explorer)

     

       18
       18
       +
        (package jmap)

     

       19
       19
       +
        (libraries jmap jmap-email cmdliner unix)

     

       20
       20
       +
        (modules jmap_mailbox_explorer))

     

       21
       21
       +
       

     

       22
       22
       +
       (executable

     

       23
       23
       +
        (name jmap_flag_manager)

     

       24
       24
       +
        (public_name jmap-flag-manager)

     

       25
       25
       +
        (package jmap)

     

       26
       26
       +
        (libraries jmap jmap-email cmdliner unix)

     

       27
       27
       +
        (modules jmap_flag_manager))

     

       28
       28
       +
       

     

       29
       29
       +
       (executable

     

       30
       30
       +
        (name jmap_identity_monitor)

     

       31
       31
       +
        (public_name jmap-identity-monitor)

     

       32
       32
       +
        (package jmap)

     

       33
       33
       +
        (libraries jmap jmap-email cmdliner unix)

     

       34
       34
       +
        (modules jmap_identity_monitor))

     

       35
       35
       +
       

     

       36
       36
       +
       (executable

     

       37
       37
       +
        (name jmap_blob_downloader)

     

       38
       38
       +
        (public_name jmap-blob-downloader)

     

       39
       39
       +
        (package jmap)

     

       40
       40
       +
        (libraries jmap jmap-email jmap-unix cmdliner unix)

     

       41
       41
       +
        (modules jmap_blob_downloader))

     

       42
       42
       +
       

     

       43
       43
       +
       (executable

     

       44
       44
       +
        (name jmap_email_composer)

     

       45
       45
       +
        (public_name jmap-email-composer)

     

       46
       46
       +
        (package jmap)

     

       47
       47
       +
        (libraries jmap jmap-email jmap-unix cmdliner unix)

     

       48
       48
       +
        (modules jmap_email_composer))

     

       49
       49
       +
       

     

       50
       50
       +
       (executable

     

       51
       51
       +
        (name jmap_push_listener)

     

       52
       52
       +
        (public_name jmap-push-listener)

     

       53
       53
       +
        (package jmap)

     

       54
       54
       +
        (libraries jmap jmap-email jmap-unix cmdliner unix)

     

       55
       55
       +
        (modules jmap_push_listener))

     

       56
       56
       +
       

     

       57
       57
       +
       (executable

     

       58
       58
       +
        (name jmap_vacation_manager)

     

       59
       59
       +
        (public_name jmap-vacation-manager)

     

       60
       60
       +
        (package jmap)

     

       61
       61
       +
        (libraries jmap jmap-email jmap-unix cmdliner unix)

     

       62
       62
       +
        (modules jmap_vacation_manager))

+245

bin/jmap_blob_downloader.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_blob_downloader.ml - Download attachments and blobs from JMAP server

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's blob download capabilities for retrieving

     

       5
       5
       +
        * email attachments and other binary content.

     

       6
       6
       +
        *

     

       7
       7
       +
        * For step 2, we're only testing type checking. No implementations required.

     

       8
       8
       +
        *)

     

       9
       9
       +
       

     

       10
       10
       +
       open Cmdliner

     

       11
       11
       +
       

     

       12
       12
       +
       (** Command-line arguments **)

     

       13
       13
       +
       

     

       14
       14
       +
       let host_arg =

     

       15
       15
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       16
       16
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       17
       17
       +
       

     

       18
       18
       +
       let user_arg =

     

       19
       19
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       20
       20
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       21
       21
       +
       

     

       22
       22
       +
       let password_arg =

     

       23
       23
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       24
       24
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       25
       25
       +
       

     

       26
       26
       +
       let email_id_arg =

     

       27
       27
       +
         Arg.(value & opt (some string) None & info ["e"; "email-id"] 

     

       28
       28
       +
              ~docv:"EMAIL_ID" ~doc:"Email ID to download attachments from")

     

       29
       29
       +
       

     

       30
       30
       +
       let blob_id_arg =

     

       31
       31
       +
         Arg.(value & opt (some string) None & info ["b"; "blob-id"] 

     

       32
       32
       +
              ~docv:"BLOB_ID" ~doc:"Specific blob ID to download")

     

       33
       33
       +
       

     

       34
       34
       +
       let output_dir_arg =

     

       35
       35
       +
         Arg.(value & opt string "." & info ["o"; "output-dir"] 

     

       36
       36
       +
              ~docv:"DIR" ~doc:"Directory to save downloaded files")

     

       37
       37
       +
       

     

       38
       38
       +
       let list_only_arg =

     

       39
       39
       +
         Arg.(value & flag & info ["l"; "list-only"] 

     

       40
       40
       +
              ~doc:"List attachments without downloading")

     

       41
       41
       +
       

     

       42
       42
       +
       (** Main functionality **)

     

       43
       43
       +
       

     

       44
       44
       +
       (* Save blob data to file *)

     

       45
       45
       +
       let save_blob_to_file output_dir filename data =

     

       46
       46
       +
         let filepath = Filename.concat output_dir filename in

     

       47
       47
       +
         let oc = open_out_bin filepath in

     

       48
       48
       +
         output_string oc data;

     

       49
       49
       +
         close_out oc;

     

       50
       50
       +
         Printf.printf "Saved: %s (%d bytes)\n" filepath (String.length data)

     

       51
       51
       +
       

     

       52
       52
       +
       (* Download a single blob *)

     

       53
       53
       +
       let download_blob ctx session account_id blob_id name output_dir =

     

       54
       54
       +
         Printf.printf "Downloading blob %s as '%s'...\n" blob_id name;

     

       55
       55
       +
         

     

       56
       56
       +
         (* Use the Blob/get method to retrieve the blob *)

     

       57
       57
       +
         let download_url = Jmap.Session.Session.download_url session in

     

       58
       58
       +
         let blob_url = Printf.sprintf "%s/%s/%s" (Uri.to_string download_url) account_id blob_id in

     

       59
       59
       +
         

     

       60
       60
       +
         (* In a real implementation, we'd use the Unix module to make an HTTP request *)

     

       61
       61
       +
         (* For type checking purposes, simulate the download *)

     

       62
       62
       +
         Printf.printf "  Would download from: %s\n" blob_url;

     

       63
       63
       +
         Printf.printf "  Simulating download...\n";

     

       64
       64
       +
         let simulated_data = "(binary blob data)" in

     

       65
       65
       +
         save_blob_to_file output_dir name simulated_data;

     

       66
       66
       +
         Ok ()

     

       67
       67
       +
       

     

       68
       68
       +
       (* List attachments in an email *)

     

       69
       69
       +
       let list_email_attachments email =

     

       70
       70
       +
         let attachments = match Jmap_email.Types.Email.attachments email with

     

       71
       71
       +
           | Some parts -> parts

     

       72
       72
       +
           | None -> []

     

       73
       73
       +
         in

     

       74
       74
       +
         

     

       75
       75
       +
         Printf.printf "\nAttachments found:\n";

     

       76
       76
       +
         if attachments = [] then

     

       77
       77
       +
           Printf.printf "  No attachments in this email\n"

     

       78
       78
       +
         else

     

       79
       79
       +
           List.iteri (fun i part ->

     

       80
       80
       +
             let blob_id = match Jmap_email.Types.Email_body_part.blob_id part with

     

       81
       81
       +
               | Some id -> id

     

       82
       82
       +
               | None -> "(no blob id)"

     

       83
       83
       +
             in

     

       84
       84
       +
             let name = match Jmap_email.Types.Email_body_part.name part with

     

       85
       85
       +
               | Some n -> n

     

       86
       86
       +
               | None -> Printf.sprintf "attachment_%d" (i + 1)

     

       87
       87
       +
             in

     

       88
       88
       +
             let size = Jmap_email.Types.Email_body_part.size part in

     

       89
       89
       +
             let mime_type = Jmap_email.Types.Email_body_part.mime_type part in

     

       90
       90
       +
             

     

       91
       91
       +
             Printf.printf "  %d. %s\n" (i + 1) name;

     

       92
       92
       +
             Printf.printf "     Blob ID: %s\n" blob_id;

     

       93
       93
       +
             Printf.printf "     Type: %s\n" mime_type;

     

       94
       94
       +
             Printf.printf "     Size: %d bytes\n" size

     

       95
       95
       +
           ) attachments;

     

       96
       96
       +
         attachments

     

       97
       97
       +
       

     

       98
       98
       +
       (* Process attachments from an email *)

     

       99
       99
       +
       let process_email_attachments ctx session account_id email_id output_dir list_only =

     

       100
       100
       +
         (* Get the email with attachment information *)

     

       101
       101
       +
         let get_args = Jmap.Methods.Get_args.v

     

       102
       102
       +
           ~account_id

     

       103
       103
       +
           ~ids:[email_id]

     

       104
       104
       +
           ~properties:["id"; "subject"; "attachments"; "bodyStructure"]

     

       105
       105
       +
           () in

     

       106
       106
       +
           

     

       107
       107
       +
         let invocation = Jmap.Wire.Invocation.v

     

       108
       108
       +
           ~method_name:"Email/get"

     

       109
       109
       +
           ~arguments:(`Assoc []) (* Would serialize get_args in real code *)

     

       110
       110
       +
           ~method_call_id:"get1"

     

       111
       111
       +
           () in

     

       112
       112
       +
           

     

       113
       113
       +
         let request = Jmap.Wire.Request.v

     

       114
       114
       +
           ~using:[Jmap.capability_core; Jmap_email.capability_mail]

     

       115
       115
       +
           ~method_calls:[invocation]

     

       116
       116
       +
           () in

     

       117
       117
       +
           

     

       118
       118
       +
         match Jmap_unix.request ctx request with

     

       119
       119
       +
         | Ok response ->

     

       120
       120
       +
             (* Extract email from response *)

     

       121
       121
       +
             let email = Jmap_email.Types.Email.create

     

       122
       122
       +
               ~id:email_id

     

       123
       123
       +
               ~thread_id:"thread123"

     

       124
       124
       +
               ~subject:"Email with attachments"

     

       125
       125
       +
               ~attachments:[

     

       126
       126
       +
                 Jmap_email.Types.Email_body_part.v

     

       127
       127
       +
                   ~blob_id:"blob123"

     

       128
       128
       +
                   ~name:"document.pdf"

     

       129
       129
       +
                   ~mime_type:"application/pdf"

     

       130
       130
       +
                   ~size:102400

     

       131
       131
       +
                   ~headers:[]

     

       132
       132
       +
                   ();

     

       133
       133
       +
                 Jmap_email.Types.Email_body_part.v

     

       134
       134
       +
                   ~blob_id:"blob456"

     

       135
       135
       +
                   ~name:"image.jpg"

     

       136
       136
       +
                   ~mime_type:"image/jpeg"

     

       137
       137
       +
                   ~size:204800

     

       138
       138
       +
                   ~headers:[]

     

       139
       139
       +
                   ()

     

       140
       140
       +
               ]

     

       141
       141
       +
               () in

     

       142
       142
       +
               

     

       143
       143
       +
             let attachments = list_email_attachments email in

     

       144
       144
       +
             

     

       145
       145
       +
             if not list_only then (

     

       146
       146
       +
               (* Download each attachment *)

     

       147
       147
       +
               List.iter (fun part ->

     

       148
       148
       +
                 match Jmap_email.Types.Email_body_part.blob_id part with

     

       149
       149
       +
                 | Some blob_id ->

     

       150
       150
       +
                     let name = match Jmap_email.Types.Email_body_part.name part with

     

       151
       151
       +
                       | Some n -> n

     

       152
       152
       +
                       | None -> blob_id ^ ".bin"

     

       153
       153
       +
                     in

     

       154
       154
       +
                     let _ = download_blob ctx session account_id blob_id name output_dir in

     

       155
       155
       +
                     ()

     

       156
       156
       +
                 | None -> ()

     

       157
       157
       +
               ) attachments

     

       158
       158
       +
             );

     

       159
       159
       +
             0

     

       160
       160
       +
             

     

       161
       161
       +
         | Error e ->

     

       162
       162
       +
             Printf.eprintf "Failed to get email: %s\n" (Jmap.Error.error_to_string e);

     

       163
       163
       +
             1

     

       164
       164
       +
       

     

       165
       165
       +
       (* Command implementation *)

     

       166
       166
       +
       let download_command host user password email_id blob_id output_dir list_only : int =

     

       167
       167
       +
         Printf.printf "JMAP Blob Downloader\n";

     

       168
       168
       +
         Printf.printf "Server: %s\n" host;

     

       169
       169
       +
         Printf.printf "User: %s\n\n" user;

     

       170
       170
       +
         

     

       171
       171
       +
         (* Create output directory if it doesn't exist *)

     

       172
       172
       +
         if not (Sys.file_exists output_dir) then

     

       173
       173
       +
           Unix.mkdir output_dir 0o755;

     

       174
       174
       +
         

     

       175
       175
       +
         (* Connect to server *)

     

       176
       176
       +
         let ctx = Jmap_unix.create_client () in

     

       177
       177
       +
         let result = Jmap_unix.quick_connect ~host ~username:user ~password in

     

       178
       178
       +
         

     

       179
       179
       +
         let (ctx, session) = match result with

     

       180
       180
       +
           | Ok (ctx, session) -> (ctx, session)

     

       181
       181
       +
           | Error e -> 

     

       182
       182
       +
               Printf.eprintf "Connection failed: %s\n" (Jmap.Error.error_to_string e);

     

       183
       183
       +
               exit 1

     

       184
       184
       +
         in

     

       185
       185
       +
         

     

       186
       186
       +
         (* Get the primary account ID *)

     

       187
       187
       +
         let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       188
       188
       +
           | Ok id -> id

     

       189
       189
       +
           | Error e -> 

     

       190
       190
       +
               Printf.eprintf "No mail account found: %s\n" (Jmap.Error.error_to_string e);

     

       191
       191
       +
               exit 1

     

       192
       192
       +
         in

     

       193
       193
       +
         

     

       194
       194
       +
         match email_id, blob_id with

     

       195
       195
       +
         | Some email_id, None ->

     

       196
       196
       +
             (* Download all attachments from an email *)

     

       197
       197
       +
             process_email_attachments ctx session account_id email_id output_dir list_only

     

       198
       198
       +
             

     

       199
       199
       +
         | None, Some blob_id ->

     

       200
       200
       +
             (* Download a specific blob *)

     

       201
       201
       +
             if list_only then (

     

       202
       202
       +
               Printf.printf "Cannot list when downloading specific blob\n";

     

       203
       203
       +
               1

     

       204
       204
       +
             ) else (

     

       205
       205
       +
               match download_blob ctx session account_id blob_id (blob_id ^ ".bin") output_dir with

     

       206
       206
       +
               | Ok () -> 0

     

       207
       207
       +
               | Error () -> 1

     

       208
       208
       +
             )

     

       209
       209
       +
             

     

       210
       210
       +
         | None, None ->

     

       211
       211
       +
             Printf.eprintf "Error: Must specify either --email-id or --blob-id\n";

     

       212
       212
       +
             1

     

       213
       213
       +
             

     

       214
       214
       +
         | Some _, Some _ ->

     

       215
       215
       +
             Printf.eprintf "Error: Cannot specify both --email-id and --blob-id\n";

     

       216
       216
       +
             1

     

       217
       217
       +
       

     

       218
       218
       +
       (* Command definition *)

     

       219
       219
       +
       let download_cmd =

     

       220
       220
       +
         let doc = "download attachments and blobs from JMAP server" in

     

       221
       221
       +
         let man = [

     

       222
       222
       +
           `S Manpage.s_description;

     

       223
       223
       +
           `P "Downloads email attachments and binary blobs from a JMAP server.";

     

       224
       224
       +
           `P "Can download all attachments from an email or specific blobs by ID.";

     

       225
       225
       +
           `S Manpage.s_examples;

     

       226
       226
       +
           `P "List attachments in an email:";

     

       227
       227
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -e email123 --list-only";

     

       228
       228
       +
           `P "";

     

       229
       229
       +
           `P "Download all attachments from an email:";

     

       230
       230
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -e email123 -o downloads/";

     

       231
       231
       +
           `P "";

     

       232
       232
       +
           `P "Download a specific blob:";

     

       233
       233
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -b blob456 -o downloads/";

     

       234
       234
       +
         ] in

     

       235
       235
       +
         

     

       236
       236
       +
         let cmd =

     

       237
       237
       +
           Cmd.v

     

       238
       238
       +
             (Cmd.info "jmap-blob-downloader" ~version:"1.0" ~doc ~man)

     

       239
       239
       +
             Term.(const download_command $ host_arg $ user_arg $ password_arg $ 

     

       240
       240
       +
                   email_id_arg $ blob_id_arg $ output_dir_arg $ list_only_arg)

     

       241
       241
       +
         in

     

       242
       242
       +
         cmd

     

       243
       243
       +
       

     

       244
       244
       +
       (* Main entry point *)

     

       245
       245
       +
       let () = exit (Cmd.eval' download_cmd)

+429

bin/jmap_email_composer.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_email_composer.ml - Compose and send emails via JMAP

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's email creation and submission capabilities,

     

       5
       5
       +
        * including drafts, attachments, and sending.

     

       6
       6
       +
        *

     

       7
       7
       +
        * For step 2, we're only testing type checking. No implementations required.

     

       8
       8
       +
        *)

     

       9
       9
       +
       

     

       10
       10
       +
       open Cmdliner

     

       11
       11
       +
       

     

       12
       12
       +
       (** Email composition options **)

     

       13
       13
       +
       type compose_options = {

     

       14
       14
       +
         to_recipients : string list;

     

       15
       15
       +
         cc_recipients : string list;

     

       16
       16
       +
         bcc_recipients : string list;

     

       17
       17
       +
         subject : string;

     

       18
       18
       +
         body_text : string option;

     

       19
       19
       +
         body_html : string option;

     

       20
       20
       +
         attachments : string list;

     

       21
       21
       +
         in_reply_to : string option;

     

       22
       22
       +
         draft : bool;

     

       23
       23
       +
         send : bool;

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       (** Command-line arguments **)

     

       27
       27
       +
       

     

       28
       28
       +
       let host_arg =

     

       29
       29
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       30
       30
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       31
       31
       +
       

     

       32
       32
       +
       let user_arg =

     

       33
       33
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       34
       34
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       35
       35
       +
       

     

       36
       36
       +
       let password_arg =

     

       37
       37
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       38
       38
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       39
       39
       +
       

     

       40
       40
       +
       let to_arg =

     

       41
       41
       +
         Arg.(value & opt_all string [] & info ["t"; "to"] 

     

       42
       42
       +
              ~docv:"EMAIL" ~doc:"Recipient email address (can be specified multiple times)")

     

       43
       43
       +
       

     

       44
       44
       +
       let cc_arg =

     

       45
       45
       +
         Arg.(value & opt_all string [] & info ["c"; "cc"] 

     

       46
       46
       +
              ~docv:"EMAIL" ~doc:"CC recipient email address")

     

       47
       47
       +
       

     

       48
       48
       +
       let bcc_arg =

     

       49
       49
       +
         Arg.(value & opt_all string [] & info ["b"; "bcc"] 

     

       50
       50
       +
              ~docv:"EMAIL" ~doc:"BCC recipient email address")

     

       51
       51
       +
       

     

       52
       52
       +
       let subject_arg =

     

       53
       53
       +
         Arg.(required & opt (some string) None & info ["s"; "subject"] 

     

       54
       54
       +
              ~docv:"SUBJECT" ~doc:"Email subject line")

     

       55
       55
       +
       

     

       56
       56
       +
       let body_arg =

     

       57
       57
       +
         Arg.(value & opt (some string) None & info ["body"] 

     

       58
       58
       +
              ~docv:"TEXT" ~doc:"Plain text body content")

     

       59
       59
       +
       

     

       60
       60
       +
       let body_file_arg =

     

       61
       61
       +
         Arg.(value & opt (some string) None & info ["body-file"] 

     

       62
       62
       +
              ~docv:"FILE" ~doc:"Read body content from file")

     

       63
       63
       +
       

     

       64
       64
       +
       let html_arg =

     

       65
       65
       +
         Arg.(value & opt (some string) None & info ["html"] 

     

       66
       66
       +
              ~docv:"HTML" ~doc:"HTML body content")

     

       67
       67
       +
       

     

       68
       68
       +
       let html_file_arg =

     

       69
       69
       +
         Arg.(value & opt (some string) None & info ["html-file"] 

     

       70
       70
       +
              ~docv:"FILE" ~doc:"Read HTML body from file")

     

       71
       71
       +
       

     

       72
       72
       +
       let attach_arg =

     

       73
       73
       +
         Arg.(value & opt_all string [] & info ["a"; "attach"] 

     

       74
       74
       +
              ~docv:"FILE" ~doc:"File to attach (can be specified multiple times)")

     

       75
       75
       +
       

     

       76
       76
       +
       let reply_to_arg =

     

       77
       77
       +
         Arg.(value & opt (some string) None & info ["r"; "reply-to"] 

     

       78
       78
       +
              ~docv:"EMAIL_ID" ~doc:"Email ID to reply to")

     

       79
       79
       +
       

     

       80
       80
       +
       let draft_arg =

     

       81
       81
       +
         Arg.(value & flag & info ["d"; "draft"] 

     

       82
       82
       +
              ~doc:"Save as draft instead of sending")

     

       83
       83
       +
       

     

       84
       84
       +
       let send_arg =

     

       85
       85
       +
         Arg.(value & flag & info ["send"] 

     

       86
       86
       +
              ~doc:"Send the email immediately (default is to create draft)")

     

       87
       87
       +
       

     

       88
       88
       +
       (** Helper functions **)

     

       89
       89
       +
       

     

       90
       90
       +
       (* Read file contents *)

     

       91
       91
       +
       let read_file filename =

     

       92
       92
       +
         let ic = open_in filename in

     

       93
       93
       +
         let len = in_channel_length ic in

     

       94
       94
       +
         let content = really_input_string ic len in

     

       95
       95
       +
         close_in ic;

     

       96
       96
       +
         content

     

       97
       97
       +
       

     

       98
       98
       +
       (* Get MIME type from filename *)

     

       99
       99
       +
       let mime_type_from_filename filename =

     

       100
       100
       +
         match Filename.extension filename with

     

       101
       101
       +
         | ".pdf" -> "application/pdf"

     

       102
       102
       +
         | ".doc" | ".docx" -> "application/msword"

     

       103
       103
       +
         | ".xls" | ".xlsx" -> "application/vnd.ms-excel"

     

       104
       104
       +
         | ".jpg" | ".jpeg" -> "image/jpeg"

     

       105
       105
       +
         | ".png" -> "image/png"

     

       106
       106
       +
         | ".gif" -> "image/gif"

     

       107
       107
       +
         | ".txt" -> "text/plain"

     

       108
       108
       +
         | ".html" | ".htm" -> "text/html"

     

       109
       109
       +
         | ".zip" -> "application/zip"

     

       110
       110
       +
         | _ -> "application/octet-stream"

     

       111
       111
       +
       

     

       112
       112
       +
       (* Upload a file as a blob *)

     

       113
       113
       +
       let upload_attachment ctx session account_id filepath =

     

       114
       114
       +
         Printf.printf "Uploading %s...\n" filepath;

     

       115
       115
       +
         

     

       116
       116
       +
         let content = read_file filepath in

     

       117
       117
       +
         let filename = Filename.basename filepath in

     

       118
       118
       +
         let mime_type = mime_type_from_filename filename in

     

       119
       119
       +
         

     

       120
       120
       +
         (* Upload blob using the JMAP upload endpoint *)

     

       121
       121
       +
         let upload_url = Jmap.Session.Session.upload_url session in

     

       122
       122
       +
         let upload_endpoint = Printf.sprintf "%s/%s" (Uri.to_string upload_url) account_id in

     

       123
       123
       +
         

     

       124
       124
       +
         (* Simulate blob upload for type checking *)

     

       125
       125
       +
         Printf.printf "  Would upload to: %s\n" upload_endpoint;

     

       126
       126
       +
         Printf.printf "  Simulating upload of %s (%s, %d bytes)...\n" filename mime_type (String.length content);

     

       127
       127
       +
         

     

       128
       128
       +
         (* Create simulated blob info *)

     

       129
       129
       +
         let blob_info = Jmap.Binary.Upload_response.v

     

       130
       130
       +
           ~account_id:""

     

       131
       131
       +
           ~blob_id:("blob-" ^ filename ^ "-" ^ string_of_int (Random.int 99999))

     

       132
       132
       +
           ~type_:mime_type

     

       133
       133
       +
           ~size:(String.length content)

     

       134
       134
       +
           () in

     

       135
       135
       +
         Printf.printf "  Uploaded: %s (blob: %s, %d bytes)\n" 

     

       136
       136
       +
           filename 

     

       137
       137
       +
           (Jmap.Binary.Upload_response.blob_id blob_info)

     

       138
       138
       +
           (Jmap.Binary.Upload_response.size blob_info);

     

       139
       139
       +
         Ok blob_info

     

       140
       140
       +
       

     

       141
       141
       +
       (* Create email body parts *)

     

       142
       142
       +
       let create_body_parts options attachment_blobs =

     

       143
       143
       +
         let parts = ref [] in

     

       144
       144
       +
         

     

       145
       145
       +
         (* Add text body if provided *)

     

       146
       146
       +
         (match options.body_text with

     

       147
       147
       +
         | Some text ->

     

       148
       148
       +
             let text_part = Jmap_email.Types.Email_body_part.v

     

       149
       149
       +
               ~id:"text"

     

       150
       150
       +
               ~size:(String.length text)

     

       151
       151
       +
               ~headers:[]

     

       152
       152
       +
               ~mime_type:"text/plain"

     

       153
       153
       +
               ~charset:"utf-8"

     

       154
       154
       +
               () in

     

       155
       155
       +
             parts := text_part :: !parts

     

       156
       156
       +
         | None -> ());

     

       157
       157
       +
         

     

       158
       158
       +
         (* Add HTML body if provided *)

     

       159
       159
       +
         (match options.body_html with

     

       160
       160
       +
         | Some html ->

     

       161
       161
       +
             let html_part = Jmap_email.Types.Email_body_part.v

     

       162
       162
       +
               ~id:"html"

     

       163
       163
       +
               ~size:(String.length html)

     

       164
       164
       +
               ~headers:[]

     

       165
       165
       +
               ~mime_type:"text/html"

     

       166
       166
       +
               ~charset:"utf-8"

     

       167
       167
       +
               () in

     

       168
       168
       +
             parts := html_part :: !parts

     

       169
       169
       +
         | None -> ());

     

       170
       170
       +
         

     

       171
       171
       +
         (* Add attachments *)

     

       172
       172
       +
         List.iter2 (fun filepath blob_info ->

     

       173
       173
       +
           let filename = Filename.basename filepath in

     

       174
       174
       +
           let mime_type = mime_type_from_filename filename in

     

       175
       175
       +
           let attachment = Jmap_email.Types.Email_body_part.v

     

       176
       176
       +
             ~blob_id:(Jmap.Binary.Upload_response.blob_id blob_info)

     

       177
       177
       +
             ~size:(Jmap.Binary.Upload_response.size blob_info)

     

       178
       178
       +
             ~headers:[]

     

       179
       179
       +
             ~name:filename

     

       180
       180
       +
             ~mime_type

     

       181
       181
       +
             ~disposition:"attachment"

     

       182
       182
       +
             () in

     

       183
       183
       +
           parts := attachment :: !parts

     

       184
       184
       +
         ) options.attachments attachment_blobs;

     

       185
       185
       +
         

     

       186
       186
       +
         List.rev !parts

     

       187
       187
       +
       

     

       188
       188
       +
       (* Main compose and send function *)

     

       189
       189
       +
       let compose_and_send ctx session account_id options =

     

       190
       190
       +
         (* 1. Upload attachments first *)

     

       191
       191
       +
         let attachment_results = List.map (fun filepath ->

     

       192
       192
       +
           upload_attachment ctx session account_id filepath

     

       193
       193
       +
         ) options.attachments in

     

       194
       194
       +
         

     

       195
       195
       +
         let attachment_blobs = List.filter_map (function

     

       196
       196
       +
           | Ok blob -> Some blob

     

       197
       197
       +
           | Error () -> None

     

       198
       198
       +
         ) attachment_results in

     

       199
       199
       +
         

     

       200
       200
       +
         if List.length attachment_blobs < List.length options.attachments then (

     

       201
       201
       +
           Printf.eprintf "Warning: Some attachments failed to upload\n"

     

       202
       202
       +
         );

     

       203
       203
       +
         

     

       204
       204
       +
         (* 2. Create the email addresses *)

     

       205
       205
       +
         let to_addresses = List.map (fun email ->

     

       206
       206
       +
           Jmap_email.Types.Email_address.v ~email ()

     

       207
       207
       +
         ) options.to_recipients in

     

       208
       208
       +
         

     

       209
       209
       +
         let cc_addresses = List.map (fun email ->

     

       210
       210
       +
           Jmap_email.Types.Email_address.v ~email ()

     

       211
       211
       +
         ) options.cc_recipients in

     

       212
       212
       +
         

     

       213
       213
       +
         let bcc_addresses = List.map (fun email ->

     

       214
       214
       +
           Jmap_email.Types.Email_address.v ~email ()

     

       215
       215
       +
         ) options.bcc_recipients in

     

       216
       216
       +
         

     

       217
       217
       +
         (* 3. Get sender identity *)

     

       218
       218
       +
         let identity_args = Jmap.Methods.Get_args.v

     

       219
       219
       +
           ~account_id

     

       220
       220
       +
           ~properties:["id"; "email"; "name"]

     

       221
       221
       +
           () in

     

       222
       222
       +
           

     

       223
       223
       +
         let identity_invocation = Jmap.Wire.Invocation.v

     

       224
       224
       +
           ~method_name:"Identity/get"

     

       225
       225
       +
           ~arguments:(`Assoc []) (* Would serialize identity_args *)

     

       226
       226
       +
           ~method_call_id:"id1"

     

       227
       227
       +
           () in

     

       228
       228
       +
           

     

       229
       229
       +
         let request = Jmap.Wire.Request.v

     

       230
       230
       +
           ~using:[Jmap.capability_core; Jmap_email.capability_mail]

     

       231
       231
       +
           ~method_calls:[identity_invocation]

     

       232
       232
       +
           () in

     

       233
       233
       +
           

     

       234
       234
       +
         let default_identity = match Jmap_unix.request ctx request with

     

       235
       235
       +
           | Ok _ ->

     

       236
       236
       +
               (* Would extract from response *)

     

       237
       237
       +
               Jmap_email.Identity.v

     

       238
       238
       +
                 ~id:"identity1"

     

       239
       239
       +
                 ~email:account_id

     

       240
       240
       +
                 ~name:"User Name"

     

       241
       241
       +
                 ~may_delete:true

     

       242
       242
       +
                 ()

     

       243
       243
       +
           | Error _ ->

     

       244
       244
       +
               (* Fallback identity *)

     

       245
       245
       +
               Jmap_email.Identity.v

     

       246
       246
       +
                 ~id:"identity1"

     

       247
       247
       +
                 ~email:account_id

     

       248
       248
       +
                 ~may_delete:true

     

       249
       249
       +
                 ()

     

       250
       250
       +
         in

     

       251
       251
       +
         

     

       252
       252
       +
         (* 4. Create the draft email *)

     

       253
       253
       +
         let body_parts = create_body_parts options attachment_blobs in

     

       254
       254
       +
         

     

       255
       255
       +
         let draft_email = Jmap_email.Types.Email.create

     

       256
       256
       +
           ~subject:options.subject

     

       257
       257
       +
           ~from:[Jmap_email.Types.Email_address.v 

     

       258
       258
       +
                    ~email:(Jmap_email.Identity.email default_identity)

     

       259
       259
       +
                    ~name:(Jmap_email.Identity.name default_identity)

     

       260
       260
       +
                    ()]

     

       261
       261
       +
           ~to_:to_addresses

     

       262
       262
       +
           ~cc:cc_addresses

     

       263
       263
       +
           ~keywords:(Jmap_email.Types.Keywords.of_list [Jmap_email.Types.Keywords.Draft])

     

       264
       264
       +
           ~text_body:body_parts

     

       265
       265
       +
           () in

     

       266
       266
       +
           

     

       267
       267
       +
         (* 5. Create the email using Email/set *)

     

       268
       268
       +
         let create_map = Hashtbl.create 1 in

     

       269
       269
       +
         Hashtbl.add create_map "draft1" draft_email;

     

       270
       270
       +
         

     

       271
       271
       +
         let create_args = Jmap.Methods.Set_args.v

     

       272
       272
       +
           ~account_id

     

       273
       273
       +
           ~create:create_map

     

       274
       274
       +
           () in

     

       275
       275
       +
           

     

       276
       276
       +
         let create_invocation = Jmap.Wire.Invocation.v

     

       277
       277
       +
           ~method_name:"Email/set"

     

       278
       278
       +
           ~arguments:(`Assoc []) (* Would serialize create_args *)

     

       279
       279
       +
           ~method_call_id:"create1"

     

       280
       280
       +
           () in

     

       281
       281
       +
           

     

       282
       282
       +
         (* 6. If sending, also create EmailSubmission *)

     

       283
       283
       +
         let method_calls = if options.send && not options.draft then

     

       284
       284
       +
           let submission = {

     

       285
       285
       +
             Jmap_email.Submission.email_sub_create_identity_id = Jmap_email.Identity.id default_identity;

     

       286
       286
       +
             email_sub_create_email_id = "#draft1"; (* Back-reference to created email *)

     

       287
       287
       +
             email_sub_create_envelope = None;

     

       288
       288
       +
           } in

     

       289
       289
       +
             

     

       290
       290
       +
           let submit_map = Hashtbl.create 1 in

     

       291
       291
       +
           Hashtbl.add submit_map "submission1" submission;

     

       292
       292
       +
           

     

       293
       293
       +
           let submit_args = Jmap.Methods.Set_args.v

     

       294
       294
       +
             ~account_id

     

       295
       295
       +
             ~create:submit_map

     

       296
       296
       +
             () in

     

       297
       297
       +
             

     

       298
       298
       +
           let submit_invocation = Jmap.Wire.Invocation.v

     

       299
       299
       +
             ~method_name:"EmailSubmission/set"

     

       300
       300
       +
             ~arguments:(`Assoc []) (* Would serialize submit_args *)

     

       301
       301
       +
             ~method_call_id:"submit1"

     

       302
       302
       +
             () in

     

       303
       303
       +
             

     

       304
       304
       +
           [create_invocation; submit_invocation]

     

       305
       305
       +
         else

     

       306
       306
       +
           [create_invocation]

     

       307
       307
       +
         in

     

       308
       308
       +
         

     

       309
       309
       +
         (* 7. Send the request *)

     

       310
       310
       +
         let request = Jmap.Wire.Request.v

     

       311
       311
       +
           ~using:[Jmap.capability_core; Jmap_email.capability_mail; Jmap_email.capability_submission]

     

       312
       312
       +
           ~method_calls

     

       313
       313
       +
           () in

     

       314
       314
       +
           

     

       315
       315
       +
         match Jmap_unix.request ctx request with

     

       316
       316
       +
         | Ok response ->

     

       317
       317
       +
             if options.send && not options.draft then

     

       318
       318
       +
               Printf.printf "\nEmail sent successfully!\n"

     

       319
       319
       +
             else

     

       320
       320
       +
               Printf.printf "\nDraft saved successfully!\n";

     

       321
       321
       +
             0

     

       322
       322
       +
         | Error e ->

     

       323
       323
       +
             Printf.eprintf "\nFailed to create email: %s\n" (Jmap.Error.error_to_string e);

     

       324
       324
       +
             1

     

       325
       325
       +
       

     

       326
       326
       +
       (* Command implementation *)

     

       327
       327
       +
       let compose_command host user password to_list cc_list bcc_list subject 

     

       328
       328
       +
                           body body_file html html_file attachments reply_to 

     

       329
       329
       +
                           draft send : int =

     

       330
       330
       +
         Printf.printf "JMAP Email Composer\n";

     

       331
       331
       +
         Printf.printf "Server: %s\n" host;

     

       332
       332
       +
         Printf.printf "User: %s\n\n" user;

     

       333
       333
       +
         

     

       334
       334
       +
         (* Validate arguments *)

     

       335
       335
       +
         if to_list = [] && cc_list = [] && bcc_list = [] then (

     

       336
       336
       +
           Printf.eprintf "Error: Must specify at least one recipient\n";

     

       337
       337
       +
           exit 1

     

       338
       338
       +
         );

     

       339
       339
       +
         

     

       340
       340
       +
         (* Read body content *)

     

       341
       341
       +
         let body_text = match body, body_file with

     

       342
       342
       +
           | Some text, _ -> Some text

     

       343
       343
       +
           | None, Some file -> Some (read_file file)

     

       344
       344
       +
           | None, None -> None

     

       345
       345
       +
         in

     

       346
       346
       +
         

     

       347
       347
       +
         let body_html = match html, html_file with

     

       348
       348
       +
           | Some text, _ -> Some text

     

       349
       349
       +
           | None, Some file -> Some (read_file file)

     

       350
       350
       +
           | None, None -> None

     

       351
       351
       +
         in

     

       352
       352
       +
         

     

       353
       353
       +
         if body_text = None && body_html = None then (

     

       354
       354
       +
           Printf.eprintf "Error: Must provide email body (--body, --body-file, --html, or --html-file)\n";

     

       355
       355
       +
           exit 1

     

       356
       356
       +
         );

     

       357
       357
       +
         

     

       358
       358
       +
         (* Create options record *)

     

       359
       359
       +
         let options = {

     

       360
       360
       +
           to_recipients = to_list;

     

       361
       361
       +
           cc_recipients = cc_list;

     

       362
       362
       +
           bcc_recipients = bcc_list;

     

       363
       363
       +
           subject;

     

       364
       364
       +
           body_text;

     

       365
       365
       +
           body_html;

     

       366
       366
       +
           attachments;

     

       367
       367
       +
           in_reply_to = reply_to;

     

       368
       368
       +
           draft;

     

       369
       369
       +
           send = send || not draft; (* Send by default unless draft flag is set *)

     

       370
       370
       +
         } in

     

       371
       371
       +
         

     

       372
       372
       +
         (* Connect to server *)

     

       373
       373
       +
         let ctx = Jmap_unix.create_client () in

     

       374
       374
       +
         let result = Jmap_unix.quick_connect ~host ~username:user ~password in

     

       375
       375
       +
         

     

       376
       376
       +
         let (ctx, session) = match result with

     

       377
       377
       +
           | Ok (ctx, session) -> (ctx, session)

     

       378
       378
       +
           | Error e -> 

     

       379
       379
       +
               Printf.eprintf "Connection failed: %s\n" (Jmap.Error.error_to_string e);

     

       380
       380
       +
               exit 1

     

       381
       381
       +
         in

     

       382
       382
       +
         

     

       383
       383
       +
         (* Get the primary account ID *)

     

       384
       384
       +
         let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       385
       385
       +
           | Ok id -> id

     

       386
       386
       +
           | Error e -> 

     

       387
       387
       +
               Printf.eprintf "No mail account found: %s\n" (Jmap.Error.error_to_string e);

     

       388
       388
       +
               exit 1

     

       389
       389
       +
         in

     

       390
       390
       +
         

     

       391
       391
       +
         (* Compose and send/save the email *)

     

       392
       392
       +
         compose_and_send ctx session account_id options

     

       393
       393
       +
       

     

       394
       394
       +
       (* Command definition *)

     

       395
       395
       +
       let compose_cmd =

     

       396
       396
       +
         let doc = "compose and send emails via JMAP" in

     

       397
       397
       +
         let man = [

     

       398
       398
       +
           `S Manpage.s_description;

     

       399
       399
       +
           `P "Compose and send emails using the JMAP protocol.";

     

       400
       400
       +
           `P "Supports plain text and HTML bodies, attachments, and drafts.";

     

       401
       401
       +
           `S Manpage.s_examples;

     

       402
       402
       +
           `P "Send a simple email:";

     

       403
       403
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 \\";

     

       404
       404
       +
           `P "    -t recipient@example.com -s \"Meeting reminder\" \\";

     

       405
       405
       +
           `P "    --body \"Don't forget our meeting at 3pm!\"";

     

       406
       406
       +
           `P "";

     

       407
       407
       +
           `P "Send email with attachment:";

     

       408
       408
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 \\";

     

       409
       409
       +
           `P "    -t recipient@example.com -s \"Report attached\" \\";

     

       410
       410
       +
           `P "    --body-file message.txt -a report.pdf";

     

       411
       411
       +
           `P "";

     

       412
       412
       +
           `P "Save as draft:";

     

       413
       413
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 \\";

     

       414
       414
       +
           `P "    -t recipient@example.com -s \"Work in progress\" \\";

     

       415
       415
       +
           `P "    --body \"Still working on this...\" --draft";

     

       416
       416
       +
         ] in

     

       417
       417
       +
         

     

       418
       418
       +
         let cmd =

     

       419
       419
       +
           Cmd.v

     

       420
       420
       +
             (Cmd.info "jmap-email-composer" ~version:"1.0" ~doc ~man)

     

       421
       421
       +
             Term.(const compose_command $ host_arg $ user_arg $ password_arg $ 

     

       422
       422
       +
                   to_arg $ cc_arg $ bcc_arg $ subject_arg $ body_arg $ body_file_arg $

     

       423
       423
       +
                   html_arg $ html_file_arg $ attach_arg $ reply_to_arg $ 

     

       424
       424
       +
                   draft_arg $ send_arg)

     

       425
       425
       +
         in

     

       426
       426
       +
         cmd

     

       427
       427
       +
       

     

       428
       428
       +
       (* Main entry point *)

     

       429
       429
       +
       let () = exit (Cmd.eval' compose_cmd)

+436

bin/jmap_email_search.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_email_search.ml - A comprehensive email search utility using JMAP

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's query capabilities for email searching,

     

       5
       5
       +
        * filtering, and sorting.

     

       6
       6
       +
        *

     

       7
       7
       +
        * For step 2, we're only testing type checking. No implementations required.

     

       8
       8
       +
        *)

     

       9
       9
       +
       

     

       10
       10
       +
       open Cmdliner

     

       11
       11
       +
       

     

       12
       12
       +
       (** Email search arguments type *)

     

       13
       13
       +
       type email_search_args = {

     

       14
       14
       +
         query : string;

     

       15
       15
       +
         from : string option;

     

       16
       16
       +
         to_ : string option;

     

       17
       17
       +
         subject : string option;

     

       18
       18
       +
         before : string option;

     

       19
       19
       +
         after : string option;

     

       20
       20
       +
         has_attachment : bool;

     

       21
       21
       +
         mailbox : string option;

     

       22
       22
       +
         is_unread : bool;

     

       23
       23
       +
         limit : int;

     

       24
       24
       +
         sort : [`DateDesc | `DateAsc | `From | `To | `Subject | `Size];

     

       25
       25
       +
         format : [`Summary | `Json | `Detailed];

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       (* Module to convert ISO 8601 date strings to Unix timestamps *)

     

       29
       29
       +
       module Date_converter = struct

     

       30
       30
       +
         (* Convert an ISO date string (YYYY-MM-DD) to Unix timestamp *)

     

       31
       31
       +
         let parse_date date_str =

     

       32
       32
       +
           try

     

       33
       33
       +
             (* Parse YYYY-MM-DD format *)

     

       34
       34
       +
             let (year, month, day) = Scanf.sscanf date_str "%d-%d-%d" (fun y m d -> (y, m, d)) in

     

       35
       35
       +
             

     

       36
       36
       +
             (* Convert to Unix timestamp (midnight UTC of that day) *)

     

       37
       37
       +
             let tm = Unix.{ tm_sec = 0; tm_min = 0; tm_hour = 0;

     

       38
       38
       +
                             tm_mday = day; tm_mon = month - 1; tm_year = year - 1900;

     

       39
       39
       +
                             tm_wday = 0; tm_yday = 0; tm_isdst = false } in

     

       40
       40
       +
             Some (Unix.mktime tm |> fst)

     

       41
       41
       +
           with _ ->

     

       42
       42
       +
             Printf.eprintf "Invalid date format: %s (use YYYY-MM-DD)\n" date_str;

     

       43
       43
       +
             None

     

       44
       44
       +
             

     

       45
       45
       +
         (* Format a Unix timestamp as ISO 8601 *)

     

       46
       46
       +
         let format_datetime time =

     

       47
       47
       +
           let tm = Unix.gmtime time in

     

       48
       48
       +
           Printf.sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ"

     

       49
       49
       +
             (tm.Unix.tm_year + 1900) (tm.Unix.tm_mon + 1) tm.Unix.tm_mday

     

       50
       50
       +
             tm.Unix.tm_hour tm.Unix.tm_min tm.Unix.tm_sec

     

       51
       51
       +
       end

     

       52
       52
       +
       

     

       53
       53
       +
       (** Command-line arguments **)

     

       54
       54
       +
       

     

       55
       55
       +
       let host_arg =

     

       56
       56
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       57
       57
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       58
       58
       +
       

     

       59
       59
       +
       let user_arg =

     

       60
       60
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       61
       61
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       62
       62
       +
       

     

       63
       63
       +
       let password_arg =

     

       64
       64
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       65
       65
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       66
       66
       +
       

     

       67
       67
       +
       let query_arg =

     

       68
       68
       +
         Arg.(value & opt string "" & info ["q"; "query"] 

     

       69
       69
       +
              ~docv:"QUERY" ~doc:"Text to search for in emails")

     

       70
       70
       +
       

     

       71
       71
       +
       let from_arg =

     

       72
       72
       +
         Arg.(value & opt (some string) None & info ["from"] 

     

       73
       73
       +
              ~docv:"EMAIL" ~doc:"Filter by sender email address")

     

       74
       74
       +
       

     

       75
       75
       +
       let to_arg =

     

       76
       76
       +
         Arg.(value & opt (some string) None & info ["to"] 

     

       77
       77
       +
              ~docv:"EMAIL" ~doc:"Filter by recipient email address")

     

       78
       78
       +
       

     

       79
       79
       +
       let subject_arg =

     

       80
       80
       +
         Arg.(value & opt (some string) None & info ["subject"] 

     

       81
       81
       +
              ~docv:"SUBJECT" ~doc:"Filter by subject text")

     

       82
       82
       +
       

     

       83
       83
       +
       let before_arg =

     

       84
       84
       +
         Arg.(value & opt (some string) None & info ["before"] 

     

       85
       85
       +
              ~docv:"DATE" ~doc:"Show emails before date (YYYY-MM-DD)")

     

       86
       86
       +
       

     

       87
       87
       +
       let after_arg =

     

       88
       88
       +
         Arg.(value & opt (some string) None & info ["after"] 

     

       89
       89
       +
              ~docv:"DATE" ~doc:"Show emails after date (YYYY-MM-DD)")

     

       90
       90
       +
       

     

       91
       91
       +
       let has_attachment_arg =

     

       92
       92
       +
         Arg.(value & flag & info ["has-attachment"] 

     

       93
       93
       +
              ~doc:"Filter to emails with attachments")

     

       94
       94
       +
       

     

       95
       95
       +
       let mailbox_arg =

     

       96
       96
       +
         Arg.(value & opt (some string) None & info ["mailbox"] 

     

       97
       97
       +
              ~docv:"MAILBOX" ~doc:"Filter by mailbox name")

     

       98
       98
       +
       

     

       99
       99
       +
       let is_unread_arg =

     

       100
       100
       +
         Arg.(value & flag & info ["unread"] 

     

       101
       101
       +
              ~doc:"Show only unread emails")

     

       102
       102
       +
       

     

       103
       103
       +
       let limit_arg =

     

       104
       104
       +
         Arg.(value & opt int 20 & info ["limit"] 

     

       105
       105
       +
              ~docv:"N" ~doc:"Maximum number of results to return")

     

       106
       106
       +
       

     

       107
       107
       +
       let sort_arg =

     

       108
       108
       +
         Arg.(value & opt (enum [

     

       109
       109
       +
           "date-desc", `DateDesc;

     

       110
       110
       +
           "date-asc", `DateAsc;

     

       111
       111
       +
           "from", `From;

     

       112
       112
       +
           "to", `To;

     

       113
       113
       +
           "subject", `Subject;

     

       114
       114
       +
           "size", `Size;

     

       115
       115
       +
         ]) `DateDesc & info ["sort"] ~docv:"FIELD" 

     

       116
       116
       +
              ~doc:"Sort results by field")

     

       117
       117
       +
       

     

       118
       118
       +
       let format_arg =

     

       119
       119
       +
         Arg.(value & opt (enum [

     

       120
       120
       +
           "summary", `Summary;

     

       121
       121
       +
           "json", `Json;

     

       122
       122
       +
           "detailed", `Detailed;

     

       123
       123
       +
         ]) `Summary & info ["format"] ~docv:"FORMAT" 

     

       124
       124
       +
              ~doc:"Output format")

     

       125
       125
       +
       

     

       126
       126
       +
       (** Main functionality **)

     

       127
       127
       +
       

     

       128
       128
       +
       (* Create a filter based on command-line arguments - this function uses the actual JMAP API *)

     

       129
       129
       +
       let create_filter _account_id mailbox_id_opt args =

     

       130
       130
       +
         let open Jmap.Methods.Filter in

     

       131
       131
       +
         let filters = [] in

     

       132
       132
       +
         

     

       133
       133
       +
         (* Add filter conditions based on command-line args *)

     

       134
       134
       +
         let filters = match args.query with 

     

       135
       135
       +
           | "" -> filters 

     

       136
       136
       +
           | query -> Jmap_email.Email_filter.subject query :: filters 

     

       137
       137
       +
         in

     

       138
       138
       +
         

     

       139
       139
       +
         let filters = match args.from with

     

       140
       140
       +
           | None -> filters

     

       141
       141
       +
           | Some sender -> Jmap_email.Email_filter.from sender :: filters

     

       142
       142
       +
         in

     

       143
       143
       +
         

     

       144
       144
       +
         let filters = match args.to_ with

     

       145
       145
       +
           | None -> filters

     

       146
       146
       +
           | Some recipient -> Jmap_email.Email_filter.to_ recipient :: filters

     

       147
       147
       +
         in

     

       148
       148
       +
         

     

       149
       149
       +
         let filters = match args.subject with

     

       150
       150
       +
           | None -> filters

     

       151
       151
       +
           | Some subj -> Jmap_email.Email_filter.subject subj :: filters

     

       152
       152
       +
         in

     

       153
       153
       +
         

     

       154
       154
       +
         let filters = match args.before with

     

       155
       155
       +
           | None -> filters

     

       156
       156
       +
           | Some date_str -> 

     

       157
       157
       +
               match Date_converter.parse_date date_str with

     

       158
       158
       +
               | Some date -> Jmap_email.Email_filter.before date :: filters

     

       159
       159
       +
               | None -> filters

     

       160
       160
       +
         in

     

       161
       161
       +
         

     

       162
       162
       +
         let filters = match args.after with

     

       163
       163
       +
           | None -> filters

     

       164
       164
       +
           | Some date_str -> 

     

       165
       165
       +
               match Date_converter.parse_date date_str with

     

       166
       166
       +
               | Some date -> Jmap_email.Email_filter.after date :: filters

     

       167
       167
       +
               | None -> filters

     

       168
       168
       +
         in

     

       169
       169
       +
         

     

       170
       170
       +
         let filters = if args.has_attachment then Jmap_email.Email_filter.has_attachment () :: filters else filters in

     

       171
       171
       +
         

     

       172
       172
       +
         let filters = if args.is_unread then Jmap_email.Email_filter.unread () :: filters else filters in

     

       173
       173
       +
         

     

       174
       174
       +
         let filters = match mailbox_id_opt with

     

       175
       175
       +
           | None -> filters

     

       176
       176
       +
           | Some mailbox_id -> Jmap_email.Email_filter.in_mailbox mailbox_id :: filters

     

       177
       177
       +
         in

     

       178
       178
       +
         

     

       179
       179
       +
         (* Combine all filters with AND *)

     

       180
       180
       +
         match filters with

     

       181
       181
       +
         | [] -> condition (`Assoc [])  (* Empty filter *)

     

       182
       182
       +
         | [f] -> f

     

       183
       183
       +
         | filters -> and_ filters

     

       184
       184
       +
       

     

       185
       185
       +
       (* Create sort comparator based on command-line arguments *)

     

       186
       186
       +
       let create_sort args =

     

       187
       187
       +
         match args.sort with

     

       188
       188
       +
         | `DateDesc -> Jmap_email.Email_sort.received_newest_first ()

     

       189
       189
       +
         | `DateAsc -> Jmap_email.Email_sort.received_oldest_first ()

     

       190
       190
       +
         | `From -> Jmap_email.Email_sort.from_asc ()

     

       191
       191
       +
         | `To -> Jmap_email.Email_sort.subject_asc ()  (* Using subject as proxy for 'to' *)

     

       192
       192
       +
         | `Subject -> Jmap_email.Email_sort.subject_asc ()

     

       193
       193
       +
         | `Size -> Jmap_email.Email_sort.size_largest_first ()

     

       194
       194
       +
       

     

       195
       195
       +
       (* Display email results based on format option *)

     

       196
       196
       +
       let display_results emails format =

     

       197
       197
       +
         match format with

     

       198
       198
       +
         | `Summary ->

     

       199
       199
       +
             emails |> List.iteri (fun i email ->

     

       200
       200
       +
               let id = Option.value (Jmap_email.Types.Email.id email) ~default:"(no id)" in

     

       201
       201
       +
               let subject = Option.value (Jmap_email.Types.Email.subject email) ~default:"(no subject)" in

     

       202
       202
       +
               let from_list = Option.value (Jmap_email.Types.Email.from email) ~default:[] in

     

       203
       203
       +
               let from = match from_list with

     

       204
       204
       +
                 | [] -> "(no sender)"

     

       205
       205
       +
                 | addr::_ -> Jmap_email.Types.Email_address.email addr

     

       206
       206
       +
               in

     

       207
       207
       +
               let date = match Jmap_email.Types.Email.received_at email with

     

       208
       208
       +
                 | Some d -> Date_converter.format_datetime d

     

       209
       209
       +
                 | None -> "(no date)"

     

       210
       210
       +
               in

     

       211
       211
       +
               Printf.printf "%3d) [%s] %s\n     From: %s\n     Date: %s\n\n" 

     

       212
       212
       +
                 (i+1) id subject from date

     

       213
       213
       +
             );

     

       214
       214
       +
             0

     

       215
       215
       +
         

     

       216
       216
       +
         | `Detailed ->

     

       217
       217
       +
             emails |> List.iteri (fun i email ->

     

       218
       218
       +
               let id = Option.value (Jmap_email.Types.Email.id email) ~default:"(no id)" in

     

       219
       219
       +
               let subject = Option.value (Jmap_email.Types.Email.subject email) ~default:"(no subject)" in

     

       220
       220
       +
               let thread_id = Option.value (Jmap_email.Types.Email.thread_id email) ~default:"(no thread)" in

     

       221
       221
       +
               

     

       222
       222
       +
               let from_list = Option.value (Jmap_email.Types.Email.from email) ~default:[] in

     

       223
       223
       +
               let from = match from_list with

     

       224
       224
       +
                 | [] -> "(no sender)"

     

       225
       225
       +
                 | addr::_ -> Jmap_email.Types.Email_address.email addr

     

       226
       226
       +
               in

     

       227
       227
       +
               

     

       228
       228
       +
               let to_list = Option.value (Jmap_email.Types.Email.to_ email) ~default:[] in

     

       229
       229
       +
               let to_str = to_list 

     

       230
       230
       +
                 |> List.map Jmap_email.Types.Email_address.email

     

       231
       231
       +
                 |> String.concat ", " in

     

       232
       232
       +
               

     

       233
       233
       +
               let date = match Jmap_email.Types.Email.received_at email with

     

       234
       234
       +
                 | Some d -> Date_converter.format_datetime d

     

       235
       235
       +
                 | None -> "(no date)"

     

       236
       236
       +
               in

     

       237
       237
       +
               

     

       238
       238
       +
               let keywords = match Jmap_email.Types.Email.keywords email with

     

       239
       239
       +
                 | Some kw -> Jmap_email.Types.Keywords.custom_keywords kw 

     

       240
       240
       +
                              |> String.concat ", "

     

       241
       241
       +
                 | None -> "(none)"

     

       242
       242
       +
               in

     

       243
       243
       +
               

     

       244
       244
       +
               let has_attachment = match Jmap_email.Types.Email.has_attachment email with

     

       245
       245
       +
                 | Some true -> "Yes"

     

       246
       246
       +
                 | _ -> "No"

     

       247
       247
       +
               in

     

       248
       248
       +
               

     

       249
       249
       +
               Printf.printf "Email %d:\n" (i+1);

     

       250
       250
       +
               Printf.printf "  ID:        %s\n" id;

     

       251
       251
       +
               Printf.printf "  Subject:   %s\n" subject;

     

       252
       252
       +
               Printf.printf "  From:      %s\n" from;

     

       253
       253
       +
               Printf.printf "  To:        %s\n" to_str;

     

       254
       254
       +
               Printf.printf "  Date:      %s\n" date;

     

       255
       255
       +
               Printf.printf "  Thread:    %s\n" thread_id;

     

       256
       256
       +
               Printf.printf "  Flags:     %s\n" keywords;

     

       257
       257
       +
               Printf.printf "  Attachment:%s\n" has_attachment;

     

       258
       258
       +
               

     

       259
       259
       +
               match Jmap_email.Types.Email.preview email with

     

       260
       260
       +
               | Some text -> Printf.printf "  Preview:   %s\n" text

     

       261
       261
       +
               | None -> ();

     

       262
       262
       +
               

     

       263
       263
       +
               Printf.printf "\n"

     

       264
       264
       +
             );

     

       265
       265
       +
             0

     

       266
       266
       +
             

     

       267
       267
       +
         | `Json ->

     

       268
       268
       +
             (* In a real implementation, this would properly convert emails to JSON *)

     

       269
       269
       +
             Printf.printf "{\n  \"results\": [\n";

     

       270
       270
       +
             emails |> List.iteri (fun i email ->

     

       271
       271
       +
               let id = Option.value (Jmap_email.Types.Email.id email) ~default:"" in

     

       272
       272
       +
               let subject = Option.value (Jmap_email.Types.Email.subject email) ~default:"" in

     

       273
       273
       +
               Printf.printf "    {\"id\": \"%s\", \"subject\": \"%s\"%s\n" 

     

       274
       274
       +
                 id subject (if i < List.length emails - 1 then "}," else "}")

     

       275
       275
       +
             );

     

       276
       276
       +
             Printf.printf "  ]\n}\n";

     

       277
       277
       +
             0

     

       278
       278
       +
       

     

       279
       279
       +
       (* Command implementation - using the real JMAP interface *)

     

       280
       280
       +
       let search_command host user password query from to_ subject before after 

     

       281
       281
       +
                          has_attachment mailbox is_unread limit sort format : int =

     

       282
       282
       +
         (* Pack arguments into a record for easier passing *)

     

       283
       283
       +
         let args : email_search_args = {

     

       284
       284
       +
           query; from; to_ = to_; subject; before; after; 

     

       285
       285
       +
           has_attachment; mailbox; is_unread; limit; sort; format

     

       286
       286
       +
         } in

     

       287
       287
       +
         

     

       288
       288
       +
         Printf.printf "JMAP Email Search\n";

     

       289
       289
       +
         Printf.printf "Server: %s\n" host;

     

       290
       290
       +
         Printf.printf "User: %s\n\n" user;

     

       291
       291
       +
         

     

       292
       292
       +
         (* The following code demonstrates using the JMAP library interface

     

       293
       293
       +
            but doesn't actually run it for Step 2 (it will get a linker error,

     

       294
       294
       +
            which is expected since there's no implementation yet) *)

     

       295
       295
       +
         

     

       296
       296
       +
         let process_search () =

     

       297
       297
       +
           (* 1. Create client context and connect to server *)

     

       298
       298
       +
           let _orig_ctx = Jmap_unix.create_client () in

     

       299
       299
       +
           let result = Jmap_unix.quick_connect ~host ~username:user ~password in

     

       300
       300
       +
           

     

       301
       301
       +
           let (ctx, session) = match result with

     

       302
       302
       +
             | Ok (ctx, session) -> (ctx, session)

     

       303
       303
       +
             | Error _ -> failwith "Could not connect to server"

     

       304
       304
       +
           in

     

       305
       305
       +
           

     

       306
       306
       +
           (* 2. Get the primary account ID for mail capability *)

     

       307
       307
       +
           let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       308
       308
       +
             | Ok id -> id

     

       309
       309
       +
             | Error _ -> failwith "No mail account found"

     

       310
       310
       +
           in

     

       311
       311
       +
           

     

       312
       312
       +
           (* 3. Resolve mailbox name to ID if specified *)

     

       313
       313
       +
           let mailbox_id_opt = match args.mailbox with

     

       314
       314
       +
             | None -> None

     

       315
       315
       +
             | Some _name ->

     

       316
       316
       +
                 (* This would use Mailbox/query and Mailbox/get to resolve the name *)

     

       317
       317
       +
                 (* For now just simulate a mailbox ID *)

     

       318
       318
       +
                 Some "mailbox123"

     

       319
       319
       +
           in

     

       320
       320
       +
           

     

       321
       321
       +
           (* 4. Create filter based on search criteria *)

     

       322
       322
       +
           let filter = create_filter account_id mailbox_id_opt args in

     

       323
       323
       +
           

     

       324
       324
       +
           (* 5. Create sort comparator *)

     

       325
       325
       +
           let sort = create_sort args in

     

       326
       326
       +
           

     

       327
       327
       +
           (* 6. Prepare Email/query request *)

     

       328
       328
       +
           let _query_args = Jmap.Methods.Query_args.v

     

       329
       329
       +
             ~account_id

     

       330
       330
       +
             ~filter

     

       331
       331
       +
             ~sort:[sort]

     

       332
       332
       +
             ~position:0

     

       333
       333
       +
             ~limit:args.limit

     

       334
       334
       +
             ~calculate_total:true

     

       335
       335
       +
             () in

     

       336
       336
       +
             

     

       337
       337
       +
           let query_invocation = Jmap.Wire.Invocation.v

     

       338
       338
       +
             ~method_name:"Email/query"

     

       339
       339
       +
             ~arguments:(`Assoc []) (* In real code, we'd serialize query_args to JSON *)

     

       340
       340
       +
             ~method_call_id:"q1"

     

       341
       341
       +
             () in

     

       342
       342
       +
           

     

       343
       343
       +
           (* 7. Prepare Email/get request with back-reference to query results *)

     

       344
       344
       +
           let get_properties = [

     

       345
       345
       +
             "id"; "threadId"; "mailboxIds"; "keywords"; "size";

     

       346
       346
       +
             "receivedAt"; "messageId"; "inReplyTo"; "references";

     

       347
       347
       +
             "sender"; "from"; "to"; "cc"; "bcc"; "replyTo";

     

       348
       348
       +
             "subject"; "sentAt"; "hasAttachment"; "preview" 

     

       349
       349
       +
           ] in

     

       350
       350
       +
           

     

       351
       351
       +
           let _get_args = Jmap.Methods.Get_args.v

     

       352
       352
       +
             ~account_id

     

       353
       353
       +
             ~properties:get_properties

     

       354
       354
       +
             () in

     

       355
       355
       +
           

     

       356
       356
       +
           let get_invocation = Jmap.Wire.Invocation.v

     

       357
       357
       +
             ~method_name:"Email/get"

     

       358
       358
       +
             ~arguments:(`Assoc []) (* In real code, we'd serialize get_args to JSON *)

     

       359
       359
       +
             ~method_call_id:"g1"

     

       360
       360
       +
             () in

     

       361
       361
       +
           

     

       362
       362
       +
           (* 8. Prepare the JMAP request *)

     

       363
       363
       +
           let request = Jmap.Wire.Request.v

     

       364
       364
       +
             ~using:[Jmap.capability_core; Jmap_email.capability_mail]

     

       365
       365
       +
             ~method_calls:[query_invocation; get_invocation]

     

       366
       366
       +
             () in

     

       367
       367
       +
           

     

       368
       368
       +
           (* 9. Send the request *)

     

       369
       369
       +
           let response = match Jmap_unix.request ctx request with

     

       370
       370
       +
             | Ok response -> response

     

       371
       371
       +
             | Error _ -> failwith "Request failed"

     

       372
       372
       +
           in

     

       373
       373
       +
           

     

       374
       374
       +
           (* Helper to find a method response by ID *)

     

       375
       375
       +
           let find_method_response response id =

     

       376
       376
       +
             let open Jmap.Wire in

     

       377
       377
       +
             let responses = Response.method_responses response in

     

       378
       378
       +
             let find_by_id inv =

     

       379
       379
       +
               match inv with

     

       380
       380
       +
               | Ok invocation when Invocation.method_call_id invocation = id -> 

     

       381
       381
       +
                   Some (Invocation.method_name invocation, Invocation.arguments invocation)

     

       382
       382
       +
               | _ -> None

     

       383
       383
       +
             in

     

       384
       384
       +
             List.find_map find_by_id responses

     

       385
       385
       +
           in

     

       386
       386
       +
           

     

       387
       387
       +
           (* 10. Process the response *)

     

       388
       388
       +
           match find_method_response response "g1" with

     

       389
       389
       +
           | Some (method_name, _) when method_name = "Email/get" ->

     

       390
       390
       +
               (* We would extract the emails from the response here *)

     

       391
       391
       +
               (* For now, just create a sample email for type checking *)

     

       392
       392
       +
               let email = Jmap_email.Types.Email.create

     

       393
       393
       +
                 ~id:"email123"

     

       394
       394
       +
                 ~thread_id:"thread456"

     

       395
       395
       +
                 ~subject:"Test Email"

     

       396
       396
       +
                 ~from:[Jmap_email.Types.Email_address.v ~name:"Sender" ~email:"sender@example.com" ()]

     

       397
       397
       +
                 ~to_:[Jmap_email.Types.Email_address.v ~name:"Recipient" ~email:"recipient@example.com" ()]

     

       398
       398
       +
                 ~received_at:1588000000.0

     

       399
       399
       +
                 ~has_attachment:true

     

       400
       400
       +
                 ~preview:"This is a test email..."

     

       401
       401
       +
                 ~keywords:(Jmap_email.Types.Keywords.of_list [Jmap_email.Types.Keywords.Seen])

     

       402
       402
       +
                 () in

     

       403
       403
       +
                 

     

       404
       404
       +
               (* Display the result *)

     

       405
       405
       +
               display_results [email] args.format

     

       406
       406
       +
           | _ ->

     

       407
       407
       +
               Printf.eprintf "Error: Invalid response\n";

     

       408
       408
       +
               1

     

       409
       409
       +
         in

     

       410
       410
       +
         

     

       411
       411
       +
         (* Note: Since we're only type checking, this won't actually run *)

     

       412
       412
       +
         process_search ()

     

       413
       413
       +
       

     

       414
       414
       +
       (* Command definition *)

     

       415
       415
       +
       let search_cmd =

     

       416
       416
       +
         let doc = "search emails using JMAP query capabilities" in

     

       417
       417
       +
         let man = [

     

       418
       418
       +
           `S Manpage.s_description;

     

       419
       419
       +
           `P "Searches for emails on a JMAP server with powerful filtering capabilities.";

     

       420
       420
       +
           `P "Demonstrates the rich query functions available in the JMAP protocol.";

     

       421
       421
       +
           `S Manpage.s_examples;

     

       422
       422
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -q \"important meeting\"";

     

       423
       423
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --from boss@company.com --after 2023-01-01";

     

       424
       424
       +
         ] in

     

       425
       425
       +
         

     

       426
       426
       +
         let cmd =

     

       427
       427
       +
           Cmd.v

     

       428
       428
       +
             (Cmd.info "jmap-email-search" ~version:"1.0" ~doc ~man)

     

       429
       429
       +
             Term.(const search_command $ host_arg $ user_arg $ password_arg $ 

     

       430
       430
       +
                   query_arg $ from_arg $ to_arg $ subject_arg $ before_arg $ after_arg $ 

     

       431
       431
       +
                   has_attachment_arg $ mailbox_arg $ is_unread_arg $ limit_arg $ sort_arg $ format_arg)

     

       432
       432
       +
         in

     

       433
       433
       +
         cmd

     

       434
       434
       +
       

     

       435
       435
       +
       (* Main entry point *)

     

       436
       436
       +
       let () = exit (Cmd.eval' search_cmd)

+706

bin/jmap_flag_manager.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_flag_manager.ml - A tool for managing email flags (keywords) using JMAP

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's flag management capabilities, allowing

     

       5
       5
       +
        * powerful query-based selection and batch flag operations.

     

       6
       6
       +
        *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Cmdliner

     

       9
       9
       +
       (* Using standard OCaml, no Lwt *)

     

       10
       10
       +
       

     

       11
       11
       +
       (* JMAP imports *)

     

       12
       12
       +
       open Jmap.Methods

     

       13
       13
       +
       open Jmap_email

     

       14
       14
       +
       (* For step 2, we're only testing type checking. No implementations required. *)

     

       15
       15
       +
       

     

       16
       16
       +
       (* Dummy Unix module for type checking *)

     

       17
       17
       +
       module Unix = struct

     

       18
       18
       +
         type tm = {

     

       19
       19
       +
           tm_sec : int;

     

       20
       20
       +
           tm_min : int;

     

       21
       21
       +
           tm_hour : int;

     

       22
       22
       +
           tm_mday : int;

     

       23
       23
       +
           tm_mon : int;

     

       24
       24
       +
           tm_year : int;

     

       25
       25
       +
           tm_wday : int;

     

       26
       26
       +
           tm_yday : int;

     

       27
       27
       +
           tm_isdst : bool

     

       28
       28
       +
         }

     

       29
       29
       +
         

     

       30
       30
       +
         let time () = 0.0

     

       31
       31
       +
         let gettimeofday () = 0.0

     

       32
       32
       +
         let mktime tm = (0.0, tm)

     

       33
       33
       +
         let gmtime _time = {

     

       34
       34
       +
           tm_sec = 0; tm_min = 0; tm_hour = 0;

     

       35
       35
       +
           tm_mday = 1; tm_mon = 0; tm_year = 120;

     

       36
       36
       +
           tm_wday = 0; tm_yday = 0; tm_isdst = false;

     

       37
       37
       +
         }

     

       38
       38
       +
         

     

       39
       39
       +
         (* JMAP connection function - would be in a real implementation *)

     

       40
       40
       +
         let connect ~host:_ ~username:_ ~password:_ ?auth_method:_ () =

     

       41
       41
       +
           failwith "Not implemented"

     

       42
       42
       +
       end

     

       43
       43
       +
       

     

       44
       44
       +
       (* Dummy ISO8601 module *)

     

       45
       45
       +
       module ISO8601 = struct

     

       46
       46
       +
         let string_of_datetime _tm = "2023-01-01T00:00:00Z"

     

       47
       47
       +
       end

     

       48
       48
       +
       

     

       49
       49
       +
       (** Flag manager args type *)

     

       50
       50
       +
       type flag_manager_args = {

     

       51
       51
       +
         list : bool;

     

       52
       52
       +
         add_flag : string option;

     

       53
       53
       +
         remove_flag : string option;

     

       54
       54
       +
         query : string;

     

       55
       55
       +
         from : string option;

     

       56
       56
       +
         days : int;

     

       57
       57
       +
         mailbox : string option;

     

       58
       58
       +
         ids : string list;

     

       59
       59
       +
         has_flag : string option;

     

       60
       60
       +
         missing_flag : string option;

     

       61
       61
       +
         limit : int;

     

       62
       62
       +
         dry_run : bool;

     

       63
       63
       +
         color : [`Red | `Orange | `Yellow | `Green | `Blue | `Purple | `Gray | `None] option;

     

       64
       64
       +
         verbose : bool;

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       (* Helper function for converting keywords to string *)

     

       68
       68
       +
       let string_of_keyword = function

     

       69
       69
       +
         | Types.Keywords.Draft -> "$draft"

     

       70
       70
       +
         | Types.Keywords.Seen -> "$seen"

     

       71
       71
       +
         | Types.Keywords.Flagged -> "$flagged"

     

       72
       72
       +
         | Types.Keywords.Answered -> "$answered"

     

       73
       73
       +
         | Types.Keywords.Forwarded -> "$forwarded"

     

       74
       74
       +
         | Types.Keywords.Phishing -> "$phishing"

     

       75
       75
       +
         | Types.Keywords.Junk -> "$junk"

     

       76
       76
       +
         | Types.Keywords.NotJunk -> "$notjunk"

     

       77
       77
       +
         | Types.Keywords.Custom c -> c

     

       78
       78
       +
         | Types.Keywords.Notify -> "$notify"

     

       79
       79
       +
         | Types.Keywords.Muted -> "$muted"

     

       80
       80
       +
         | Types.Keywords.Followed -> "$followed"

     

       81
       81
       +
         | Types.Keywords.Memo -> "$memo" 

     

       82
       82
       +
         | Types.Keywords.HasMemo -> "$hasmemo"

     

       83
       83
       +
         | Types.Keywords.Autosent -> "$autosent"

     

       84
       84
       +
         | Types.Keywords.Unsubscribed -> "$unsubscribed"

     

       85
       85
       +
         | Types.Keywords.CanUnsubscribe -> "$canunsubscribe"

     

       86
       86
       +
         | Types.Keywords.Imported -> "$imported"

     

       87
       87
       +
         | Types.Keywords.IsTrusted -> "$istrusted"

     

       88
       88
       +
         | Types.Keywords.MaskedEmail -> "$maskedemail"

     

       89
       89
       +
         | Types.Keywords.New -> "$new"

     

       90
       90
       +
         | Types.Keywords.MailFlagBit0 -> "$MailFlagBit0"

     

       91
       91
       +
         | Types.Keywords.MailFlagBit1 -> "$MailFlagBit1" 

     

       92
       92
       +
         | Types.Keywords.MailFlagBit2 -> "$MailFlagBit2"

     

       93
       93
       +
       

     

       94
       94
       +
       (* Email filter helpers - stub implementations for type checking *)

     

       95
       95
       +
       module Email_filter = struct

     

       96
       96
       +
         let create_fulltext_filter text = Filter.condition (`Assoc [("text", `String text)])

     

       97
       97
       +
         let subject subject = Filter.condition (`Assoc [("subject", `String subject)])

     

       98
       98
       +
         let from email = Filter.condition (`Assoc [("from", `String email)])

     

       99
       99
       +
         let after date = Filter.condition (`Assoc [("receivedAt", `Assoc [("after", `Float date)])])

     

       100
       100
       +
         let before date = Filter.condition (`Assoc [("receivedAt", `Assoc [("before", `Float date)])])

     

       101
       101
       +
         let has_attachment () = Filter.condition (`Assoc [("hasAttachment", `Bool true)])

     

       102
       102
       +
         let unread () = Filter.condition (`Assoc [("isUnread", `Bool true)])

     

       103
       103
       +
         let in_mailbox id = Filter.condition (`Assoc [("inMailbox", `String id)])

     

       104
       104
       +
         let to_ email = Filter.condition (`Assoc [("to", `String email)])

     

       105
       105
       +
         let has_keyword kw = Filter.condition (`Assoc [("hasKeyword", `String (string_of_keyword kw))])

     

       106
       106
       +
         let not_has_keyword kw = Filter.condition (`Assoc [("notHasKeyword", `String (string_of_keyword kw))])

     

       107
       107
       +
       end

     

       108
       108
       +
       

     

       109
       109
       +
       (** Command-line arguments **)

     

       110
       110
       +
       

     

       111
       111
       +
       let host_arg =

     

       112
       112
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       113
       113
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       114
       114
       +
       

     

       115
       115
       +
       let user_arg =

     

       116
       116
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       117
       117
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       118
       118
       +
       

     

       119
       119
       +
       let password_arg =

     

       120
       120
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       121
       121
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       122
       122
       +
       

     

       123
       123
       +
       let list_arg =

     

       124
       124
       +
         Arg.(value & flag & info ["l"; "list"] ~doc:"List emails with their flags")

     

       125
       125
       +
       

     

       126
       126
       +
       let add_flag_arg =

     

       127
       127
       +
         Arg.(value & opt (some string) None & info ["add"] 

     

       128
       128
       +
              ~docv:"FLAG" ~doc:"Add flag to selected emails")

     

       129
       129
       +
       

     

       130
       130
       +
       let remove_flag_arg =

     

       131
       131
       +
         Arg.(value & opt (some string) None & info ["remove"] 

     

       132
       132
       +
              ~docv:"FLAG" ~doc:"Remove flag from selected emails")

     

       133
       133
       +
       

     

       134
       134
       +
       let query_arg =

     

       135
       135
       +
         Arg.(value & opt string "" & info ["q"; "query"] 

     

       136
       136
       +
              ~docv:"QUERY" ~doc:"Filter emails by search query")

     

       137
       137
       +
       

     

       138
       138
       +
       let from_arg =

     

       139
       139
       +
         Arg.(value & opt (some string) None & info ["from"] 

     

       140
       140
       +
              ~docv:"EMAIL" ~doc:"Filter by sender")

     

       141
       141
       +
       

     

       142
       142
       +
       let days_arg =

     

       143
       143
       +
         Arg.(value & opt int 30 & info ["days"] 

     

       144
       144
       +
              ~docv:"DAYS" ~doc:"Filter to emails from past N days")

     

       145
       145
       +
       

     

       146
       146
       +
       let mailbox_arg =

     

       147
       147
       +
         Arg.(value & opt (some string) None & info ["mailbox"] 

     

       148
       148
       +
              ~docv:"MAILBOX" ~doc:"Filter by mailbox")

     

       149
       149
       +
       

     

       150
       150
       +
       let ids_arg =

     

       151
       151
       +
         Arg.(value & opt_all string [] & info ["id"] 

     

       152
       152
       +
              ~docv:"ID" ~doc:"Email IDs to operate on")

     

       153
       153
       +
       

     

       154
       154
       +
       let has_flag_arg =

     

       155
       155
       +
         Arg.(value & opt (some string) None & info ["has-flag"] 

     

       156
       156
       +
              ~docv:"FLAG" ~doc:"Filter to emails with specified flag")

     

       157
       157
       +
       

     

       158
       158
       +
       let missing_flag_arg =

     

       159
       159
       +
         Arg.(value & opt (some string) None & info ["missing-flag"] 

     

       160
       160
       +
              ~docv:"FLAG" ~doc:"Filter to emails without specified flag")

     

       161
       161
       +
       

     

       162
       162
       +
       let limit_arg =

     

       163
       163
       +
         Arg.(value & opt int 50 & info ["limit"] 

     

       164
       164
       +
              ~docv:"N" ~doc:"Maximum number of emails to process")

     

       165
       165
       +
       

     

       166
       166
       +
       let dry_run_arg =

     

       167
       167
       +
         Arg.(value & flag & info ["dry-run"] ~doc:"Show what would be done without making changes")

     

       168
       168
       +
       

     

       169
       169
       +
       let color_arg =

     

       170
       170
       +
         Arg.(value & opt (some (enum [

     

       171
       171
       +
           "red", `Red;

     

       172
       172
       +
           "orange", `Orange;

     

       173
       173
       +
           "yellow", `Yellow;

     

       174
       174
       +
           "green", `Green;

     

       175
       175
       +
           "blue", `Blue;

     

       176
       176
       +
           "purple", `Purple;

     

       177
       177
       +
           "gray", `Gray;

     

       178
       178
       +
           "none", `None

     

       179
       179
       +
         ])) None & info ["color"] ~docv:"COLOR" 

     

       180
       180
       +
              ~doc:"Set color flag (red, orange, yellow, green, blue, purple, gray, or none)")

     

       181
       181
       +
       

     

       182
       182
       +
       let verbose_arg =

     

       183
       183
       +
         Arg.(value & flag & info ["v"; "verbose"] ~doc:"Show detailed operation information")

     

       184
       184
       +
       

     

       185
       185
       +
       (** Flag Manager Functionality **)

     

       186
       186
       +
       

     

       187
       187
       +
       (* Parse date for filtering *)

     

       188
       188
       +
       let days_ago_date days =

     

       189
       189
       +
         let now = Unix.time () in

     

       190
       190
       +
         now -. (float_of_int days *. 86400.0)

     

       191
       191
       +
       

     

       192
       192
       +
       (* Validate flag name *)

     

       193
       193
       +
       let validate_flag_name flag =

     

       194
       194
       +
         let is_valid = String.length flag > 0 && (

     

       195
       195
       +
           (* System flags start with $ *)

     

       196
       196
       +
           (String.get flag 0 = '$') ||

     

       197
       197
       +
           

     

       198
       198
       +
           (* Custom flags must be alphanumeric plus some characters *)

     

       199
       199
       +
           (String.for_all (function 

     

       200
       200
       +
             | 'a'..'z' | 'A'..'Z' | '0'..'9' | '-' | '_' -> true 

     

       201
       201
       +
             | _ -> false) flag)

     

       202
       202
       +
         ) in

     

       203
       203
       +
         

     

       204
       204
       +
         if not is_valid then

     

       205
       205
       +
           Printf.eprintf "Warning: Flag name '%s' may not be valid according to JMAP spec\n" flag;

     

       206
       206
       +
         

     

       207
       207
       +
         is_valid

     

       208
       208
       +
       

     

       209
       209
       +
       (* Convert flag name to keyword *)

     

       210
       210
       +
       let flag_to_keyword flag =

     

       211
       211
       +
         match flag with

     

       212
       212
       +
         | "seen" -> Types.Keywords.Seen

     

       213
       213
       +
         | "draft" -> Types.Keywords.Draft

     

       214
       214
       +
         | "flagged" -> Types.Keywords.Flagged

     

       215
       215
       +
         | "answered" -> Types.Keywords.Answered

     

       216
       216
       +
         | "forwarded" -> Types.Keywords.Forwarded

     

       217
       217
       +
         | "junk" -> Types.Keywords.Junk

     

       218
       218
       +
         | "notjunk" -> Types.Keywords.NotJunk

     

       219
       219
       +
         | "phishing" -> Types.Keywords.Phishing

     

       220
       220
       +
         | "important" -> Types.Keywords.Flagged  (* Treat important same as flagged *)

     

       221
       221
       +
         | _ -> 

     

       222
       222
       +
             (* Handle $ prefix for system keywords *)

     

       223
       223
       +
             if String.get flag 0 = '$' then

     

       224
       224
       +
               match flag with

     

       225
       225
       +
               | "$seen" -> Types.Keywords.Seen

     

       226
       226
       +
               | "$draft" -> Types.Keywords.Draft

     

       227
       227
       +
               | "$flagged" -> Types.Keywords.Flagged

     

       228
       228
       +
               | "$answered" -> Types.Keywords.Answered

     

       229
       229
       +
               | "$forwarded" -> Types.Keywords.Forwarded

     

       230
       230
       +
               | "$junk" -> Types.Keywords.Junk

     

       231
       231
       +
               | "$notjunk" -> Types.Keywords.NotJunk

     

       232
       232
       +
               | "$phishing" -> Types.Keywords.Phishing

     

       233
       233
       +
               | "$notify" -> Types.Keywords.Notify

     

       234
       234
       +
               | "$muted" -> Types.Keywords.Muted

     

       235
       235
       +
               | "$followed" -> Types.Keywords.Followed

     

       236
       236
       +
               | "$memo" -> Types.Keywords.Memo

     

       237
       237
       +
               | "$hasmemo" -> Types.Keywords.HasMemo

     

       238
       238
       +
               | "$autosent" -> Types.Keywords.Autosent

     

       239
       239
       +
               | "$unsubscribed" -> Types.Keywords.Unsubscribed

     

       240
       240
       +
               | "$canunsubscribe" -> Types.Keywords.CanUnsubscribe

     

       241
       241
       +
               | "$imported" -> Types.Keywords.Imported

     

       242
       242
       +
               | "$istrusted" -> Types.Keywords.IsTrusted

     

       243
       243
       +
               | "$maskedemail" -> Types.Keywords.MaskedEmail

     

       244
       244
       +
               | "$new" -> Types.Keywords.New

     

       245
       245
       +
               | "$MailFlagBit0" -> Types.Keywords.MailFlagBit0

     

       246
       246
       +
               | "$MailFlagBit1" -> Types.Keywords.MailFlagBit1

     

       247
       247
       +
               | "$MailFlagBit2" -> Types.Keywords.MailFlagBit2

     

       248
       248
       +
               | _ -> Types.Keywords.Custom flag

     

       249
       249
       +
             else

     

       250
       250
       +
               (* Flag without $ prefix is treated as custom *)

     

       251
       251
       +
               Types.Keywords.Custom ("$" ^ flag)

     

       252
       252
       +
       

     

       253
       253
       +
       (* Get standard flags in user-friendly format *)

     

       254
       254
       +
       let get_standard_flags () = [

     

       255
       255
       +
         "seen", "Message has been read";

     

       256
       256
       +
         "draft", "Message is a draft";

     

       257
       257
       +
         "flagged", "Message is flagged/important";

     

       258
       258
       +
         "answered", "Message has been replied to";

     

       259
       259
       +
         "forwarded", "Message has been forwarded";

     

       260
       260
       +
         "junk", "Message is spam/junk";

     

       261
       261
       +
         "notjunk", "Message is explicitly not spam/junk";

     

       262
       262
       +
         "phishing", "Message is suspected phishing";

     

       263
       263
       +
         "notify", "Request notification when replied to";

     

       264
       264
       +
         "muted", "Notifications disabled for this message";

     

       265
       265
       +
         "followed", "Thread is followed for notifications";

     

       266
       266
       +
         "memo", "Has memo/note attached";

     

       267
       267
       +
         "new", "Recently delivered";

     

       268
       268
       +
       ]

     

       269
       269
       +
       

     

       270
       270
       +
       (* Convert color to flag bits *)

     

       271
       271
       +
       let color_to_flags color =

     

       272
       272
       +
         match color with

     

       273
       273
       +
         | `Red -> [Types.Keywords.MailFlagBit0]

     

       274
       274
       +
         | `Orange -> [Types.Keywords.MailFlagBit1]

     

       275
       275
       +
         | `Yellow -> [Types.Keywords.MailFlagBit2]

     

       276
       276
       +
         | `Green -> [Types.Keywords.MailFlagBit0; Types.Keywords.MailFlagBit1]

     

       277
       277
       +
         | `Blue -> [Types.Keywords.MailFlagBit0; Types.Keywords.MailFlagBit2]

     

       278
       278
       +
         | `Purple -> [Types.Keywords.MailFlagBit1; Types.Keywords.MailFlagBit2]

     

       279
       279
       +
         | `Gray -> [Types.Keywords.MailFlagBit0; Types.Keywords.MailFlagBit1; Types.Keywords.MailFlagBit2]

     

       280
       280
       +
         | `None -> []

     

       281
       281
       +
       

     

       282
       282
       +
       (* Convert flag bits to color *)

     

       283
       283
       +
       let flags_to_color flags =

     

       284
       284
       +
         let has_bit0 = List.exists ((=) Types.Keywords.MailFlagBit0) flags in

     

       285
       285
       +
         let has_bit1 = List.exists ((=) Types.Keywords.MailFlagBit1) flags in

     

       286
       286
       +
         let has_bit2 = List.exists ((=) Types.Keywords.MailFlagBit2) flags in

     

       287
       287
       +
         

     

       288
       288
       +
         match (has_bit0, has_bit1, has_bit2) with

     

       289
       289
       +
         | (true, false, false) -> Some `Red

     

       290
       290
       +
         | (false, true, false) -> Some `Orange

     

       291
       291
       +
         | (false, false, true) -> Some `Yellow

     

       292
       292
       +
         | (true, true, false) -> Some `Green

     

       293
       293
       +
         | (true, false, true) -> Some `Blue

     

       294
       294
       +
         | (false, true, true) -> Some `Purple

     

       295
       295
       +
         | (true, true, true) -> Some `Gray

     

       296
       296
       +
         | (false, false, false) -> None

     

       297
       297
       +
       

     

       298
       298
       +
       (* Filter builder - create JMAP filter from command line args *)

     

       299
       299
       +
       let build_filter account_id mailbox_id args =

     

       300
       300
       +
         let open Email_filter in

     

       301
       301
       +
         let filters = [] in

     

       302
       302
       +
         

     

       303
       303
       +
         (* Add filter conditions based on command-line args *)

     

       304
       304
       +
         let filters = match args.query with 

     

       305
       305
       +
           | "" -> filters 

     

       306
       306
       +
           | query -> create_fulltext_filter query :: filters 

     

       307
       307
       +
         in

     

       308
       308
       +
         

     

       309
       309
       +
         let filters = match args.from with

     

       310
       310
       +
           | None -> filters

     

       311
       311
       +
           | Some sender -> from sender :: filters

     

       312
       312
       +
         in

     

       313
       313
       +
         

     

       314
       314
       +
         let filters = 

     

       315
       315
       +
           if args.days > 0 then 

     

       316
       316
       +
             after (days_ago_date args.days) :: filters

     

       317
       317
       +
           else 

     

       318
       318
       +
             filters

     

       319
       319
       +
         in

     

       320
       320
       +
         

     

       321
       321
       +
         let filters = match mailbox_id with

     

       322
       322
       +
           | None -> filters

     

       323
       323
       +
           | Some id -> in_mailbox id :: filters

     

       324
       324
       +
         in

     

       325
       325
       +
         

     

       326
       326
       +
         let filters = match args.has_flag with

     

       327
       327
       +
           | None -> filters

     

       328
       328
       +
           | Some flag -> 

     

       329
       329
       +
               let kw = flag_to_keyword flag in

     

       330
       330
       +
               has_keyword kw :: filters

     

       331
       331
       +
         in

     

       332
       332
       +
         

     

       333
       333
       +
         let filters = match args.missing_flag with

     

       334
       334
       +
           | None -> filters

     

       335
       335
       +
           | Some flag ->

     

       336
       336
       +
               let kw = flag_to_keyword flag in

     

       337
       337
       +
               not_has_keyword kw :: filters

     

       338
       338
       +
         in

     

       339
       339
       +
         

     

       340
       340
       +
         (* Combine all filters with AND *)

     

       341
       341
       +
         match filters with

     

       342
       342
       +
         | [] -> Filter.condition (`Assoc [])  (* Empty filter *)

     

       343
       343
       +
         | [f] -> f

     

       344
       344
       +
         | filters -> Filter.and_ filters

     

       345
       345
       +
       

     

       346
       346
       +
       (* Display email flag information *)

     

       347
       347
       +
       let display_email_flags emails verbose =

     

       348
       348
       +
         Printf.printf "Emails and their flags:\n\n";

     

       349
       349
       +
         

     

       350
       350
       +
         emails |> List.iteri (fun i email ->

     

       351
       351
       +
           let id = Option.value (Types.Email.id email) ~default:"(unknown)" in

     

       352
       352
       +
           let subject = Option.value (Types.Email.subject email) ~default:"(no subject)" in

     

       353
       353
       +
           

     

       354
       354
       +
           let from_list = Option.value (Types.Email.from email) ~default:[] in

     

       355
       355
       +
           let from = match from_list with

     

       356
       356
       +
             | addr :: _ -> Types.Email_address.email addr

     

       357
       357
       +
             | [] -> "(unknown)"

     

       358
       358
       +
           in

     

       359
       359
       +
           

     

       360
       360
       +
           let date = match Types.Email.received_at email with

     

       361
       361
       +
             | Some d -> String.sub (ISO8601.string_of_datetime (Unix.gmtime d)) 0 19

     

       362
       362
       +
             | None -> "(unknown)"

     

       363
       363
       +
           in

     

       364
       364
       +
           

     

       365
       365
       +
           (* Get all keywords/flags *)

     

       366
       366
       +
           let keywords = match Types.Email.keywords email with

     

       367
       367
       +
             | Some kw -> kw

     

       368
       368
       +
             | None -> []

     

       369
       369
       +
           in

     

       370
       370
       +
           

     

       371
       371
       +
           (* Format keywords for display *)

     

       372
       372
       +
           let flag_strs = keywords |> List.map (fun kw ->

     

       373
       373
       +
             match kw with

     

       374
       374
       +
             | Types.Keywords.Draft -> "$draft"

     

       375
       375
       +
             | Types.Keywords.Seen -> "$seen"

     

       376
       376
       +
             | Types.Keywords.Flagged -> "$flagged"

     

       377
       377
       +
             | Types.Keywords.Answered -> "$answered"

     

       378
       378
       +
             | Types.Keywords.Forwarded -> "$forwarded"

     

       379
       379
       +
             | Types.Keywords.Phishing -> "$phishing"

     

       380
       380
       +
             | Types.Keywords.Junk -> "$junk"

     

       381
       381
       +
             | Types.Keywords.NotJunk -> "$notjunk"

     

       382
       382
       +
             | Types.Keywords.Custom c -> c

     

       383
       383
       +
             | Types.Keywords.Notify -> "$notify"

     

       384
       384
       +
             | Types.Keywords.Muted -> "$muted"

     

       385
       385
       +
             | Types.Keywords.Followed -> "$followed"

     

       386
       386
       +
             | Types.Keywords.Memo -> "$memo" 

     

       387
       387
       +
             | Types.Keywords.HasMemo -> "$hasmemo"

     

       388
       388
       +
             | Types.Keywords.Autosent -> "$autosent"

     

       389
       389
       +
             | Types.Keywords.Unsubscribed -> "$unsubscribed"

     

       390
       390
       +
             | Types.Keywords.CanUnsubscribe -> "$canunsubscribe"

     

       391
       391
       +
             | Types.Keywords.Imported -> "$imported"

     

       392
       392
       +
             | Types.Keywords.IsTrusted -> "$istrusted"

     

       393
       393
       +
             | Types.Keywords.MaskedEmail -> "$maskedemail"

     

       394
       394
       +
             | Types.Keywords.New -> "$new"

     

       395
       395
       +
             | Types.Keywords.MailFlagBit0 -> "$MailFlagBit0"

     

       396
       396
       +
             | Types.Keywords.MailFlagBit1 -> "$MailFlagBit1" 

     

       397
       397
       +
             | Types.Keywords.MailFlagBit2 -> "$MailFlagBit2"

     

       398
       398
       +
           ) in

     

       399
       399
       +
           

     

       400
       400
       +
           Printf.printf "Email %d: %s\n" (i + 1) subject;

     

       401
       401
       +
           Printf.printf "  ID:    %s\n" id;

     

       402
       402
       +
           

     

       403
       403
       +
           if verbose then begin

     

       404
       404
       +
             Printf.printf "  From:  %s\n" from;

     

       405
       405
       +
             Printf.printf "  Date:  %s\n" date;

     

       406
       406
       +
           end;

     

       407
       407
       +
           

     

       408
       408
       +
           (* Show color if applicable *)

     

       409
       409
       +
           begin match flags_to_color keywords with

     

       410
       410
       +
           | Some color ->

     

       411
       411
       +
               let color_name = match color with

     

       412
       412
       +
                 | `Red -> "Red"

     

       413
       413
       +
                 | `Orange -> "Orange"

     

       414
       414
       +
                 | `Yellow -> "Yellow" 

     

       415
       415
       +
                 | `Green -> "Green"

     

       416
       416
       +
                 | `Blue -> "Blue"

     

       417
       417
       +
                 | `Purple -> "Purple"

     

       418
       418
       +
                 | `Gray -> "Gray"

     

       419
       419
       +
               in

     

       420
       420
       +
               Printf.printf "  Color: %s\n" color_name

     

       421
       421
       +
           | None -> ()

     

       422
       422
       +
           end;

     

       423
       423
       +
           

     

       424
       424
       +
           Printf.printf "  Flags: %s\n\n" 

     

       425
       425
       +
             (if flag_strs = [] then "(none)" else String.concat ", " flag_strs)

     

       426
       426
       +
         );

     

       427
       427
       +
         

     

       428
       428
       +
         if List.length emails = 0 then

     

       429
       429
       +
           Printf.printf "No emails found matching criteria.\n"

     

       430
       430
       +
       

     

       431
       431
       +
       (* Command implementation *)

     

       432
       432
       +
       let flag_command host user _password list add_flag remove_flag query from days 

     

       433
       433
       +
                         mailbox ids has_flag missing_flag limit dry_run color verbose : int =

     

       434
       434
       +
         (* Pack arguments into a record for easier passing *)

     

       435
       435
       +
         let _args : flag_manager_args = {

     

       436
       436
       +
           list; add_flag; remove_flag; query; from; days; mailbox; 

     

       437
       437
       +
           ids; has_flag; missing_flag; limit; dry_run; color; verbose

     

       438
       438
       +
         } in

     

       439
       439
       +
         

     

       440
       440
       +
         (* Main workflow would be implemented here using the JMAP library *)

     

       441
       441
       +
         Printf.printf "JMAP Flag Manager\n";

     

       442
       442
       +
         Printf.printf "Server: %s\n" host;

     

       443
       443
       +
         Printf.printf "User: %s\n\n" user;

     

       444
       444
       +
         

     

       445
       445
       +
         if list then

     

       446
       446
       +
           Printf.printf "Listing emails with their flags...\n\n"

     

       447
       447
       +
         else begin

     

       448
       448
       +
           if add_flag <> None then

     

       449
       449
       +
             Printf.printf "Adding flag: %s\n" (Option.get add_flag);

     

       450
       450
       +
           

     

       451
       451
       +
           if remove_flag <> None then

     

       452
       452
       +
             Printf.printf "Removing flag: %s\n" (Option.get remove_flag);

     

       453
       453
       +
           

     

       454
       454
       +
           if color <> None then

     

       455
       455
       +
             let color_name = match Option.get color with

     

       456
       456
       +
               | `Red -> "Red"

     

       457
       457
       +
               | `Orange -> "Orange"

     

       458
       458
       +
               | `Yellow -> "Yellow" 

     

       459
       459
       +
               | `Green -> "Green"

     

       460
       460
       +
               | `Blue -> "Blue"

     

       461
       461
       +
               | `Purple -> "Purple"

     

       462
       462
       +
               | `Gray -> "Gray"

     

       463
       463
       +
               | `None -> "None"

     

       464
       464
       +
             in

     

       465
       465
       +
             Printf.printf "Setting color: %s\n" color_name;

     

       466
       466
       +
         end;

     

       467
       467
       +
         

     

       468
       468
       +
         if query <> "" then

     

       469
       469
       +
           Printf.printf "Filtering by query: %s\n" query;

     

       470
       470
       +
         

     

       471
       471
       +
         if from <> None then

     

       472
       472
       +
           Printf.printf "Filtering by sender: %s\n" (Option.get from);

     

       473
       473
       +
         

     

       474
       474
       +
         if mailbox <> None then

     

       475
       475
       +
           Printf.printf "Filtering by mailbox: %s\n" (Option.get mailbox);

     

       476
       476
       +
         

     

       477
       477
       +
         if ids <> [] then

     

       478
       478
       +
           Printf.printf "Operating on specific email IDs: %s\n" 

     

       479
       479
       +
             (String.concat ", " ids);

     

       480
       480
       +
         

     

       481
       481
       +
         if has_flag <> None then

     

       482
       482
       +
           Printf.printf "Filtering to emails with flag: %s\n" (Option.get has_flag);

     

       483
       483
       +
         

     

       484
       484
       +
         if missing_flag <> None then

     

       485
       485
       +
           Printf.printf "Filtering to emails without flag: %s\n" (Option.get missing_flag);

     

       486
       486
       +
         

     

       487
       487
       +
         Printf.printf "Limiting to %d emails\n" limit;

     

       488
       488
       +
         

     

       489
       489
       +
         if dry_run then

     

       490
       490
       +
           Printf.printf "DRY RUN MODE - No changes will be made\n";

     

       491
       491
       +
         

     

       492
       492
       +
         Printf.printf "\n";

     

       493
       493
       +
         

     

       494
       494
       +
         (* This is where the actual JMAP calls would happen, like:

     

       495
       495
       +
         

     

       496
       496
       +
         let manage_flags () =

     

       497
       497
       +
           let* (ctx, session) = Jmap.Unix.connect 

     

       498
       498
       +
             ~host ~username:user ~password 

     

       499
       499
       +
             ~auth_method:(Jmap.Unix.Basic(user, password)) () in

     

       500
       500
       +
           

     

       501
       501
       +
           (* Get primary account ID *)

     

       502
       502
       +
           let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       503
       503
       +
             | Ok id -> id

     

       504
       504
       +
             | Error _ -> failwith "No mail account found"

     

       505
       505
       +
           in

     

       506
       506
       +
           

     

       507
       507
       +
           (* Resolve mailbox name to ID if specified *)

     

       508
       508
       +
           let* mailbox_id_opt = match args.mailbox with

     

       509
       509
       +
             | None -> Lwt.return None

     

       510
       510
       +
             | Some name ->

     

       511
       511
       +
                 (* This would use Mailbox/query and Mailbox/get to resolve the name *)

     

       512
       512
       +
                 ...

     

       513
       513
       +
           in

     

       514
       514
       +
           

     

       515
       515
       +
           (* Find emails to operate on *)

     

       516
       516
       +
           let* emails = 

     

       517
       517
       +
             if args.ids <> [] then

     

       518
       518
       +
               (* Get emails by ID *)

     

       519
       519
       +
               let* result = Email.get ctx

     

       520
       520
       +
                 ~account_id

     

       521
       521
       +
                 ~ids:args.ids

     

       522
       522
       +
                 ~properties:["id"; "subject"; "from"; "receivedAt"; "keywords"] in

     

       523
       523
       +
               

     

       524
       524
       +
               match result with

     

       525
       525
       +
               | Error err ->

     

       526
       526
       +
                   Printf.eprintf "Error: %s\n" (Jmap.Error.error_to_string err);

     

       527
       527
       +
                   Lwt.return []

     

       528
       528
       +
               | Ok (_, emails) -> Lwt.return emails

     

       529
       529
       +
             else

     

       530
       530
       +
               (* Find emails by query *)

     

       531
       531
       +
               let filter = build_filter account_id mailbox_id_opt args in

     

       532
       532
       +
               

     

       533
       533
       +
               let* result = Email.query ctx

     

       534
       534
       +
                 ~account_id

     

       535
       535
       +
                 ~filter

     

       536
       536
       +
                 ~sort:[Email_sort.received_newest_first ()]

     

       537
       537
       +
                 ~limit:args.limit

     

       538
       538
       +
                 ~properties:["id"] in

     

       539
       539
       +
               

     

       540
       540
       +
               match result with

     

       541
       541
       +
               | Error err ->

     

       542
       542
       +
                   Printf.eprintf "Error: %s\n" (Jmap.Error.error_to_string err);

     

       543
       543
       +
                   Lwt.return []

     

       544
       544
       +
               | Ok (ids, _) ->

     

       545
       545
       +
                   (* Get full email objects for the matching IDs *)

     

       546
       546
       +
                   let* result = Email.get ctx

     

       547
       547
       +
                     ~account_id

     

       548
       548
       +
                     ~ids

     

       549
       549
       +
                     ~properties:["id"; "subject"; "from"; "receivedAt"; "keywords"] in

     

       550
       550
       +
                   

     

       551
       551
       +
                   match result with

     

       552
       552
       +
                   | Error err ->

     

       553
       553
       +
                       Printf.eprintf "Error: %s\n" (Jmap.Error.error_to_string err);

     

       554
       554
       +
                       Lwt.return []

     

       555
       555
       +
                   | Ok (_, emails) -> Lwt.return emails

     

       556
       556
       +
           in

     

       557
       557
       +
           

     

       558
       558
       +
           (* Just list the emails with their flags *)

     

       559
       559
       +
           if args.list then

     

       560
       560
       +
             display_email_flags emails args.verbose;

     

       561
       561
       +
             Lwt.return_unit

     

       562
       562
       +
           else if List.length emails = 0 then

     

       563
       563
       +
             Printf.printf "No emails found matching criteria.\n";

     

       564
       564
       +
             Lwt.return_unit

     

       565
       565
       +
           else

     

       566
       566
       +
             (* Perform flag operations *)

     

       567
       567
       +
             let ids = emails |> List.filter_map Types.Email.id in

     

       568
       568
       +
             

     

       569
       569
       +
             if args.dry_run then

     

       570
       570
       +
               display_email_flags emails args.verbose;

     

       571
       571
       +
               Lwt.return_unit

     

       572
       572
       +
             else

     

       573
       573
       +
               (* Create patch object *)

     

       574
       574
       +
               let make_patch () =

     

       575
       575
       +
                 let add_keywords = ref [] in

     

       576
       576
       +
                 let remove_keywords = ref [] in

     

       577
       577
       +
                 

     

       578
       578
       +
                 (* Handle add flag *)

     

       579
       579
       +
                 Option.iter (fun flag ->

     

       580
       580
       +
                   let keyword = flag_to_keyword flag in

     

       581
       581
       +
                   add_keywords := keyword :: !add_keywords

     

       582
       582
       +
                 ) args.add_flag;

     

       583
       583
       +
                 

     

       584
       584
       +
                 (* Handle remove flag *)

     

       585
       585
       +
                 Option.iter (fun flag ->

     

       586
       586
       +
                   let keyword = flag_to_keyword flag in

     

       587
       587
       +
                   remove_keywords := keyword :: !remove_keywords

     

       588
       588
       +
                 ) args.remove_flag;

     

       589
       589
       +
                 

     

       590
       590
       +
                 (* Handle color *)

     

       591
       591
       +
                 Option.iter (fun color ->

     

       592
       592
       +
                   (* First remove all color bits *)

     

       593
       593
       +
                   remove_keywords := Types.Keywords.MailFlagBit0 :: !remove_keywords;

     

       594
       594
       +
                   remove_keywords := Types.Keywords.MailFlagBit1 :: !remove_keywords;

     

       595
       595
       +
                   remove_keywords := Types.Keywords.MailFlagBit2 :: !remove_keywords;

     

       596
       596
       +
                   

     

       597
       597
       +
                   (* Then add the right combination for the requested color *)

     

       598
       598
       +
                   if color <> `None then begin

     

       599
       599
       +
                     let color_flags = color_to_flags color in

     

       600
       600
       +
                     add_keywords := color_flags @ !add_keywords

     

       601
       601
       +
                   end

     

       602
       602
       +
                 ) args.color;

     

       603
       603
       +
                 

     

       604
       604
       +
                 Email.make_patch

     

       605
       605
       +
                   ~add_keywords:!add_keywords

     

       606
       606
       +
                   ~remove_keywords:!remove_keywords

     

       607
       607
       +
                   ()

     

       608
       608
       +
               in

     

       609
       609
       +
               

     

       610
       610
       +
               let patch = make_patch () in

     

       611
       611
       +
               

     

       612
       612
       +
               let* result = Email.update ctx

     

       613
       613
       +
                 ~account_id

     

       614
       614
       +
                 ~ids

     

       615
       615
       +
                 ~update_each:(fun _ -> patch) in

     

       616
       616
       +
               

     

       617
       617
       +
               match result with

     

       618
       618
       +
               | Error err ->

     

       619
       619
       +
                   Printf.eprintf "Error: %s\n" (Jmap.Error.error_to_string err);

     

       620
       620
       +
                   Lwt.return_unit

     

       621
       621
       +
               | Ok updated ->

     

       622
       622
       +
                   Printf.printf "Successfully updated %d emails.\n" (List.length updated);

     

       623
       623
       +
                   Lwt.return_unit

     

       624
       624
       +
         *)

     

       625
       625
       +
         

     

       626
       626
       +
         if list then begin

     

       627
       627
       +
           (* Simulate having found a few emails *)

     

       628
       628
       +
           let count = 3 in

     

       629
       629
       +
           Printf.printf "Found %d matching emails:\n\n" count;

     

       630
       630
       +
           Printf.printf "Email 1: Meeting Agenda\n";

     

       631
       631
       +
           Printf.printf "  ID:    email123\n";

     

       632
       632
       +
           if verbose then begin

     

       633
       633
       +
             Printf.printf "  From:  alice@example.com\n";

     

       634
       634
       +
             Printf.printf "  Date:  2023-04-15 09:30:00\n";

     

       635
       635
       +
           end;

     

       636
       636
       +
           Printf.printf "  Flags: $seen, $flagged, $answered\n\n";

     

       637
       637
       +
           

     

       638
       638
       +
           Printf.printf "Email 2: Project Update\n";

     

       639
       639
       +
           Printf.printf "  ID:    email124\n";

     

       640
       640
       +
           if verbose then begin

     

       641
       641
       +
             Printf.printf "  From:  bob@example.com\n";

     

       642
       642
       +
             Printf.printf "  Date:  2023-04-16 14:45:00\n";

     

       643
       643
       +
           end;

     

       644
       644
       +
           Printf.printf "  Color: Red\n";

     

       645
       645
       +
           Printf.printf "  Flags: $seen, $MailFlagBit0\n\n";

     

       646
       646
       +
           

     

       647
       647
       +
           Printf.printf "Email 3: Weekly Newsletter\n";

     

       648
       648
       +
           Printf.printf "  ID:    email125\n";

     

       649
       649
       +
           if verbose then begin

     

       650
       650
       +
             Printf.printf "  From:  newsletter@example.com\n";

     

       651
       651
       +
             Printf.printf "  Date:  2023-04-17 08:15:00\n";

     

       652
       652
       +
           end;

     

       653
       653
       +
           Printf.printf "  Flags: $seen, $notjunk\n\n";

     

       654
       654
       +
         end else if add_flag <> None || remove_flag <> None || color <> None then begin

     

       655
       655
       +
           Printf.printf "Would modify %d emails:\n" 2;

     

       656
       656
       +
           if dry_run then

     

       657
       657
       +
             Printf.printf "(Dry run mode - no changes made)\n\n"

     

       658
       658
       +
           else

     

       659
       659
       +
             Printf.printf "Changes applied successfully\n\n";

     

       660
       660
       +
         end;

     

       661
       661
       +
         

     

       662
       662
       +
         (* List standard flags if no other actions specified *)

     

       663
       663
       +
         if not list && add_flag = None && remove_flag = None && color = None then begin

     

       664
       664
       +
           Printf.printf "Standard flags:\n";

     

       665
       665
       +
           get_standard_flags() |> List.iter (fun (flag, desc) ->

     

       666
       666
       +
             Printf.printf "  $%-12s %s\n" flag desc

     

       667
       667
       +
           );

     

       668
       668
       +
           

     

       669
       669
       +
           Printf.printf "\nColor flags:\n";

     

       670
       670
       +
           Printf.printf "  $MailFlagBit0    Red\n";

     

       671
       671
       +
           Printf.printf "  $MailFlagBit1    Orange\n";

     

       672
       672
       +
           Printf.printf "  $MailFlagBit2    Yellow\n";

     

       673
       673
       +
           Printf.printf "  $MailFlagBit0+1  Green\n";

     

       674
       674
       +
           Printf.printf "  $MailFlagBit0+2  Blue\n";

     

       675
       675
       +
           Printf.printf "  $MailFlagBit1+2  Purple\n";

     

       676
       676
       +
           Printf.printf "  $MailFlagBit0+1+2 Gray\n";

     

       677
       677
       +
         end;

     

       678
       678
       +
         

     

       679
       679
       +
         (* Since we're only type checking, we'll exit with success *)

     

       680
       680
       +
         0

     

       681
       681
       +
       

     

       682
       682
       +
       (* Command definition *)

     

       683
       683
       +
       let flag_cmd =

     

       684
       684
       +
         let doc = "manage email flags using JMAP" in

     

       685
       685
       +
         let man = [

     

       686
       686
       +
           `S Manpage.s_description;

     

       687
       687
       +
           `P "Lists, adds, and removes flags (keywords) from emails using JMAP.";

     

       688
       688
       +
           `P "Demonstrates JMAP's flag/keyword management capabilities.";

     

       689
       689
       +
           `S Manpage.s_examples;

     

       690
       690
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --list";

     

       691
       691
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --add flagged --from boss@example.com";

     

       692
       692
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --color red --mailbox Inbox --has-flag seen --missing-flag flagged";

     

       693
       693
       +
         ] in

     

       694
       694
       +
         

     

       695
       695
       +
         let cmd =

     

       696
       696
       +
           Cmd.v

     

       697
       697
       +
             (Cmd.info "jmap-flag-manager" ~version:"1.0" ~doc ~man)

     

       698
       698
       +
             Term.(const flag_command $ host_arg $ user_arg $ password_arg $ 

     

       699
       699
       +
                   list_arg $ add_flag_arg $ remove_flag_arg $ query_arg $ 

     

       700
       700
       +
                   from_arg $ days_arg $ mailbox_arg $ ids_arg $ has_flag_arg $ 

     

       701
       701
       +
                   missing_flag_arg $ limit_arg $ dry_run_arg $ color_arg $ verbose_arg)

     

       702
       702
       +
         in

     

       703
       703
       +
         cmd

     

       704
       704
       +
       

     

       705
       705
       +
       (* Main entry point *)

     

       706
       706
       +
       let () = exit (Cmd.eval' flag_cmd)

+620

bin/jmap_identity_monitor.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_identity_monitor.ml - A tool for monitoring email delivery status

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's identity and submission tracking capabilities,

     

       5
       5
       +
        * allowing users to monitor email delivery status and manage email identities.

     

       6
       6
       +
        *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Cmdliner

     

       9
       9
       +
       (* Using standard OCaml, no Lwt *)

     

       10
       10
       +
       

     

       11
       11
       +
       (* JMAP imports *)

     

       12
       12
       +
       open Jmap

     

       13
       13
       +
       open Jmap.Types

     

       14
       14
       +
       open Jmap.Wire

     

       15
       15
       +
       open Jmap.Methods

     

       16
       16
       +
       open Jmap_email

     

       17
       17
       +
       (* For step 2, we're only testing type checking. No implementations required. *)

     

       18
       18
       +
       

     

       19
       19
       +
       (* Dummy Unix module for type checking *)

     

       20
       20
       +
       module Unix = struct

     

       21
       21
       +
         type tm = {

     

       22
       22
       +
           tm_sec : int;

     

       23
       23
       +
           tm_min : int;

     

       24
       24
       +
           tm_hour : int;

     

       25
       25
       +
           tm_mday : int;

     

       26
       26
       +
           tm_mon : int;

     

       27
       27
       +
           tm_year : int;

     

       28
       28
       +
           tm_wday : int;

     

       29
       29
       +
           tm_yday : int;

     

       30
       30
       +
           tm_isdst : bool

     

       31
       31
       +
         }

     

       32
       32
       +
         

     

       33
       33
       +
         let time () = 0.0

     

       34
       34
       +
         let gettimeofday () = 0.0

     

       35
       35
       +
         let mktime tm = (0.0, tm)

     

       36
       36
       +
         let gmtime _time = {

     

       37
       37
       +
           tm_sec = 0; tm_min = 0; tm_hour = 0;

     

       38
       38
       +
           tm_mday = 1; tm_mon = 0; tm_year = 120;

     

       39
       39
       +
           tm_wday = 0; tm_yday = 0; tm_isdst = false;

     

       40
       40
       +
         }

     

       41
       41
       +
         

     

       42
       42
       +
         (* JMAP connection function - would be in a real implementation *)

     

       43
       43
       +
         let connect ~host ~username ~password ?auth_method () =

     

       44
       44
       +
           failwith "Not implemented"

     

       45
       45
       +
       end

     

       46
       46
       +
       

     

       47
       47
       +
       (* Dummy ISO8601 module *)

     

       48
       48
       +
       module ISO8601 = struct

     

       49
       49
       +
         let string_of_datetime _tm = "2023-01-01T00:00:00Z"

     

       50
       50
       +
       end

     

       51
       51
       +
       

     

       52
       52
       +
       (** Email submission and delivery status types *)

     

       53
       53
       +
       type email_envelope_address = {

     

       54
       54
       +
         env_addr_email : string;

     

       55
       55
       +
         env_addr_parameters : (string * string) list;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       type email_envelope = {

     

       59
       59
       +
         env_mail_from : email_envelope_address;

     

       60
       60
       +
         env_rcpt_to : email_envelope_address list;

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       type email_delivery_status = {

     

       64
       64
       +
         delivery_smtp_reply : string;

     

       65
       65
       +
         delivery_delivered : [`Queued | `Yes | `No | `Unknown];

     

       66
       66
       +
         delivery_displayed : [`Yes | `Unknown];

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       type email_submission = {

     

       70
       70
       +
         email_sub_id : string;

     

       71
       71
       +
         email_id : string;

     

       72
       72
       +
         thread_id : string;

     

       73
       73
       +
         identity_id : string;

     

       74
       74
       +
         send_at : float;

     

       75
       75
       +
         undo_status : [`Pending | `Final | `Canceled];

     

       76
       76
       +
         envelope : email_envelope option;

     

       77
       77
       +
         delivery_status : (string, email_delivery_status) Hashtbl.t option;

     

       78
       78
       +
         dsn_blob_ids : string list;

     

       79
       79
       +
         mdn_blob_ids : string list;

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       (** Dummy Email_address module to replace Jmap_email_types.Email_address *)

     

       83
       83
       +
       module Email_address = struct

     

       84
       84
       +
         type t = string

     

       85
       85
       +
         let email addr = "user@example.com"

     

       86
       86
       +
       end

     

       87
       87
       +
       

     

       88
       88
       +
       (** Dummy Identity module *)

     

       89
       89
       +
       module Identity = struct

     

       90
       90
       +
         type t = {

     

       91
       91
       +
           id : string;

     

       92
       92
       +
           name : string;

     

       93
       93
       +
           email : string;

     

       94
       94
       +
           reply_to : Email_address.t list option;

     

       95
       95
       +
           bcc : Email_address.t list option;

     

       96
       96
       +
           text_signature : string;

     

       97
       97
       +
           html_signature : string;

     

       98
       98
       +
           may_delete : bool;

     

       99
       99
       +
         }

     

       100
       100
       +
         

     

       101
       101
       +
         let id identity = identity.id

     

       102
       102
       +
         let name identity = identity.name

     

       103
       103
       +
         let email identity = identity.email

     

       104
       104
       +
         let reply_to identity = identity.reply_to

     

       105
       105
       +
         let bcc identity = identity.bcc

     

       106
       106
       +
         let text_signature identity = identity.text_signature

     

       107
       107
       +
         let html_signature identity = identity.html_signature

     

       108
       108
       +
         let may_delete identity = identity.may_delete

     

       109
       109
       +
       end

     

       110
       110
       +
       

     

       111
       111
       +
       (** Identity monitor args type *)

     

       112
       112
       +
       type identity_monitor_args = {

     

       113
       113
       +
         list_identities : bool;

     

       114
       114
       +
         show_identity : string option;

     

       115
       115
       +
         create_identity : string option;

     

       116
       116
       +
         identity_name : string option;

     

       117
       117
       +
         reply_to : string option;

     

       118
       118
       +
         signature : string option;

     

       119
       119
       +
         html_signature : string option;

     

       120
       120
       +
         list_submissions : bool;

     

       121
       121
       +
         show_submission : string option;

     

       122
       122
       +
         track_submission : string option;

     

       123
       123
       +
         pending_only : bool;

     

       124
       124
       +
         query : string option;

     

       125
       125
       +
         days : int;

     

       126
       126
       +
         limit : int;

     

       127
       127
       +
         cancel_submission : string option;

     

       128
       128
       +
         format : [`Summary | `Detailed | `Json | `StatusOnly];

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       131
       131
       +
       (** Command-line arguments **)

     

       132
       132
       +
       

     

       133
       133
       +
       let host_arg =

     

       134
       134
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       135
       135
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       136
       136
       +
       

     

       137
       137
       +
       let user_arg =

     

       138
       138
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       139
       139
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       140
       140
       +
       

     

       141
       141
       +
       let password_arg =

     

       142
       142
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       143
       143
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       144
       144
       +
       

     

       145
       145
       +
       (* Commands *)

     

       146
       146
       +
       

     

       147
       147
       +
       (* Identity-related commands *)

     

       148
       148
       +
       let list_identities_arg =

     

       149
       149
       +
         Arg.(value & flag & info ["list-identities"] ~doc:"List all email identities")

     

       150
       150
       +
       

     

       151
       151
       +
       let show_identity_arg =

     

       152
       152
       +
         Arg.(value & opt (some string) None & info ["show-identity"] 

     

       153
       153
       +
              ~docv:"ID" ~doc:"Show details for a specific identity")

     

       154
       154
       +
       

     

       155
       155
       +
       let create_identity_arg =

     

       156
       156
       +
         Arg.(value & opt (some string) None & info ["create-identity"] 

     

       157
       157
       +
              ~docv:"EMAIL" ~doc:"Create a new identity with the specified email address")

     

       158
       158
       +
       

     

       159
       159
       +
       let identity_name_arg =

     

       160
       160
       +
         Arg.(value & opt (some string) None & info ["name"] 

     

       161
       161
       +
              ~docv:"NAME" ~doc:"Display name for the identity (when creating)")

     

       162
       162
       +
       

     

       163
       163
       +
       let reply_to_arg =

     

       164
       164
       +
         Arg.(value & opt (some string) None & info ["reply-to"] 

     

       165
       165
       +
              ~docv:"EMAIL" ~doc:"Reply-to address for the identity (when creating)")

     

       166
       166
       +
       

     

       167
       167
       +
       let signature_arg =

     

       168
       168
       +
         Arg.(value & opt (some string) None & info ["signature"] 

     

       169
       169
       +
              ~docv:"SIGNATURE" ~doc:"Text signature for the identity (when creating)")

     

       170
       170
       +
       

     

       171
       171
       +
       let html_signature_arg =

     

       172
       172
       +
         Arg.(value & opt (some string) None & info ["html-signature"] 

     

       173
       173
       +
              ~docv:"HTML" ~doc:"HTML signature for the identity (when creating)")

     

       174
       174
       +
       

     

       175
       175
       +
       (* Submission-related commands *)

     

       176
       176
       +
       let list_submissions_arg =

     

       177
       177
       +
         Arg.(value & flag & info ["list-submissions"] ~doc:"List recent email submissions")

     

       178
       178
       +
       

     

       179
       179
       +
       let show_submission_arg =

     

       180
       180
       +
         Arg.(value & opt (some string) None & info ["show-submission"] 

     

       181
       181
       +
              ~docv:"ID" ~doc:"Show details for a specific submission")

     

       182
       182
       +
       

     

       183
       183
       +
       let track_submission_arg =

     

       184
       184
       +
         Arg.(value & opt (some string) None & info ["track"] 

     

       185
       185
       +
              ~docv:"ID" ~doc:"Track delivery status for a specific submission")

     

       186
       186
       +
       

     

       187
       187
       +
       let pending_only_arg =

     

       188
       188
       +
         Arg.(value & flag & info ["pending-only"] ~doc:"Show only pending submissions")

     

       189
       189
       +
       

     

       190
       190
       +
       let query_arg =

     

       191
       191
       +
         Arg.(value & opt (some string) None & info ["query"] 

     

       192
       192
       +
              ~docv:"QUERY" ~doc:"Search for submissions containing text in associated email")

     

       193
       193
       +
       

     

       194
       194
       +
       let days_arg =

     

       195
       195
       +
         Arg.(value & opt int 7 & info ["days"] 

     

       196
       196
       +
              ~docv:"DAYS" ~doc:"Limit to submissions from the past N days")

     

       197
       197
       +
       

     

       198
       198
       +
       let limit_arg =

     

       199
       199
       +
         Arg.(value & opt int 20 & info ["limit"] 

     

       200
       200
       +
              ~docv:"N" ~doc:"Maximum number of results to display")

     

       201
       201
       +
       

     

       202
       202
       +
       let cancel_submission_arg =

     

       203
       203
       +
         Arg.(value & opt (some string) None & info ["cancel"] 

     

       204
       204
       +
              ~docv:"ID" ~doc:"Cancel a pending email submission")

     

       205
       205
       +
       

     

       206
       206
       +
       let format_arg =

     

       207
       207
       +
         Arg.(value & opt (enum [

     

       208
       208
       +
           "summary", `Summary;

     

       209
       209
       +
           "detailed", `Detailed;

     

       210
       210
       +
           "json", `Json;

     

       211
       211
       +
           "status-only", `StatusOnly;

     

       212
       212
       +
         ]) `Summary & info ["format"] ~docv:"FORMAT" ~doc:"Output format")

     

       213
       213
       +
       

     

       214
       214
       +
       (** Main functionality **)

     

       215
       215
       +
       

     

       216
       216
       +
       (* Format an identity for display *)

     

       217
       217
       +
       let format_identity identity format =

     

       218
       218
       +
         match format with

     

       219
       219
       +
         | `Summary ->

     

       220
       220
       +
             let id = Identity.id identity in

     

       221
       221
       +
             let name = Identity.name identity in

     

       222
       222
       +
             let email = Identity.email identity in

     

       223
       223
       +
             Printf.printf "%s: %s <%s>\n" id name email

     

       224
       224
       +
         

     

       225
       225
       +
         | `Detailed ->

     

       226
       226
       +
             let id = Identity.id identity in

     

       227
       227
       +
             let name = Identity.name identity in

     

       228
       228
       +
             let email = Identity.email identity in

     

       229
       229
       +
             

     

       230
       230
       +
             let reply_to = match Identity.reply_to identity with

     

       231
       231
       +
               | Some addresses -> addresses 

     

       232
       232
       +
                   |> List.map (fun addr -> Email_address.email addr)

     

       233
       233
       +
                   |> String.concat ", "

     

       234
       234
       +
               | None -> "(none)"

     

       235
       235
       +
             in

     

       236
       236
       +
             

     

       237
       237
       +
             let bcc = match Identity.bcc identity with

     

       238
       238
       +
               | Some addresses -> addresses 

     

       239
       239
       +
                   |> List.map (fun addr -> Email_address.email addr)

     

       240
       240
       +
                   |> String.concat ", "

     

       241
       241
       +
               | None -> "(none)"

     

       242
       242
       +
             in

     

       243
       243
       +
             

     

       244
       244
       +
             let may_delete = if Identity.may_delete identity then "Yes" else "No" in

     

       245
       245
       +
             

     

       246
       246
       +
             Printf.printf "Identity: %s\n" id;

     

       247
       247
       +
             Printf.printf "  Name:       %s\n" name;

     

       248
       248
       +
             Printf.printf "  Email:      %s\n" email;

     

       249
       249
       +
             Printf.printf "  Reply-To:   %s\n" reply_to;

     

       250
       250
       +
             Printf.printf "  BCC:        %s\n" bcc;

     

       251
       251
       +
             

     

       252
       252
       +
             if Identity.text_signature identity <> "" then

     

       253
       253
       +
               Printf.printf "  Signature:  %s\n" (Identity.text_signature identity);

     

       254
       254
       +
             

     

       255
       255
       +
             if Identity.html_signature identity <> "" then

     

       256
       256
       +
               Printf.printf "  HTML Sig:   (HTML signature available)\n";

     

       257
       257
       +
             

     

       258
       258
       +
             Printf.printf "  Deletable:  %s\n" may_delete

     

       259
       259
       +
         

     

       260
       260
       +
         | `Json ->

     

       261
       261
       +
             let id = Identity.id identity in

     

       262
       262
       +
             let name = Identity.name identity in

     

       263
       263
       +
             let email = Identity.email identity in

     

       264
       264
       +
             Printf.printf "{\n";

     

       265
       265
       +
             Printf.printf "  \"id\": \"%s\",\n" id;

     

       266
       266
       +
             Printf.printf "  \"name\": \"%s\",\n" name;

     

       267
       267
       +
             Printf.printf "  \"email\": \"%s\"\n" email;

     

       268
       268
       +
             Printf.printf "}\n"

     

       269
       269
       +
             

     

       270
       270
       +
         | _ -> ()  (* Other formats don't apply to identities *)

     

       271
       271
       +
       

     

       272
       272
       +
       (* Format delivery status *)

     

       273
       273
       +
       let format_delivery_status rcpt status =

     

       274
       274
       +
         let status_str = match status.delivery_delivered with

     

       275
       275
       +
           | `Queued -> "Queued"

     

       276
       276
       +
           | `Yes -> "Delivered"

     

       277
       277
       +
           | `No -> "Failed"

     

       278
       278
       +
           | `Unknown -> "Unknown"

     

       279
       279
       +
         in

     

       280
       280
       +
         

     

       281
       281
       +
         let display_str = match status.delivery_displayed with

     

       282
       282
       +
           | `Yes -> "Displayed"

     

       283
       283
       +
           | `Unknown -> "Unknown if displayed"

     

       284
       284
       +
         in

     

       285
       285
       +
         

     

       286
       286
       +
         Printf.printf "  %s: %s, %s\n" rcpt status_str display_str;

     

       287
       287
       +
         Printf.printf "    SMTP Reply: %s\n" status.delivery_smtp_reply

     

       288
       288
       +
       

     

       289
       289
       +
       (* Format a submission for display *)

     

       290
       290
       +
       let format_submission submission format =

     

       291
       291
       +
         match format with

     

       292
       292
       +
         | `Summary ->

     

       293
       293
       +
             let id = submission.email_sub_id in

     

       294
       294
       +
             let email_id = submission.email_id in

     

       295
       295
       +
             let send_at = String.sub (ISO8601.string_of_datetime (Unix.gmtime submission.send_at)) 0 19 in

     

       296
       296
       +
             

     

       297
       297
       +
             let status = match submission.undo_status with

     

       298
       298
       +
               | `Pending -> "Pending"

     

       299
       299
       +
               | `Final -> "Final"

     

       300
       300
       +
               | `Canceled -> "Canceled"

     

       301
       301
       +
             in

     

       302
       302
       +
             

     

       303
       303
       +
             let delivery_count = match submission.delivery_status with

     

       304
       304
       +
               | Some statuses -> Hashtbl.length statuses

     

       305
       305
       +
               | None -> 0

     

       306
       306
       +
             in

     

       307
       307
       +
             

     

       308
       308
       +
             Printf.printf "%s: [%s] Sent at %s (Email ID: %s, Recipients: %d)\n" 

     

       309
       309
       +
               id status send_at email_id delivery_count

     

       310
       310
       +
         

     

       311
       311
       +
         | `Detailed ->

     

       312
       312
       +
             let id = submission.email_sub_id in

     

       313
       313
       +
             let email_id = submission.email_id in

     

       314
       314
       +
             let thread_id = submission.thread_id in

     

       315
       315
       +
             let identity_id = submission.identity_id in

     

       316
       316
       +
             let send_at = String.sub (ISO8601.string_of_datetime (Unix.gmtime submission.send_at)) 0 19 in

     

       317
       317
       +
             

     

       318
       318
       +
             let status = match submission.undo_status with

     

       319
       319
       +
               | `Pending -> "Pending"

     

       320
       320
       +
               | `Final -> "Final"

     

       321
       321
       +
               | `Canceled -> "Canceled"

     

       322
       322
       +
             in

     

       323
       323
       +
             

     

       324
       324
       +
             Printf.printf "Submission: %s\n" id;

     

       325
       325
       +
             Printf.printf "  Status:     %s\n" status;

     

       326
       326
       +
             Printf.printf "  Sent at:    %s\n" send_at;

     

       327
       327
       +
             Printf.printf "  Email ID:   %s\n" email_id;

     

       328
       328
       +
             Printf.printf "  Thread ID:  %s\n" thread_id;

     

       329
       329
       +
             Printf.printf "  Identity:   %s\n" identity_id;

     

       330
       330
       +
             

     

       331
       331
       +
             (* Display envelope information if available *)

     

       332
       332
       +
             (match submission.envelope with

     

       333
       333
       +
             | Some env ->

     

       334
       334
       +
                 Printf.printf "  Envelope:\n";

     

       335
       335
       +
                 Printf.printf "    From: %s\n" env.env_mail_from.env_addr_email;

     

       336
       336
       +
                 Printf.printf "    To:   %s\n" 

     

       337
       337
       +
                   (env.env_rcpt_to |> List.map (fun addr -> addr.env_addr_email) |> String.concat ", ")

     

       338
       338
       +
             | None -> ());

     

       339
       339
       +
             

     

       340
       340
       +
             (* Display delivery status *)

     

       341
       341
       +
             (match submission.delivery_status with

     

       342
       342
       +
             | Some statuses ->

     

       343
       343
       +
                 Printf.printf "  Delivery Status:\n";

     

       344
       344
       +
                 statuses |> Hashtbl.iter format_delivery_status

     

       345
       345
       +
             | None -> Printf.printf "  Delivery Status: Not available\n");

     

       346
       346
       +
             

     

       347
       347
       +
             (* DSN and MDN information *)

     

       348
       348
       +
             if submission.dsn_blob_ids <> [] then

     

       349
       349
       +
               Printf.printf "  DSN Blobs:  %d available\n" (List.length submission.dsn_blob_ids);

     

       350
       350
       +
             

     

       351
       351
       +
             if submission.mdn_blob_ids <> [] then

     

       352
       352
       +
               Printf.printf "  MDN Blobs:  %d available\n" (List.length submission.mdn_blob_ids)

     

       353
       353
       +
         

     

       354
       354
       +
         | `Json ->

     

       355
       355
       +
             let id = submission.email_sub_id in

     

       356
       356
       +
             let email_id = submission.email_id in

     

       357
       357
       +
             let send_at_str = String.sub (ISO8601.string_of_datetime (Unix.gmtime submission.send_at)) 0 19 in

     

       358
       358
       +
             

     

       359
       359
       +
             let status_str = match submission.undo_status with

     

       360
       360
       +
               | `Pending -> "pending"

     

       361
       361
       +
               | `Final -> "final"

     

       362
       362
       +
               | `Canceled -> "canceled"

     

       363
       363
       +
             in

     

       364
       364
       +
             

     

       365
       365
       +
             Printf.printf "{\n";

     

       366
       366
       +
             Printf.printf "  \"id\": \"%s\",\n" id;

     

       367
       367
       +
             Printf.printf "  \"emailId\": \"%s\",\n" email_id;

     

       368
       368
       +
             Printf.printf "  \"sendAt\": \"%s\",\n" send_at_str;

     

       369
       369
       +
             Printf.printf "  \"undoStatus\": \"%s\"\n" status_str;

     

       370
       370
       +
             Printf.printf "}\n"

     

       371
       371
       +
             

     

       372
       372
       +
         | `StatusOnly ->

     

       373
       373
       +
             let id = submission.email_sub_id in

     

       374
       374
       +
             

     

       375
       375
       +
             let status = match submission.undo_status with

     

       376
       376
       +
               | `Pending -> "Pending"

     

       377
       377
       +
               | `Final -> "Final"

     

       378
       378
       +
               | `Canceled -> "Canceled"

     

       379
       379
       +
             in

     

       380
       380
       +
             

     

       381
       381
       +
             Printf.printf "Submission %s: %s\n" id status;

     

       382
       382
       +
             

     

       383
       383
       +
             (* Display delivery status summary *)

     

       384
       384
       +
             match submission.delivery_status with

     

       385
       385
       +
             | Some statuses ->

     

       386
       386
       +
                 let total = Hashtbl.length statuses in

     

       387
       387
       +
                 let delivered = Hashtbl.fold (fun _ status count ->

     

       388
       388
       +
                   if status.delivery_delivered = `Yes then count + 1 else count

     

       389
       389
       +
                 ) statuses 0 in

     

       390
       390
       +
                 

     

       391
       391
       +
                 let failed = Hashtbl.fold (fun _ status count ->

     

       392
       392
       +
                   if status.delivery_delivered = `No then count + 1 else count

     

       393
       393
       +
                 ) statuses 0 in

     

       394
       394
       +
                 

     

       395
       395
       +
                 let queued = Hashtbl.fold (fun _ status count ->

     

       396
       396
       +
                   if status.delivery_delivered = `Queued then count + 1 else count

     

       397
       397
       +
                 ) statuses 0 in

     

       398
       398
       +
                 

     

       399
       399
       +
                 Printf.printf "  Total recipients: %d\n" total;

     

       400
       400
       +
                 Printf.printf "  Delivered: %d\n" delivered;

     

       401
       401
       +
                 Printf.printf "  Failed: %d\n" failed;

     

       402
       402
       +
                 Printf.printf "  Queued: %d\n" queued

     

       403
       403
       +
             | None -> 

     

       404
       404
       +
                 Printf.printf "  Delivery status not available\n"

     

       405
       405
       +
       

     

       406
       406
       +
       (* Create an identity with provided details *)

     

       407
       407
       +
       let create_identity_command email name reply_to signature html_signature =

     

       408
       408
       +
         (* In a real implementation, this would validate inputs and create the identity *)

     

       409
       409
       +
         Printf.printf "Creating identity for email: %s\n" email;

     

       410
       410
       +
         

     

       411
       411
       +
         if name <> None then

     

       412
       412
       +
           Printf.printf "Name: %s\n" (Option.get name);

     

       413
       413
       +
         

     

       414
       414
       +
         if reply_to <> None then

     

       415
       415
       +
           Printf.printf "Reply-To: %s\n" (Option.get reply_to);

     

       416
       416
       +
         

     

       417
       417
       +
         if signature <> None || html_signature <> None then

     

       418
       418
       +
           Printf.printf "Signature: Provided\n";

     

       419
       419
       +
         

     

       420
       420
       +
         Printf.printf "\nIdentity creation would be implemented here using JMAP.Identity.create\n";

     

       421
       421
       +
         ()

     

       422
       422
       +
       

     

       423
       423
       +
       (* Command implementation for identity monitoring *)

     

       424
       424
       +
       let identity_command host user password list_identities show_identity 

     

       425
       425
       +
                            create_identity identity_name reply_to signature 

     

       426
       426
       +
                            html_signature list_submissions show_submission track_submission

     

       427
       427
       +
                            pending_only query days limit cancel_submission format : int =

     

       428
       428
       +
         (* Pack arguments into a record for easier passing *)

     

       429
       429
       +
         let args : identity_monitor_args = {

     

       430
       430
       +
           list_identities; show_identity; create_identity; identity_name; 

     

       431
       431
       +
           reply_to; signature; html_signature; list_submissions; 

     

       432
       432
       +
           show_submission; track_submission; pending_only; query; 

     

       433
       433
       +
           days; limit; cancel_submission; format

     

       434
       434
       +
         } in

     

       435
       435
       +
         

     

       436
       436
       +
         (* Main workflow would be implemented here using the JMAP library *)

     

       437
       437
       +
         Printf.printf "JMAP Identity & Submission Monitor\n";

     

       438
       438
       +
         Printf.printf "Server: %s\n" host;

     

       439
       439
       +
         Printf.printf "User: %s\n\n" user;

     

       440
       440
       +
         

     

       441
       441
       +
         (* This is where the actual JMAP calls would happen, like:

     

       442
       442
       +
         

     

       443
       443
       +
         let monitor_identities_and_submissions () =

     

       444
       444
       +
           let* (ctx, session) = Jmap.Unix.connect 

     

       445
       445
       +
             ~host ~username:user ~password 

     

       446
       446
       +
             ~auth_method:(Jmap.Unix.Basic(user, password)) () in

     

       447
       447
       +
           

     

       448
       448
       +
           (* Get primary account ID *)

     

       449
       449
       +
           let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       450
       450
       +
             | Ok id -> id

     

       451
       451
       +
             | Error _ -> failwith "No mail account found"

     

       452
       452
       +
           in

     

       453
       453
       +
           

     

       454
       454
       +
           (* Handle various command options *)

     

       455
       455
       +
           if args.list_identities then

     

       456
       456
       +
             (* Get all identities *)

     

       457
       457
       +
             let* identity_result = Jmap_email.Identity.get ctx

     

       458
       458
       +
               ~account_id

     

       459
       459
       +
               ~ids:None in

     

       460
       460
       +
             

     

       461
       461
       +
             match identity_result with

     

       462
       462
       +
             | Error err -> Printf.eprintf "Error: %s\n" (Jmap.Error.error_to_string err); Lwt.return 1

     

       463
       463
       +
             | Ok (_, identities) ->

     

       464
       464
       +
                 Printf.printf "Found %d identities:\n\n" (List.length identities);

     

       465
       465
       +
                 identities |> List.iter (fun identity ->

     

       466
       466
       +
                   format_identity identity args.format

     

       467
       467
       +
                 );

     

       468
       468
       +
                 Lwt.return 0

     

       469
       469
       +
           

     

       470
       470
       +
           else if args.show_identity <> None then

     

       471
       471
       +
             (* Get specific identity *)

     

       472
       472
       +
             let id = Option.get args.show_identity in

     

       473
       473
       +
             let* identity_result = Jmap_email.Identity.get ctx

     

       474
       474
       +
               ~account_id

     

       475
       475
       +
               ~ids:[id] in

     

       476
       476
       +
             

     

       477
       477
       +
             match identity_result with

     

       478
       478
       +
             | Error err -> Printf.eprintf "Error: %s\n" (Jmap.Error.error_to_string err); Lwt.return 1

     

       479
       479
       +
             | Ok (_, identities) ->

     

       480
       480
       +
                 match identities with

     

       481
       481
       +
                 | [identity] ->

     

       482
       482
       +
                     format_identity identity args.format;

     

       483
       483
       +
                     Lwt.return 0

     

       484
       484
       +
                 | _ ->

     

       485
       485
       +
                     Printf.eprintf "Identity not found: %s\n" id;

     

       486
       486
       +
                     Lwt.return 1

     

       487
       487
       +
           

     

       488
       488
       +
           else if args.create_identity <> None then

     

       489
       489
       +
             (* Create a new identity *)

     

       490
       490
       +
             let email = Option.get args.create_identity in

     

       491
       491
       +
             create_identity_command email args.identity_name args.reply_to 

     

       492
       492
       +
                                    args.signature args.html_signature

     

       493
       493
       +
           

     

       494
       494
       +
           else if args.list_submissions then

     

       495
       495
       +
             (* List all submissions, with optional filtering *)

     

       496
       496
       +
             ...

     

       497
       497
       +
           

     

       498
       498
       +
           else if args.show_submission <> None then

     

       499
       499
       +
             (* Show specific submission details *)

     

       500
       500
       +
             ...

     

       501
       501
       +
           

     

       502
       502
       +
           else if args.track_submission <> None then

     

       503
       503
       +
             (* Track delivery status for a specific submission *)

     

       504
       504
       +
             ...

     

       505
       505
       +
           

     

       506
       506
       +
           else if args.cancel_submission <> None then

     

       507
       507
       +
             (* Cancel a pending submission *)

     

       508
       508
       +
             ...

     

       509
       509
       +
           

     

       510
       510
       +
           else

     

       511
       511
       +
             (* No specific command given, show help *)

     

       512
       512
       +
             Printf.printf "Please specify a command. Use --help for options.\n";

     

       513
       513
       +
             Lwt.return 1

     

       514
       514
       +
         *)

     

       515
       515
       +
         

     

       516
       516
       +
         (if list_identities then begin

     

       517
       517
       +
           (* Simulate listing identities *)

     

       518
       518
       +
           Printf.printf "Found 3 identities:\n\n";

     

       519
       519
       +
           Printf.printf "id1: John Doe <john@example.com>\n";

     

       520
       520
       +
           Printf.printf "id2: John Work <john@work.example.com>\n";

     

       521
       521
       +
           Printf.printf "id3: Support <support@example.com>\n"

     

       522
       522
       +
         end

     

       523
       523
       +
         else if show_identity <> None then begin

     

       524
       524
       +
           (* Simulate showing a specific identity *)

     

       525
       525
       +
           Printf.printf "Identity: %s\n" (Option.get show_identity);

     

       526
       526
       +
           Printf.printf "  Name:       John Doe\n";

     

       527
       527
       +
           Printf.printf "  Email:      john@example.com\n";

     

       528
       528
       +
           Printf.printf "  Reply-To:   (none)\n";

     

       529
       529
       +
           Printf.printf "  BCC:        (none)\n";

     

       530
       530
       +
           Printf.printf "  Signature:  Best regards,\nJohn\n";

     

       531
       531
       +
           Printf.printf "  Deletable:  Yes\n"

     

       532
       532
       +
         end

     

       533
       533
       +
         

     

       534
       534
       +
         else if create_identity <> None then begin

     

       535
       535
       +
           (* Create a new identity *)

     

       536
       536
       +
           create_identity_command (Option.get create_identity) identity_name reply_to 

     

       537
       537
       +
                                    signature html_signature |> ignore

     

       538
       538
       +
         end

     

       539
       539
       +
         else if list_submissions then begin

     

       540
       540
       +
           (* Simulate listing submissions *)

     

       541
       541
       +
           Printf.printf "Recent submissions (last %d days):\n\n" days;

     

       542
       542
       +
           Printf.printf "sub1: [Final] Sent at 2023-01-15 10:30:45 (Email ID: email1, Recipients: 3)\n";

     

       543
       543
       +
           Printf.printf "sub2: [Final] Sent at 2023-01-14 08:15:22 (Email ID: email2, Recipients: 1)\n";

     

       544
       544
       +
           Printf.printf "sub3: [Pending] Sent at 2023-01-13 16:45:10 (Email ID: email3, Recipients: 5)\n"

     

       545
       545
       +
         end

     

       546
       546
       +
         else if show_submission <> None then begin

     

       547
       547
       +
           (* Simulate showing a specific submission *)

     

       548
       548
       +
           Printf.printf "Submission: %s\n" (Option.get show_submission);

     

       549
       549
       +
           Printf.printf "  Status:     Final\n";

     

       550
       550
       +
           Printf.printf "  Sent at:    2023-01-15 10:30:45\n";

     

       551
       551
       +
           Printf.printf "  Email ID:   email1\n";

     

       552
       552
       +
           Printf.printf "  Thread ID:  thread1\n";

     

       553
       553
       +
           Printf.printf "  Identity:   id1\n";

     

       554
       554
       +
           Printf.printf "  Envelope:\n";

     

       555
       555
       +
           Printf.printf "    From: john@example.com\n";

     

       556
       556
       +
           Printf.printf "    To:   alice@example.com, bob@example.com, carol@example.com\n";

     

       557
       557
       +
           Printf.printf "  Delivery Status:\n";

     

       558
       558
       +
           Printf.printf "    alice@example.com: Delivered, Displayed\n";

     

       559
       559
       +
           Printf.printf "      SMTP Reply: 250 OK\n";

     

       560
       560
       +
           Printf.printf "    bob@example.com: Delivered, Unknown if displayed\n";

     

       561
       561
       +
           Printf.printf "      SMTP Reply: 250 OK\n";

     

       562
       562
       +
           Printf.printf "    carol@example.com: Failed\n";

     

       563
       563
       +
           Printf.printf "      SMTP Reply: 550 Mailbox unavailable\n"

     

       564
       564
       +
         end

     

       565
       565
       +
         else if track_submission <> None then begin

     

       566
       566
       +
           (* Simulate tracking a submission *)

     

       567
       567
       +
           Printf.printf "Tracking delivery status for submission: %s\n\n" (Option.get track_submission);

     

       568
       568
       +
           Printf.printf "Submission %s: Final\n" (Option.get track_submission);

     

       569
       569
       +
           Printf.printf "  Total recipients: 3\n";

     

       570
       570
       +
           Printf.printf "  Delivered: 2\n";

     

       571
       571
       +
           Printf.printf "  Failed: 1\n";

     

       572
       572
       +
           Printf.printf "  Queued: 0\n"

     

       573
       573
       +
         end

     

       574
       574
       +
         else if cancel_submission <> None then begin

     

       575
       575
       +
           (* Simulate canceling a submission *)

     

       576
       576
       +
           Printf.printf "Canceling submission: %s\n" (Option.get cancel_submission);

     

       577
       577
       +
           Printf.printf "Submission has been canceled successfully.\n"

     

       578
       578
       +
         end

     

       579
       579
       +
         else 

     

       580
       580
       +
           (* No specific command given, show help *)

     

       581
       581
       +
           begin

     

       582
       582
       +
             Printf.printf "Please specify a command. Use --help for options.\n";

     

       583
       583
       +
             Printf.printf "Example commands:\n";

     

       584
       584
       +
             Printf.printf "  --list-identities      List all email identities\n";

     

       585
       585
       +
             Printf.printf "  --show-identity id1    Show details for identity 'id1'\n";

     

       586
       586
       +
             Printf.printf "  --list-submissions     List recent email submissions\n";

     

       587
       587
       +
             Printf.printf "  --track sub1           Track delivery status for submission 'sub1'\n"

     

       588
       588
       +
           end);

     

       589
       589
       +
         

     

       590
       590
       +
         (* Since we're only type checking, we'll exit with success *)

     

       591
       591
       +
         0

     

       592
       592
       +
       

     

       593
       593
       +
       (* Command definition *)

     

       594
       594
       +
       let identity_cmd =

     

       595
       595
       +
         let doc = "monitor email identities and submissions using JMAP" in

     

       596
       596
       +
         let man = [

     

       597
       597
       +
           `S Manpage.s_description;

     

       598
       598
       +
           `P "Provides identity management and email submission tracking functionality.";

     

       599
       599
       +
           `P "Demonstrates JMAP's identity and email submission monitoring capabilities.";

     

       600
       600
       +
           `S Manpage.s_examples;

     

       601
       601
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --list-identities";

     

       602
       602
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --create-identity backup@example.com --name \"Backup Account\"";

     

       603
       603
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --list-submissions --days 3";

     

       604
       604
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --track sub12345 --format status-only";

     

       605
       605
       +
         ] in

     

       606
       606
       +
         

     

       607
       607
       +
         let cmd =

     

       608
       608
       +
           Cmd.v

     

       609
       609
       +
             (Cmd.info "jmap-identity-monitor" ~version:"1.0" ~doc ~man)

     

       610
       610
       +
             Term.(const identity_command $ host_arg $ user_arg $ password_arg $ 

     

       611
       611
       +
                   list_identities_arg $ show_identity_arg $ create_identity_arg $ 

     

       612
       612
       +
                   identity_name_arg $ reply_to_arg $ signature_arg $ html_signature_arg $

     

       613
       613
       +
                   list_submissions_arg $ show_submission_arg $ track_submission_arg $

     

       614
       614
       +
                   pending_only_arg $ query_arg $ days_arg $ limit_arg $ 

     

       615
       615
       +
                   cancel_submission_arg $ format_arg)

     

       616
       616
       +
         in

     

       617
       617
       +
         cmd

     

       618
       618
       +
       

     

       619
       619
       +
       (* Main entry point *)

     

       620
       620
       +
       let () = exit (Cmd.eval' identity_cmd)

+420

bin/jmap_mailbox_explorer.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_mailbox_explorer.ml - A tool for exploring email mailboxes using JMAP

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's mailbox query and manipulation capabilities,

     

       5
       5
       +
        * allowing for exploring, creating, and analyzing mailboxes.

     

       6
       6
       +
        *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Cmdliner

     

       9
       9
       +
       (* Using standard OCaml, no Lwt *)

     

       10
       10
       +
       

     

       11
       11
       +
       (* JMAP imports *)

     

       12
       12
       +
       open Jmap

     

       13
       13
       +
       open Jmap.Types

     

       14
       14
       +
       open Jmap.Wire

     

       15
       15
       +
       open Jmap.Methods

     

       16
       16
       +
       open Jmap_email

     

       17
       17
       +
       (* For step 2, we're only testing type checking. No implementations required. *)

     

       18
       18
       +
       

     

       19
       19
       +
       (* JMAP mailbox handling *)

     

       20
       20
       +
       module Jmap_mailbox = struct

     

       21
       21
       +
         (* Dummy mailbox functions *)

     

       22
       22
       +
         let id mailbox = "mailbox-id"

     

       23
       23
       +
         let name mailbox = "mailbox-name"

     

       24
       24
       +
         let parent_id mailbox = None

     

       25
       25
       +
         let role mailbox = None

     

       26
       26
       +
         let total_emails mailbox = 0

     

       27
       27
       +
         let unread_emails mailbox = 0

     

       28
       28
       +
       end

     

       29
       29
       +
       

     

       30
       30
       +
       (* Unix implementation would be used here *)

     

       31
       31
       +
       module Unix = struct

     

       32
       32
       +
         let connect ~host ~username ~password ?auth_method () =

     

       33
       33
       +
           failwith "Not implemented"

     

       34
       34
       +
       end

     

       35
       35
       +
       

     

       36
       36
       +
       (** Types for mailbox explorer *)

     

       37
       37
       +
       type mailbox_stats = {

     

       38
       38
       +
         time_periods : (string * int) list;

     

       39
       39
       +
         senders : (string * int) list;

     

       40
       40
       +
         subjects : (string * int) list;

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       type mailbox_explorer_args = {

     

       44
       44
       +
         list : bool;

     

       45
       45
       +
         stats : bool;

     

       46
       46
       +
         mailbox : string option;

     

       47
       47
       +
         create : string option;

     

       48
       48
       +
         parent : string option;

     

       49
       49
       +
         query_mailbox : string option;

     

       50
       50
       +
         days : int;

     

       51
       51
       +
         format : [`Tree | `Flat | `Json];

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       (** Command-line arguments **)

     

       55
       55
       +
       

     

       56
       56
       +
       let host_arg =

     

       57
       57
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       58
       58
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       59
       59
       +
       

     

       60
       60
       +
       let user_arg =

     

       61
       61
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       62
       62
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       63
       63
       +
       

     

       64
       64
       +
       let password_arg =

     

       65
       65
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       66
       66
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       67
       67
       +
       

     

       68
       68
       +
       let list_arg =

     

       69
       69
       +
         Arg.(value & flag & info ["l"; "list"] ~doc:"List all mailboxes")

     

       70
       70
       +
       

     

       71
       71
       +
       let stats_arg =

     

       72
       72
       +
         Arg.(value & flag & info ["s"; "stats"] ~doc:"Show mailbox statistics")

     

       73
       73
       +
       

     

       74
       74
       +
       let mailbox_arg =

     

       75
       75
       +
         Arg.(value & opt (some string) None & info ["m"; "mailbox"] 

     

       76
       76
       +
              ~docv:"MAILBOX" ~doc:"Filter by mailbox name")

     

       77
       77
       +
       

     

       78
       78
       +
       let create_arg =

     

       79
       79
       +
         Arg.(value & opt (some string) None & info ["create"] 

     

       80
       80
       +
              ~docv:"NAME" ~doc:"Create a new mailbox")

     

       81
       81
       +
       

     

       82
       82
       +
       let parent_arg =

     

       83
       83
       +
         Arg.(value & opt (some string) None & info ["parent"] 

     

       84
       84
       +
              ~docv:"PARENT" ~doc:"Parent mailbox for creation")

     

       85
       85
       +
       

     

       86
       86
       +
       let query_mailbox_arg =

     

       87
       87
       +
         Arg.(value & opt (some string) None & info ["query"] 

     

       88
       88
       +
              ~docv:"QUERY" ~doc:"Query emails in the specified mailbox")

     

       89
       89
       +
       

     

       90
       90
       +
       let days_arg =

     

       91
       91
       +
         Arg.(value & opt int 7 & info ["days"] 

     

       92
       92
       +
              ~docv:"DAYS" ~doc:"Days to analyze for mailbox statistics")

     

       93
       93
       +
       

     

       94
       94
       +
       let format_arg =

     

       95
       95
       +
         Arg.(value & opt (enum [

     

       96
       96
       +
           "tree", `Tree;

     

       97
       97
       +
           "flat", `Flat;

     

       98
       98
       +
           "json", `Json;

     

       99
       99
       +
         ]) `Tree & info ["format"] ~docv:"FORMAT" ~doc:"Output format")

     

       100
       100
       +
       

     

       101
       101
       +
       (** Mailbox Explorer Functionality **)

     

       102
       102
       +
       

     

       103
       103
       +
       (* Get standard role name for display *)

     

       104
       104
       +
       let role_name = function

     

       105
       105
       +
         | `Inbox -> "Inbox"

     

       106
       106
       +
         | `Archive -> "Archive"

     

       107
       107
       +
         | `Drafts -> "Drafts"

     

       108
       108
       +
         | `Sent -> "Sent"

     

       109
       109
       +
         | `Trash -> "Trash"

     

       110
       110
       +
         | `Junk -> "Junk"

     

       111
       111
       +
         | `Important -> "Important"

     

       112
       112
       +
         | `Flagged -> "Flagged"

     

       113
       113
       +
         | `Snoozed -> "Snoozed"

     

       114
       114
       +
         | `Scheduled -> "Scheduled"

     

       115
       115
       +
         | `Memos -> "Memos"

     

       116
       116
       +
         | `Other name -> name

     

       117
       117
       +
         | `None -> "(No role)"

     

       118
       118
       +
       

     

       119
       119
       +
       (* Display mailboxes in tree format *)

     

       120
       120
       +
       let display_mailbox_tree mailboxes format stats =

     

       121
       121
       +
         (* Helper to find children of a parent *)

     

       122
       122
       +
         let find_children parent_id =

     

       123
       123
       +
           mailboxes |> List.filter (fun mailbox ->

     

       124
       124
       +
             match Jmap_mailbox.parent_id mailbox with

     

       125
       125
       +
             | Some id when id = parent_id -> true

     

       126
       126
       +
             | _ -> false

     

       127
       127
       +
           )

     

       128
       128
       +
         in

     

       129
       129
       +
         

     

       130
       130
       +
         (* Helper to find mailboxes without a parent (root level) *)

     

       131
       131
       +
         let find_roots () =

     

       132
       132
       +
           mailboxes |> List.filter (fun mailbox ->

     

       133
       133
       +
             Jmap_mailbox.parent_id mailbox = None

     

       134
       134
       +
           )

     

       135
       135
       +
         in

     

       136
       136
       +
         

     

       137
       137
       +
         (* Get mailbox name with role *)

     

       138
       138
       +
         let mailbox_name_with_role mailbox =

     

       139
       139
       +
           let name = Jmap_mailbox.name mailbox in

     

       140
       140
       +
           match Jmap_mailbox.role mailbox with

     

       141
       141
       +
           | Some role -> Printf.sprintf "%s (%s)" name (role_name role)

     

       142
       142
       +
           | None -> name

     

       143
       143
       +
         in

     

       144
       144
       +
         

     

       145
       145
       +
         (* Helper to get statistics for a mailbox *)

     

       146
       146
       +
         let get_stats mailbox =

     

       147
       147
       +
           let id = Jmap_mailbox.id mailbox in

     

       148
       148
       +
           let total = Jmap_mailbox.total_emails mailbox in

     

       149
       149
       +
           let unread = Jmap_mailbox.unread_emails mailbox in

     

       150
       150
       +
           

     

       151
       151
       +
           match Hashtbl.find_opt stats id with

     

       152
       152
       +
           | Some mailbox_stats -> 

     

       153
       153
       +
               let recent = match List.assoc_opt "Last week" mailbox_stats.time_periods with

     

       154
       154
       +
                 | Some count -> count

     

       155
       155
       +
                 | None -> 0

     

       156
       156
       +
               in

     

       157
       157
       +
               (total, unread, recent)

     

       158
       158
       +
           | None -> (total, unread, 0)

     

       159
       159
       +
         in

     

       160
       160
       +
         

     

       161
       161
       +
         (* Helper to print a JSON representation *)

     

       162
       162
       +
         let print_json_mailbox mailbox indent =

     

       163
       163
       +
           let id = Jmap_mailbox.id mailbox in

     

       164
       164
       +
           let name = Jmap_mailbox.name mailbox in

     

       165
       165
       +
           let role = match Jmap_mailbox.role mailbox with

     

       166
       166
       +
             | Some role -> Printf.sprintf "\"%s\"" (role_name role)

     

       167
       167
       +
             | None -> "null"

     

       168
       168
       +
           in

     

       169
       169
       +
           let total, unread, recent = get_stats mailbox in

     

       170
       170
       +
           

     

       171
       171
       +
           let indent_str = String.make indent ' ' in

     

       172
       172
       +
           Printf.printf "%s{\n" indent_str;

     

       173
       173
       +
           Printf.printf "%s  \"id\": \"%s\",\n" indent_str id;

     

       174
       174
       +
           Printf.printf "%s  \"name\": \"%s\",\n" indent_str name;

     

       175
       175
       +
           Printf.printf "%s  \"role\": %s,\n" indent_str role;

     

       176
       176
       +
           Printf.printf "%s  \"totalEmails\": %d,\n" indent_str total;

     

       177
       177
       +
           Printf.printf "%s  \"unreadEmails\": %d,\n" indent_str unread;

     

       178
       178
       +
           Printf.printf "%s  \"recentEmails\": %d\n" indent_str recent;

     

       179
       179
       +
           Printf.printf "%s}" indent_str

     

       180
       180
       +
         in

     

       181
       181
       +
         

     

       182
       182
       +
         (* Recursive function to print a tree of mailboxes *)

     

       183
       183
       +
         let rec print_tree_level mailboxes level =

     

       184
       184
       +
           mailboxes |> List.iteri (fun i mailbox ->

     

       185
       185
       +
             let id = Jmap_mailbox.id mailbox in

     

       186
       186
       +
             let name = mailbox_name_with_role mailbox in

     

       187
       187
       +
             let total, unread, recent = get_stats mailbox in

     

       188
       188
       +
             

     

       189
       189
       +
             let indent = String.make (level * 2) ' ' in

     

       190
       190
       +
             let is_last = i = List.length mailboxes - 1 in

     

       191
       191
       +
             let prefix = if level = 0 then "" else

     

       192
       192
       +
                          if is_last then "└── " else "├── " in

     

       193
       193
       +
             

     

       194
       194
       +
             match format with

     

       195
       195
       +
             | `Tree ->

     

       196
       196
       +
                 Printf.printf "%s%s%s" indent prefix name;

     

       197
       197
       +
                 if stats <> Hashtbl.create 0 then

     

       198
       198
       +
                   Printf.printf " (%d emails, %d unread, %d recent)" total unread recent;

     

       199
       199
       +
                 Printf.printf "\n";

     

       200
       200
       +
                 

     

       201
       201
       +
                 (* Print children *)

     

       202
       202
       +
                 let children = find_children id in

     

       203
       203
       +
                 let child_indent = level + 1 in

     

       204
       204
       +
                 print_tree_level children child_indent

     

       205
       205
       +
                 

     

       206
       206
       +
             | `Flat ->

     

       207
       207
       +
                 Printf.printf "%s [%s]\n" name id;

     

       208
       208
       +
                 if stats <> Hashtbl.create 0 then

     

       209
       209
       +
                   Printf.printf "  Emails: %d total, %d unread, %d in last week\n" 

     

       210
       210
       +
                     total unread recent;

     

       211
       211
       +
                 

     

       212
       212
       +
                 (* Print children *)

     

       213
       213
       +
                 let children = find_children id in

     

       214
       214
       +
                 print_tree_level children 0

     

       215
       215
       +
                 

     

       216
       216
       +
             | `Json ->

     

       217
       217
       +
                 print_json_mailbox mailbox (level * 2);

     

       218
       218
       +
                 

     

       219
       219
       +
                 (* Handle commas between mailboxes *)

     

       220
       220
       +
                 let children = find_children id in

     

       221
       221
       +
                 if children <> [] || (not is_last) then Printf.printf ",\n" else Printf.printf "\n";

     

       222
       222
       +
                 

     

       223
       223
       +
                 (* Print children as a "children" array *)

     

       224
       224
       +
                 if children <> [] then begin

     

       225
       225
       +
                   Printf.printf "%s\"children\": [\n" (String.make ((level * 2) + 2) ' ');

     

       226
       226
       +
                   print_tree_level children (level + 2);

     

       227
       227
       +
                   Printf.printf "%s]\n" (String.make ((level * 2) + 2) ' ');

     

       228
       228
       +
                   

     

       229
       229
       +
                   (* Add comma if not the last mailbox *)

     

       230
       230
       +
                   if not is_last then Printf.printf "%s,\n" (String.make (level * 2) ' ');

     

       231
       231
       +
                 end

     

       232
       232
       +
           )

     

       233
       233
       +
         in

     

       234
       234
       +
         

     

       235
       235
       +
         (* Print the mailbox tree *)

     

       236
       236
       +
         match format with

     

       237
       237
       +
         | `Tree | `Flat ->

     

       238
       238
       +
             Printf.printf "Mailboxes:\n";

     

       239
       239
       +
             print_tree_level (find_roots()) 0

     

       240
       240
       +
         | `Json ->

     

       241
       241
       +
             Printf.printf "{\n";

     

       242
       242
       +
             Printf.printf "  \"mailboxes\": [\n";

     

       243
       243
       +
             print_tree_level (find_roots()) 1;

     

       244
       244
       +
             Printf.printf "  ]\n";

     

       245
       245
       +
             Printf.printf "}\n"

     

       246
       246
       +
       

     

       247
       247
       +
       (* Command implementation *)

     

       248
       248
       +
       let mailbox_command host user password list stats mailbox create parent 

     

       249
       249
       +
                            query_mailbox days format : int =

     

       250
       250
       +
         (* Pack arguments into a record for easier passing *)

     

       251
       251
       +
         let args : mailbox_explorer_args = {

     

       252
       252
       +
           list; stats; mailbox; create; parent; 

     

       253
       253
       +
           query_mailbox; days; format

     

       254
       254
       +
         } in

     

       255
       255
       +
         

     

       256
       256
       +
         (* Main workflow would be implemented here using the JMAP library *)

     

       257
       257
       +
         Printf.printf "JMAP Mailbox Explorer\n";

     

       258
       258
       +
         Printf.printf "Server: %s\n" host;

     

       259
       259
       +
         Printf.printf "User: %s\n\n" user;

     

       260
       260
       +
         

     

       261
       261
       +
         (* This is where the actual JMAP calls would happen, like:

     

       262
       262
       +
         

     

       263
       263
       +
         let explore_mailboxes () =

     

       264
       264
       +
           let* (ctx, session) = Jmap.Unix.connect 

     

       265
       265
       +
             ~host ~username:user ~password 

     

       266
       266
       +
             ~auth_method:(Jmap.Unix.Basic(user, password)) () in

     

       267
       267
       +
           

     

       268
       268
       +
           (* Get primary account ID *)

     

       269
       269
       +
           let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       270
       270
       +
             | Ok id -> id

     

       271
       271
       +
             | Error _ -> failwith "No mail account found"

     

       272
       272
       +
           in

     

       273
       273
       +
           

     

       274
       274
       +
           (* Create a new mailbox if requested *)

     

       275
       275
       +
           if args.create <> None then

     

       276
       276
       +
             let name = Option.get args.create in

     

       277
       277
       +
             let parent_id_opt = match args.parent with

     

       278
       278
       +
               | None -> None

     

       279
       279
       +
               | Some parent_name ->

     

       280
       280
       +
                   (* Resolve parent name to ID - would need to search for it *)

     

       281
       281
       +
                   None (* This would actually find or return an error *)

     

       282
       282
       +
             in

     

       283
       283
       +
             

     

       284
       284
       +
             let create_mailbox = Jmap_mailbox.create 

     

       285
       285
       +
               ~name

     

       286
       286
       +
               ?parent_id:parent_id_opt

     

       287
       287
       +
               () in

     

       288
       288
       +
             

     

       289
       289
       +
             let* result = Jmap_mailbox.set ctx

     

       290
       290
       +
               ~account_id

     

       291
       291
       +
               ~create:(Hashtbl.of_seq (Seq.return ("new", create_mailbox)))

     

       292
       292
       +
               () in

     

       293
       293
       +
             

     

       294
       294
       +
             (* Handle mailbox creation result *)

     

       295
       295
       +
             ...

     

       296
       296
       +
           

     

       297
       297
       +
           (* List mailboxes *)

     

       298
       298
       +
           if args.list || args.stats then

     

       299
       299
       +
             (* Query mailboxes *)

     

       300
       300
       +
             let filter = 

     

       301
       301
       +
               if args.mailbox <> None then

     

       302
       302
       +
                 Jmap_mailbox.filter_name_contains (Option.get args.mailbox)

     

       303
       303
       +
               else

     

       304
       304
       +
                 Jmap_mailbox.Filter.condition (`Assoc [])

     

       305
       305
       +
             in

     

       306
       306
       +
             

     

       307
       307
       +
             let* mailbox_ids = Jmap_mailbox.query ctx

     

       308
       308
       +
               ~account_id

     

       309
       309
       +
               ~filter

     

       310
       310
       +
               ~sort:[Jmap_mailbox.sort_by_name () ]

     

       311
       311
       +
               () in

     

       312
       312
       +
             

     

       313
       313
       +
             match mailbox_ids with

     

       314
       314
       +
             | Error err -> 

     

       315
       315
       +
                 Printf.eprintf "Error querying mailboxes: %s\n" (Jmap.Error.error_to_string err);

     

       316
       316
       +
                 Lwt.return_unit

     

       317
       317
       +
             | Ok (ids, _) ->

     

       318
       318
       +
                 (* Get full mailbox objects *)

     

       319
       319
       +
                 let* mailboxes = Jmap_mailbox.get ctx

     

       320
       320
       +
                   ~account_id

     

       321
       321
       +
                   ~ids

     

       322
       322
       +
                   ~properties:["id"; "name"; "parentId"; "role"; "totalEmails"; "unreadEmails"] in

     

       323
       323
       +
                 

     

       324
       324
       +
                 match mailboxes with

     

       325
       325
       +
                 | Error err ->

     

       326
       326
       +
                     Printf.eprintf "Error getting mailboxes: %s\n" (Jmap.Error.error_to_string err);

     

       327
       327
       +
                     Lwt.return_unit

     

       328
       328
       +
                 | Ok (_, mailbox_list) ->

     

       329
       329
       +
                     (* If stats requested, gather email stats for each mailbox *)

     

       330
       330
       +
                     let* stats_opt = 

     

       331
       331
       +
                       if args.stats then

     

       332
       332
       +
                         (* For each mailbox, gather stats like weekly counts *)

     

       333
       333
       +
                         ...

     

       334
       334
       +
                       else

     

       335
       335
       +
                         Lwt.return (Hashtbl.create 0)

     

       336
       336
       +
                     in

     

       337
       337
       +
                     

     

       338
       338
       +
                     (* Display mailboxes in requested format *)

     

       339
       339
       +
                     display_mailbox_tree mailbox_list args.format stats_opt;

     

       340
       340
       +
                     Lwt.return_unit

     

       341
       341
       +
           

     

       342
       342
       +
           (* Query emails in a specific mailbox *)

     

       343
       343
       +
           if args.query_mailbox <> None then

     

       344
       344
       +
             let mailbox_name = Option.get args.query_mailbox in

     

       345
       345
       +
             

     

       346
       346
       +
             (* Find mailbox ID from name *)

     

       347
       347
       +
             ...

     

       348
       348
       +
             

     

       349
       349
       +
             (* Query emails in that mailbox *)

     

       350
       350
       +
             ...

     

       351
       351
       +
         *)

     

       352
       352
       +
         

     

       353
       353
       +
         if create <> None then

     

       354
       354
       +
           Printf.printf "Creating mailbox: %s\n" (Option.get create);

     

       355
       355
       +
         

     

       356
       356
       +
         if list || stats then

     

       357
       357
       +
           Printf.printf "Listing mailboxes%s:\n" 

     

       358
       358
       +
             (if stats then " with statistics" else "");

     

       359
       359
       +
         

     

       360
       360
       +
         (* Example output for a tree of mailboxes *)

     

       361
       361
       +
         (match format with

     

       362
       362
       +
         | `Tree -> 

     

       363
       363
       +
             Printf.printf "Mailboxes:\n";

     

       364
       364
       +
             Printf.printf "Inbox (14 emails, 3 unread, 5 recent)\n";

     

       365
       365
       +
             Printf.printf "├── Work (8 emails, 2 unread, 3 recent)\n";

     

       366
       366
       +
             Printf.printf "│   └── Project A (3 emails, 1 unread, 2 recent)\n";

     

       367
       367
       +
             Printf.printf "└── Personal (6 emails, 1 unread, 2 recent)\n"

     

       368
       368
       +
         | `Flat ->

     

       369
       369
       +
             Printf.printf "Inbox [mbox1]\n";

     

       370
       370
       +
             Printf.printf "  Emails: 14 total, 3 unread, 5 in last week\n";

     

       371
       371
       +
             Printf.printf "Work [mbox2]\n";

     

       372
       372
       +
             Printf.printf "  Emails: 8 total, 2 unread, 3 in last week\n";

     

       373
       373
       +
             Printf.printf "Project A [mbox3]\n";

     

       374
       374
       +
             Printf.printf "  Emails: 3 total, 1 unread, 2 in last week\n";

     

       375
       375
       +
             Printf.printf "Personal [mbox4]\n";

     

       376
       376
       +
             Printf.printf "  Emails: 6 total, 1 unread, 2 in last week\n"

     

       377
       377
       +
         | `Json ->

     

       378
       378
       +
             Printf.printf "{\n";

     

       379
       379
       +
             Printf.printf "  \"mailboxes\": [\n";

     

       380
       380
       +
             Printf.printf "    {\n";

     

       381
       381
       +
             Printf.printf "      \"id\": \"mbox1\",\n";

     

       382
       382
       +
             Printf.printf "      \"name\": \"Inbox\",\n";

     

       383
       383
       +
             Printf.printf "      \"role\": \"Inbox\",\n";

     

       384
       384
       +
             Printf.printf "      \"totalEmails\": 14,\n";

     

       385
       385
       +
             Printf.printf "      \"unreadEmails\": 3,\n";

     

       386
       386
       +
             Printf.printf "      \"recentEmails\": 5\n";

     

       387
       387
       +
             Printf.printf "    }\n";

     

       388
       388
       +
             Printf.printf "  ]\n";

     

       389
       389
       +
             Printf.printf "}\n");

     

       390
       390
       +
         

     

       391
       391
       +
         if query_mailbox <> None then

     

       392
       392
       +
           Printf.printf "\nQuerying emails in mailbox: %s\n" (Option.get query_mailbox);

     

       393
       393
       +
         

     

       394
       394
       +
         (* Since we're only type checking, we'll exit with success *)

     

       395
       395
       +
         0

     

       396
       396
       +
       

     

       397
       397
       +
       (* Command definition *)

     

       398
       398
       +
       let mailbox_cmd =

     

       399
       399
       +
         let doc = "explore and manage mailboxes using JMAP" in

     

       400
       400
       +
         let man = [

     

       401
       401
       +
           `S Manpage.s_description;

     

       402
       402
       +
           `P "Lists, creates, and analyzes email mailboxes using JMAP.";

     

       403
       403
       +
           `P "Demonstrates JMAP's mailbox query and management capabilities.";

     

       404
       404
       +
           `S Manpage.s_examples;

     

       405
       405
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --list";

     

       406
       406
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --stats --mailbox Inbox";

     

       407
       407
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --create \"Work/Project X\" --parent Work";

     

       408
       408
       +
         ] in

     

       409
       409
       +
         

     

       410
       410
       +
         let cmd = 

     

       411
       411
       +
           Cmd.v 

     

       412
       412
       +
             (Cmd.info "jmap-mailbox-explorer" ~version:"1.0" ~doc ~man)

     

       413
       413
       +
             Term.(const mailbox_command $ host_arg $ user_arg $ password_arg $ 

     

       414
       414
       +
                    list_arg $ stats_arg $ mailbox_arg $ create_arg $ 

     

       415
       415
       +
                    parent_arg $ query_mailbox_arg $ days_arg $ format_arg)

     

       416
       416
       +
         in

     

       417
       417
       +
         cmd

     

       418
       418
       +
       

     

       419
       419
       +
       (* Main entry point *)

     

       420
       420
       +
       let () = exit (Cmd.eval' mailbox_cmd)

+238

bin/jmap_push_listener.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_push_listener.ml - Monitor real-time changes via JMAP push notifications

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's push notification capabilities for monitoring

     

       5
       5
       +
        * changes to emails, mailboxes, and other data in real-time.

     

       6
       6
       +
        *

     

       7
       7
       +
        * For step 2, we're only testing type checking. No implementations required.

     

       8
       8
       +
        *)

     

       9
       9
       +
       

     

       10
       10
       +
       open Cmdliner

     

       11
       11
       +
       

     

       12
       12
       +
       (** Push notification types to monitor **)

     

       13
       13
       +
       type monitor_types = {

     

       14
       14
       +
         emails : bool;

     

       15
       15
       +
         mailboxes : bool;

     

       16
       16
       +
         threads : bool;

     

       17
       17
       +
         identities : bool;

     

       18
       18
       +
         submissions : bool;

     

       19
       19
       +
         all : bool;

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       (** Command-line arguments **)

     

       23
       23
       +
       

     

       24
       24
       +
       let host_arg =

     

       25
       25
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       26
       26
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       27
       27
       +
       

     

       28
       28
       +
       let user_arg =

     

       29
       29
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       30
       30
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       31
       31
       +
       

     

       32
       32
       +
       let password_arg =

     

       33
       33
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       34
       34
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       35
       35
       +
       

     

       36
       36
       +
       let monitor_emails_arg =

     

       37
       37
       +
         Arg.(value & flag & info ["emails"] 

     

       38
       38
       +
              ~doc:"Monitor email changes")

     

       39
       39
       +
       

     

       40
       40
       +
       let monitor_mailboxes_arg =

     

       41
       41
       +
         Arg.(value & flag & info ["mailboxes"] 

     

       42
       42
       +
              ~doc:"Monitor mailbox changes")

     

       43
       43
       +
       

     

       44
       44
       +
       let monitor_threads_arg =

     

       45
       45
       +
         Arg.(value & flag & info ["threads"] 

     

       46
       46
       +
              ~doc:"Monitor thread changes")

     

       47
       47
       +
       

     

       48
       48
       +
       let monitor_identities_arg =

     

       49
       49
       +
         Arg.(value & flag & info ["identities"] 

     

       50
       50
       +
              ~doc:"Monitor identity changes")

     

       51
       51
       +
       

     

       52
       52
       +
       let monitor_submissions_arg =

     

       53
       53
       +
         Arg.(value & flag & info ["submissions"] 

     

       54
       54
       +
              ~doc:"Monitor email submission changes")

     

       55
       55
       +
       

     

       56
       56
       +
       let monitor_all_arg =

     

       57
       57
       +
         Arg.(value & flag & info ["all"] 

     

       58
       58
       +
              ~doc:"Monitor all supported types")

     

       59
       59
       +
       

     

       60
       60
       +
       let verbose_arg =

     

       61
       61
       +
         Arg.(value & flag & info ["v"; "verbose"] 

     

       62
       62
       +
              ~doc:"Show detailed information about changes")

     

       63
       63
       +
       

     

       64
       64
       +
       let timeout_arg =

     

       65
       65
       +
         Arg.(value & opt int 300 & info ["t"; "timeout"] 

     

       66
       66
       +
              ~docv:"SECONDS" ~doc:"Timeout for push connections (default: 300)")

     

       67
       67
       +
       

     

       68
       68
       +
       (** Helper functions **)

     

       69
       69
       +
       

     

       70
       70
       +
       (* Format timestamp *)

     

       71
       71
       +
       let format_timestamp () =

     

       72
       72
       +
         let time = Unix.gettimeofday () in

     

       73
       73
       +
         let tm = Unix.localtime time in

     

       74
       74
       +
         Printf.sprintf "%04d-%02d-%02d %02d:%02d:%02d"

     

       75
       75
       +
           (tm.Unix.tm_year + 1900) (tm.Unix.tm_mon + 1) tm.Unix.tm_mday

     

       76
       76
       +
           tm.Unix.tm_hour tm.Unix.tm_min tm.Unix.tm_sec

     

       77
       77
       +
       

     

       78
       78
       +
       (* Print change notification *)

     

       79
       79
       +
       let print_change data_type change_type details verbose =

     

       80
       80
       +
         let timestamp = format_timestamp () in

     

       81
       81
       +
         Printf.printf "[%s] %s %s" timestamp data_type change_type;

     

       82
       82
       +
         if verbose && details <> "" then

     

       83
       83
       +
           Printf.printf ": %s" details;

     

       84
       84
       +
         Printf.printf "\n";

     

       85
       85
       +
         flush stdout

     

       86
       86
       +
       

     

       87
       87
       +
       (* Monitor using polling simulation *)

     

       88
       88
       +
       let monitor_changes _ctx _session _account_id monitor verbose timeout =

     

       89
       89
       +
         Printf.printf "Starting change monitoring (simulated)...\n\n";

     

       90
       90
       +
         

     

       91
       91
       +
         (* Types to monitor *)

     

       92
       92
       +
         let types = ref [] in

     

       93
       93
       +
         if monitor.emails || monitor.all then types := "Email" :: !types;

     

       94
       94
       +
         if monitor.mailboxes || monitor.all then types := "Mailbox" :: !types;

     

       95
       95
       +
         if monitor.threads || monitor.all then types := "Thread" :: !types;

     

       96
       96
       +
         if monitor.identities || monitor.all then types := "Identity" :: !types;

     

       97
       97
       +
         if monitor.submissions || monitor.all then types := "EmailSubmission" :: !types;

     

       98
       98
       +
         

     

       99
       99
       +
         Printf.printf "Monitoring: %s\n\n" (String.concat ", " !types);

     

       100
       100
       +
         

     

       101
       101
       +
         (* In a real implementation, we would:

     

       102
       102
       +
            1. Use EventSource or long polling

     

       103
       103
       +
            2. Track state changes per type

     

       104
       104
       +
            3. Fetch and display actual changes

     

       105
       105
       +
            

     

       106
       106
       +
            For this demo, we'll simulate monitoring *)

     

       107
       107
       +
         

     

       108
       108
       +
         let rec monitor_loop count =

     

       109
       109
       +
           (* Make a simple echo request to stay connected *)

     

       110
       110
       +
           let invocation = Jmap.Wire.Invocation.v

     

       111
       111
       +
             ~method_name:"Core/echo"

     

       112
       112
       +
             ~arguments:(`Assoc ["ping", `String "keepalive"]) 

     

       113
       113
       +
             ~method_call_id:"echo1"

     

       114
       114
       +
             () in

     

       115
       115
       +
             

     

       116
       116
       +
           let request = Jmap.Wire.Request.v

     

       117
       117
       +
             ~using:[Jmap.capability_core; Jmap_email.capability_mail]

     

       118
       118
       +
             ~method_calls:[invocation]

     

       119
       119
       +
             () in

     

       120
       120
       +
             

     

       121
       121
       +
           match Jmap_unix.request _ctx request with

     

       122
       122
       +
           | Ok _ ->

     

       123
       123
       +
               (* Simulate random changes for demonstration *)

     

       124
       124
       +
               if count mod 3 = 0 && !types <> [] then (

     

       125
       125
       +
                 let changed_type = List.nth !types (Random.int (List.length !types)) in

     

       126
       126
       +
                 let change_details = match changed_type with

     

       127
       127
       +
                   | "Email" -> "2 new, 1 updated"

     

       128
       128
       +
                   | "Mailbox" -> "1 updated (Inbox)"

     

       129
       129
       +
                   | "Thread" -> "3 updated"

     

       130
       130
       +
                   | "Identity" -> "settings changed"

     

       131
       131
       +
                   | "EmailSubmission" -> "1 sent"

     

       132
       132
       +
                   | _ -> "changed"

     

       133
       133
       +
                 in

     

       134
       134
       +
                 print_change changed_type "changed" change_details verbose

     

       135
       135
       +
               );

     

       136
       136
       +
               

     

       137
       137
       +
               (* Wait before next check *)

     

       138
       138
       +
               Unix.sleep 5;

     

       139
       139
       +
               

     

       140
       140
       +
               if count < timeout / 5 then

     

       141
       141
       +
                 monitor_loop (count + 1)

     

       142
       142
       +
               else (

     

       143
       143
       +
                 Printf.printf "\nMonitoring timeout reached.\n";

     

       144
       144
       +
                 0

     

       145
       145
       +
               )

     

       146
       146
       +
           | Error e ->

     

       147
       147
       +
               Printf.eprintf "Connection error: %s\n" (Jmap.Error.error_to_string e);

     

       148
       148
       +
               1

     

       149
       149
       +
         in

     

       150
       150
       +
         

     

       151
       151
       +
         monitor_loop 0

     

       152
       152
       +
       

     

       153
       153
       +
       (* Command implementation *)

     

       154
       154
       +
       let listen_command host user password emails mailboxes threads identities 

     

       155
       155
       +
                          submissions all verbose timeout : int =

     

       156
       156
       +
         Printf.printf "JMAP Push Listener\n";

     

       157
       157
       +
         Printf.printf "Server: %s\n" host;

     

       158
       158
       +
         Printf.printf "User: %s\n\n" user;

     

       159
       159
       +
         

     

       160
       160
       +
         (* Build monitor options *)

     

       161
       161
       +
         let monitor = {

     

       162
       162
       +
           emails;

     

       163
       163
       +
           mailboxes;

     

       164
       164
       +
           threads;

     

       165
       165
       +
           identities;

     

       166
       166
       +
           submissions;

     

       167
       167
       +
           all;

     

       168
       168
       +
         } in

     

       169
       169
       +
         

     

       170
       170
       +
         (* Check that at least one type is selected *)

     

       171
       171
       +
         if not (emails || mailboxes || threads || identities || submissions || all) then (

     

       172
       172
       +
           Printf.eprintf "Error: Must specify at least one type to monitor (or --all)\n";

     

       173
       173
       +
           exit 1

     

       174
       174
       +
         );

     

       175
       175
       +
         

     

       176
       176
       +
         (* Initialize random for simulation *)

     

       177
       177
       +
         Random.self_init ();

     

       178
       178
       +
         

     

       179
       179
       +
         (* Connect to server *)

     

       180
       180
       +
         let ctx = Jmap_unix.create_client () in

     

       181
       181
       +
         let result = Jmap_unix.quick_connect ~host ~username:user ~password in

     

       182
       182
       +
         

     

       183
       183
       +
         let (ctx, session) = match result with

     

       184
       184
       +
           | Ok (ctx, session) -> (ctx, session)

     

       185
       185
       +
           | Error e -> 

     

       186
       186
       +
               Printf.eprintf "Connection failed: %s\n" (Jmap.Error.error_to_string e);

     

       187
       187
       +
               exit 1

     

       188
       188
       +
         in

     

       189
       189
       +
         

     

       190
       190
       +
         (* Get the primary account ID *)

     

       191
       191
       +
         let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       192
       192
       +
           | Ok id -> id

     

       193
       193
       +
           | Error e -> 

     

       194
       194
       +
               Printf.eprintf "No mail account found: %s\n" (Jmap.Error.error_to_string e);

     

       195
       195
       +
               exit 1

     

       196
       196
       +
         in

     

       197
       197
       +
         

     

       198
       198
       +
         (* Check EventSource URL availability *)

     

       199
       199
       +
         let event_source_url = Jmap.Session.Session.event_source_url session in

     

       200
       200
       +
         if Uri.to_string event_source_url <> "" then

     

       201
       201
       +
           Printf.printf "Note: Server supports EventSource at: %s\n\n" (Uri.to_string event_source_url)

     

       202
       202
       +
         else

     

       203
       203
       +
           Printf.printf "Note: Server doesn't advertise EventSource support\n\n";

     

       204
       204
       +
         

     

       205
       205
       +
         (* Monitor for changes *)

     

       206
       206
       +
         monitor_changes ctx session account_id monitor verbose timeout

     

       207
       207
       +
       

     

       208
       208
       +
       (* Command definition *)

     

       209
       209
       +
       let listen_cmd =

     

       210
       210
       +
         let doc = "monitor real-time changes via JMAP push notifications" in

     

       211
       211
       +
         let man = [

     

       212
       212
       +
           `S Manpage.s_description;

     

       213
       213
       +
           `P "Monitor real-time changes to JMAP data using push notifications.";

     

       214
       214
       +
           `P "Supports both EventSource and long-polling methods.";

     

       215
       215
       +
           `P "Shows when emails, mailboxes, threads, and other data change.";

     

       216
       216
       +
           `S Manpage.s_examples;

     

       217
       217
       +
           `P "Monitor all changes:";

     

       218
       218
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --all";

     

       219
       219
       +
           `P "";

     

       220
       220
       +
           `P "Monitor only emails and mailboxes with details:";

     

       221
       221
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --emails --mailboxes -v";

     

       222
       222
       +
           `P "";

     

       223
       223
       +
           `P "Monitor with custom timeout:";

     

       224
       224
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --all -t 600";

     

       225
       225
       +
         ] in

     

       226
       226
       +
         

     

       227
       227
       +
         let cmd =

     

       228
       228
       +
           Cmd.v

     

       229
       229
       +
             (Cmd.info "jmap-push-listener" ~version:"1.0" ~doc ~man)

     

       230
       230
       +
             Term.(const listen_command $ host_arg $ user_arg $ password_arg $ 

     

       231
       231
       +
                   monitor_emails_arg $ monitor_mailboxes_arg $ monitor_threads_arg $

     

       232
       232
       +
                   monitor_identities_arg $ monitor_submissions_arg $ monitor_all_arg $

     

       233
       233
       +
                   verbose_arg $ timeout_arg)

     

       234
       234
       +
         in

     

       235
       235
       +
         cmd

     

       236
       236
       +
       

     

       237
       237
       +
       (* Main entry point *)

     

       238
       238
       +
       let () = exit (Cmd.eval' listen_cmd)

+533

bin/jmap_thread_analyzer.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_thread_analyzer.ml - A tool for analyzing email threads using JMAP

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates the thread-related capabilities of JMAP,

     

       5
       5
       +
        * allowing visualization and analysis of conversation threads.

     

       6
       6
       +
        *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Cmdliner

     

       9
       9
       +
       (* Using standard OCaml, no Lwt *)

     

       10
       10
       +
       

     

       11
       11
       +
       (* JMAP imports *)

     

       12
       12
       +
       open Jmap

     

       13
       13
       +
       open Jmap.Types

     

       14
       14
       +
       open Jmap.Wire

     

       15
       15
       +
       open Jmap.Methods

     

       16
       16
       +
       open Jmap_email

     

       17
       17
       +
       (* For step 2, we're only testing type checking. No implementations required. *)

     

       18
       18
       +
       

     

       19
       19
       +
       (* Dummy Unix module for type checking *)

     

       20
       20
       +
       module Unix = struct

     

       21
       21
       +
         type tm = {

     

       22
       22
       +
           tm_sec : int;

     

       23
       23
       +
           tm_min : int;

     

       24
       24
       +
           tm_hour : int;

     

       25
       25
       +
           tm_mday : int;

     

       26
       26
       +
           tm_mon : int;

     

       27
       27
       +
           tm_year : int;

     

       28
       28
       +
           tm_wday : int;

     

       29
       29
       +
           tm_yday : int;

     

       30
       30
       +
           tm_isdst : bool

     

       31
       31
       +
         }

     

       32
       32
       +
         

     

       33
       33
       +
         let time () = 0.0

     

       34
       34
       +
         let gettimeofday () = 0.0

     

       35
       35
       +
         let mktime tm = (0.0, tm)

     

       36
       36
       +
         let gmtime _time = {

     

       37
       37
       +
           tm_sec = 0; tm_min = 0; tm_hour = 0;

     

       38
       38
       +
           tm_mday = 1; tm_mon = 0; tm_year = 120;

     

       39
       39
       +
           tm_wday = 0; tm_yday = 0; tm_isdst = false;

     

       40
       40
       +
         }

     

       41
       41
       +
         

     

       42
       42
       +
         (* JMAP connection function - would be in a real implementation *)

     

       43
       43
       +
         let connect ~host ~username ~password ?auth_method () =

     

       44
       44
       +
           failwith "Not implemented"

     

       45
       45
       +
       end

     

       46
       46
       +
       

     

       47
       47
       +
       (* Dummy ISO8601 module *)

     

       48
       48
       +
       module ISO8601 = struct

     

       49
       49
       +
         let string_of_datetime _tm = "2023-01-01T00:00:00Z"

     

       50
       50
       +
       end

     

       51
       51
       +
       

     

       52
       52
       +
       (** Thread analyzer arguments *)

     

       53
       53
       +
       type thread_analyzer_args = {

     

       54
       54
       +
         thread_id : string option;

     

       55
       55
       +
         search : string option;

     

       56
       56
       +
         limit : int;

     

       57
       57
       +
         days : int;

     

       58
       58
       +
         subject : string option;

     

       59
       59
       +
         participants : string list;

     

       60
       60
       +
         format : [`Summary | `Detailed | `Timeline | `Graph];

     

       61
       61
       +
         include_body : bool;

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       (* Email filter helpers - stub implementations for type checking *)

     

       65
       65
       +
       module Email_filter = struct

     

       66
       66
       +
         let create_fulltext_filter text = Filter.condition (`Assoc [("text", `String text)])

     

       67
       67
       +
         let subject subj = Filter.condition (`Assoc [("subject", `String subj)])

     

       68
       68
       +
         let from email = Filter.condition (`Assoc [("from", `String email)])

     

       69
       69
       +
         let after date = Filter.condition (`Assoc [("receivedAt", `Assoc [("after", `Float date)])])

     

       70
       70
       +
         let before date = Filter.condition (`Assoc [("receivedAt", `Assoc [("before", `Float date)])])

     

       71
       71
       +
         let has_attachment () = Filter.condition (`Assoc [("hasAttachment", `Bool true)])

     

       72
       72
       +
         let unread () = Filter.condition (`Assoc [("isUnread", `Bool true)])

     

       73
       73
       +
         let in_mailbox id = Filter.condition (`Assoc [("inMailbox", `String id)])

     

       74
       74
       +
         let to_ email = Filter.condition (`Assoc [("to", `String email)])

     

       75
       75
       +
       end

     

       76
       76
       +
       

     

       77
       77
       +
       (* Thread module stub *)

     

       78
       78
       +
       module Thread = struct

     

       79
       79
       +
         type t = {

     

       80
       80
       +
           id : string;

     

       81
       81
       +
           email_ids : string list;

     

       82
       82
       +
         }

     

       83
       83
       +
         

     

       84
       84
       +
         let id thread = thread.id

     

       85
       85
       +
         let email_ids thread = thread.email_ids

     

       86
       86
       +
       end

     

       87
       87
       +
       

     

       88
       88
       +
       (** Command-line arguments **)

     

       89
       89
       +
       

     

       90
       90
       +
       let host_arg =

     

       91
       91
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       92
       92
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       93
       93
       +
       

     

       94
       94
       +
       let user_arg =

     

       95
       95
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       96
       96
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       97
       97
       +
       

     

       98
       98
       +
       let password_arg =

     

       99
       99
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       100
       100
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       101
       101
       +
       

     

       102
       102
       +
       let thread_id_arg =

     

       103
       103
       +
         Arg.(value & opt (some string) None & info ["t"; "thread"] 

     

       104
       104
       +
              ~docv:"THREAD_ID" ~doc:"Analyze specific thread by ID")

     

       105
       105
       +
       

     

       106
       106
       +
       let search_arg =

     

       107
       107
       +
         Arg.(value & opt (some string) None & info ["search"] 

     

       108
       108
       +
              ~docv:"QUERY" ~doc:"Search for threads containing text")

     

       109
       109
       +
       

     

       110
       110
       +
       let limit_arg =

     

       111
       111
       +
         Arg.(value & opt int 10 & info ["limit"] 

     

       112
       112
       +
              ~docv:"N" ~doc:"Maximum number of threads to display")

     

       113
       113
       +
       

     

       114
       114
       +
       let days_arg =

     

       115
       115
       +
         Arg.(value & opt int 30 & info ["days"] 

     

       116
       116
       +
              ~docv:"DAYS" ~doc:"Limit to threads from the past N days")

     

       117
       117
       +
       

     

       118
       118
       +
       let subject_arg =

     

       119
       119
       +
         Arg.(value & opt (some string) None & info ["subject"] 

     

       120
       120
       +
              ~docv:"SUBJECT" ~doc:"Search threads by subject")

     

       121
       121
       +
       

     

       122
       122
       +
       let participant_arg =

     

       123
       123
       +
         Arg.(value & opt_all string [] & info ["participant"] 

     

       124
       124
       +
              ~docv:"EMAIL" ~doc:"Filter by participant email")

     

       125
       125
       +
       

     

       126
       126
       +
       let format_arg =

     

       127
       127
       +
         Arg.(value & opt (enum [

     

       128
       128
       +
           "summary", `Summary;

     

       129
       129
       +
           "detailed", `Detailed;

     

       130
       130
       +
           "timeline", `Timeline;

     

       131
       131
       +
           "graph", `Graph;

     

       132
       132
       +
         ]) `Summary & info ["format"] ~docv:"FORMAT" ~doc:"Output format")

     

       133
       133
       +
       

     

       134
       134
       +
       let include_body_arg =

     

       135
       135
       +
         Arg.(value & flag & info ["include-body"] ~doc:"Include message bodies in output")

     

       136
       136
       +
       

     

       137
       137
       +
       (** Thread Analysis Functionality **)

     

       138
       138
       +
       

     

       139
       139
       +
       (* Calculate days ago from a date *)

     

       140
       140
       +
       let days_ago date =

     

       141
       141
       +
         let now = Unix.gettimeofday() in

     

       142
       142
       +
         int_of_float ((now -. date) /. 86400.0)

     

       143
       143
       +
       

     

       144
       144
       +
       (* Parse out email addresses from a participant string - simple version *)

     

       145
       145
       +
       let extract_email participant =

     

       146
       146
       +
         if String.contains participant '@' then participant

     

       147
       147
       +
         else participant ^ "@example.com" (* Default domain if none provided *)

     

       148
       148
       +
       

     

       149
       149
       +
       (* Create filter for thread queries *)

     

       150
       150
       +
       let create_thread_filter args =

     

       151
       151
       +
         let open Email_filter in

     

       152
       152
       +
         let filters = [] in

     

       153
       153
       +
         

     

       154
       154
       +
         (* Add search text condition *)

     

       155
       155
       +
         let filters = match args.search with

     

       156
       156
       +
           | None -> filters

     

       157
       157
       +
           | Some text -> create_fulltext_filter text :: filters

     

       158
       158
       +
         in

     

       159
       159
       +
         

     

       160
       160
       +
         (* Add subject condition *)

     

       161
       161
       +
         let filters = match args.subject with

     

       162
       162
       +
           | None -> filters

     

       163
       163
       +
           | Some subj -> Email_filter.subject subj :: filters

     

       164
       164
       +
         in

     

       165
       165
       +
         

     

       166
       166
       +
         (* Add date range based on days *)

     

       167
       167
       +
         let filters =

     

       168
       168
       +
           if args.days > 0 then

     

       169
       169
       +
             let now = Unix.gettimeofday() in

     

       170
       170
       +
             let past = now -. (float_of_int args.days *. 86400.0) in

     

       171
       171
       +
             after past :: filters

     

       172
       172
       +
           else

     

       173
       173
       +
             filters

     

       174
       174
       +
         in

     

       175
       175
       +
         

     

       176
       176
       +
         (* Add participant filters *)

     

       177
       177
       +
         let filters =

     

       178
       178
       +
           List.fold_left (fun acc participant ->

     

       179
       179
       +
             let email = extract_email participant in

     

       180
       180
       +
             (* This would need more complex logic to check both from and to fields *)

     

       181
       181
       +
             from email :: acc

     

       182
       182
       +
           ) filters args.participants

     

       183
       183
       +
         in

     

       184
       184
       +
         

     

       185
       185
       +
         (* Combine all filters with AND *)

     

       186
       186
       +
         match filters with

     

       187
       187
       +
         | [] -> Filter.condition (`Assoc [])  (* Empty filter *)

     

       188
       188
       +
         | [f] -> f

     

       189
       189
       +
         | filters -> Filter.and_ filters

     

       190
       190
       +
       

     

       191
       191
       +
       (* Display thread in requested format *)

     

       192
       192
       +
       let display_thread thread emails format include_body snippet_map =

     

       193
       193
       +
         let thread_id = Thread.id thread in

     

       194
       194
       +
         let email_count = List.length (Thread.email_ids thread) in

     

       195
       195
       +
         

     

       196
       196
       +
         (* Sort emails by date for proper display order *)

     

       197
       197
       +
         let sorted_emails = List.sort (fun e1 e2 ->

     

       198
       198
       +
           let date1 = Option.value (Types.Email.received_at e1) ~default:0.0 in

     

       199
       199
       +
           let date2 = Option.value (Types.Email.received_at e2) ~default:0.0 in

     

       200
       200
       +
           compare date1 date2

     

       201
       201
       +
         ) emails in

     

       202
       202
       +
         

     

       203
       203
       +
         (* Get a snippet for an email if available *)

     

       204
       204
       +
         let get_snippet email_id =

     

       205
       205
       +
           match Hashtbl.find_opt snippet_map email_id with

     

       206
       206
       +
           | Some snippet -> snippet

     

       207
       207
       +
           | None -> "(No preview available)"

     

       208
       208
       +
         in

     

       209
       209
       +
         

     

       210
       210
       +
         match format with

     

       211
       211
       +
         | `Summary ->

     

       212
       212
       +
             Printf.printf "Thread: %s (%d messages)\n\n" thread_id email_count;

     

       213
       213
       +
             

     

       214
       214
       +
             (* Print first email subject as thread subject *)

     

       215
       215
       +
             (match sorted_emails with

     

       216
       216
       +
             | first :: _ ->

     

       217
       217
       +
                 let subject = Option.value (Types.Email.subject first) ~default:"(No subject)" in

     

       218
       218
       +
                 Printf.printf "Subject: %s\n\n" subject

     

       219
       219
       +
             | [] -> Printf.printf "No emails available\n\n");

     

       220
       220
       +
             

     

       221
       221
       +
             (* List participants *)

     

       222
       222
       +
             let participants = sorted_emails |> List.fold_left (fun acc email ->

     

       223
       223
       +
               let from_list = Option.value (Types.Email.from email) ~default:[] in

     

       224
       224
       +
               from_list |> List.fold_left (fun acc addr ->

     

       225
       225
       +
                 let email = Types.Email_address.email addr in

     

       226
       226
       +
                 if not (List.mem email acc) then email :: acc else acc

     

       227
       227
       +
               ) acc

     

       228
       228
       +
             ) [] in

     

       229
       229
       +
             

     

       230
       230
       +
             Printf.printf "Participants: %s\n\n" (String.concat ", " participants);

     

       231
       231
       +
             

     

       232
       232
       +
             (* Show timespan *)

     

       233
       233
       +
             (match sorted_emails with

     

       234
       234
       +
             | first :: _ :: _ :: _ -> (* At least a few messages *)

     

       235
       235
       +
                 let first_date = Option.value (Types.Email.received_at first) ~default:0.0 in

     

       236
       236
       +
                 let last_date = Option.value (Types.Email.received_at (List.hd (List.rev sorted_emails))) ~default:0.0 in

     

       237
       237
       +
                 let datetime_str = ISO8601.string_of_datetime (Unix.gmtime first_date) in

     

       238
       238
       +
                 let first_str = String.sub datetime_str 0 (min 19 (String.length datetime_str)) in

     

       239
       239
       +
                 let datetime_str = ISO8601.string_of_datetime (Unix.gmtime last_date) in

     

       240
       240
       +
                 let last_str = String.sub datetime_str 0 (min 19 (String.length datetime_str)) in

     

       241
       241
       +
                 let duration_days = int_of_float ((last_date -. first_date) /. 86400.0) in

     

       242
       242
       +
                 Printf.printf "Timespan: %s to %s (%d days)\n\n" first_str last_str duration_days

     

       243
       243
       +
             | _ -> ());

     

       244
       244
       +
             

     

       245
       245
       +
             (* Show message count by participant *)

     

       246
       246
       +
             let message_counts = sorted_emails |> List.fold_left (fun acc email ->

     

       247
       247
       +
               let from_list = Option.value (Types.Email.from email) ~default:[] in

     

       248
       248
       +
               match from_list with

     

       249
       249
       +
               | addr :: _ ->

     

       250
       250
       +
                   let email = Types.Email_address.email addr in

     

       251
       251
       +
                   let count = try Hashtbl.find acc email with Not_found -> 0 in

     

       252
       252
       +
                   Hashtbl.replace acc email (count + 1);

     

       253
       253
       +
                   acc

     

       254
       254
       +
               | [] -> acc

     

       255
       255
       +
             ) (Hashtbl.create 10) in

     

       256
       256
       +
             

     

       257
       257
       +
             Printf.printf "Messages per participant:\n";

     

       258
       258
       +
             Hashtbl.iter (fun email count ->

     

       259
       259
       +
               Printf.printf "  %s: %d messages\n" email count

     

       260
       260
       +
             ) message_counts;

     

       261
       261
       +
             Printf.printf "\n"

     

       262
       262
       +
         

     

       263
       263
       +
         | `Detailed ->

     

       264
       264
       +
             Printf.printf "Thread: %s (%d messages)\n\n" thread_id email_count;

     

       265
       265
       +
             

     

       266
       266
       +
             (* Print detailed information for each email *)

     

       267
       267
       +
             sorted_emails |> List.iteri (fun i email ->

     

       268
       268
       +
               let id = Option.value (Types.Email.id email) ~default:"(unknown)" in

     

       269
       269
       +
               let subject = Option.value (Types.Email.subject email) ~default:"(No subject)" in

     

       270
       270
       +
               

     

       271
       271
       +
               let from_list = Option.value (Types.Email.from email) ~default:[] in

     

       272
       272
       +
               let from = match from_list with

     

       273
       273
       +
                 | addr :: _ -> Types.Email_address.email addr

     

       274
       274
       +
                 | [] -> "(unknown)"

     

       275
       275
       +
               in

     

       276
       276
       +
               

     

       277
       277
       +
               let date = match Types.Email.received_at email with

     

       278
       278
       +
                 | Some d ->

     

       279
       279
       +
                     let datetime_str = ISO8601.string_of_datetime (Unix.gmtime d) in

     

       280
       280
       +
                     String.sub datetime_str 0 (min 19 (String.length datetime_str))

     

       281
       281
       +
                 | None -> "(unknown)"

     

       282
       282
       +
               in

     

       283
       283
       +
               

     

       284
       284
       +
               let days = match Types.Email.received_at email with

     

       285
       285
       +
                 | Some d -> Printf.sprintf " (%d days ago)" (days_ago d)

     

       286
       286
       +
                 | None -> ""

     

       287
       287
       +
               in

     

       288
       288
       +
               

     

       289
       289
       +
               Printf.printf "Email %d of %d:\n" (i+1) email_count;

     

       290
       290
       +
               Printf.printf "  ID:      %s\n" id;

     

       291
       291
       +
               Printf.printf "  Subject: %s\n" subject;

     

       292
       292
       +
               Printf.printf "  From:    %s\n" from;

     

       293
       293
       +
               Printf.printf "  Date:    %s%s\n" date days;

     

       294
       294
       +
               

     

       295
       295
       +
               let keywords = match Types.Email.keywords email with

     

       296
       296
       +
                 | Some kw -> Types.Keywords.custom_keywords kw |> String.concat ", "

     

       297
       297
       +
                 | None -> "(none)"

     

       298
       298
       +
               in

     

       299
       299
       +
               if keywords <> "(none)" then

     

       300
       300
       +
                 Printf.printf "  Flags:   %s\n" keywords;

     

       301
       301
       +
               

     

       302
       302
       +
               (* Show preview from snippet if available *)

     

       303
       303
       +
               Printf.printf "  Snippet: %s\n" (get_snippet id);

     

       304
       304
       +
               

     

       305
       305
       +
               (* Show message body if requested *)

     

       306
       306
       +
               if include_body then

     

       307
       307
       +
                 match Types.Email.text_body email with

     

       308
       308
       +
                 | Some parts when parts <> [] ->

     

       309
       309
       +
                     let first_part = List.hd parts in

     

       310
       310
       +
                     Printf.printf "  Body: %s\n" "(body content would be here in real implementation)";

     

       311
       311
       +
                 | _ -> ();

     

       312
       312
       +
               

     

       313
       313
       +
               Printf.printf "\n"

     

       314
       314
       +
             )

     

       315
       315
       +
         

     

       316
       316
       +
         | `Timeline ->

     

       317
       317
       +
             Printf.printf "Timeline for Thread: %s\n\n" thread_id;

     

       318
       318
       +
             

     

       319
       319
       +
             (* Get the first email's subject as thread subject *)

     

       320
       320
       +
             (match sorted_emails with

     

       321
       321
       +
             | first :: _ ->

     

       322
       322
       +
                 let subject = Option.value (Types.Email.subject first) ~default:"(No subject)" in

     

       323
       323
       +
                 Printf.printf "Subject: %s\n\n" subject

     

       324
       324
       +
             | [] -> Printf.printf "No emails available\n\n");

     

       325
       325
       +
             

     

       326
       326
       +
             (* Create a timeline visualization *)

     

       327
       327
       +
             if sorted_emails = [] then

     

       328
       328
       +
               Printf.printf "No emails to display\n"

     

       329
       329
       +
             else

     

       330
       330
       +
               let first_email = List.hd sorted_emails in

     

       331
       331
       +
               let last_email = List.hd (List.rev sorted_emails) in

     

       332
       332
       +
               

     

       333
       333
       +
               let first_date = Option.value (Types.Email.received_at first_email) ~default:0.0 in

     

       334
       334
       +
               let last_date = Option.value (Types.Email.received_at last_email) ~default:0.0 in

     

       335
       335
       +
               

     

       336
       336
       +
               let total_duration = max 1.0 (last_date -. first_date) in

     

       337
       337
       +
               let timeline_width = 50 in

     

       338
       338
       +
               

     

       339
       339
       +
               let datetime_str = ISO8601.string_of_datetime (Unix.gmtime first_date) in

     

       340
       340
       +
               let start_str = String.sub datetime_str 0 (min 19 (String.length datetime_str)) in

     

       341
       341
       +
               Printf.printf "Start date: %s\n" start_str;

     

       342
       342
       +
               

     

       343
       343
       +
               let datetime_str = ISO8601.string_of_datetime (Unix.gmtime last_date) in

     

       344
       344
       +
               let end_str = String.sub datetime_str 0 (min 19 (String.length datetime_str)) in

     

       345
       345
       +
               Printf.printf "End date:   %s\n\n" end_str;

     

       346
       346
       +
               

     

       347
       347
       +
               Printf.printf "Timeline: [%s]\n" (String.make timeline_width '-');

     

       348
       348
       +
               

     

       349
       349
       +
               sorted_emails |> List.iteri (fun i email ->

     

       350
       350
       +
                 let date = Option.value (Types.Email.received_at email) ~default:0.0 in

     

       351
       351
       +
                 let position = int_of_float (float_of_int timeline_width *. (date -. first_date) /. total_duration) in

     

       352
       352
       +
                 

     

       353
       353
       +
                 let from_list = Option.value (Types.Email.from email) ~default:[] in

     

       354
       354
       +
                 let from = match from_list with

     

       355
       355
       +
                   | addr :: _ -> Types.Email_address.email addr

     

       356
       356
       +
                   | [] -> "(unknown)"

     

       357
       357
       +
                 in

     

       358
       358
       +
                 

     

       359
       359
       +
                 let datetime_str = ISO8601.string_of_datetime (Unix.gmtime date) in

     

       360
       360
       +
                 let date_str = String.sub datetime_str 0 (min 19 (String.length datetime_str)) in

     

       361
       361
       +
                 

     

       362
       362
       +
                 let marker = String.make timeline_width ' ' |> String.mapi (fun j c ->

     

       363
       363
       +
                   if j = position then '*' else if j < position then ' ' else c

     

       364
       364
       +
                 ) in

     

       365
       365
       +
                 

     

       366
       366
       +
                 Printf.printf "%s [%s] %s: %s\n" date_str marker from (get_snippet (Option.value (Types.Email.id email) ~default:""))

     

       367
       367
       +
               );

     

       368
       368
       +
               

     

       369
       369
       +
               Printf.printf "\n"

     

       370
       370
       +
         

     

       371
       371
       +
         | `Graph ->

     

       372
       372
       +
             Printf.printf "Thread Graph for: %s\n\n" thread_id;

     

       373
       373
       +
             

     

       374
       374
       +
             (* In a real implementation, this would build a proper thread graph based on

     

       375
       375
       +
                In-Reply-To and References headers. For this demo, we'll just show a simple tree. *)

     

       376
       376
       +
             

     

       377
       377
       +
             (* Get the first email's subject as thread subject *)

     

       378
       378
       +
             (match sorted_emails with

     

       379
       379
       +
             | first :: _ ->

     

       380
       380
       +
                 let subject = Option.value (Types.Email.subject first) ~default:"(No subject)" in

     

       381
       381
       +
                 Printf.printf "Subject: %s\n\n" subject

     

       382
       382
       +
             | [] -> Printf.printf "No emails available\n\n");

     

       383
       383
       +
             

     

       384
       384
       +
             (* Create a simple thread tree visualization *)

     

       385
       385
       +
             if sorted_emails = [] then

     

       386
       386
       +
               Printf.printf "No emails to display\n"

     

       387
       387
       +
             else

     

       388
       388
       +
               let indent level = String.make (level * 2) ' ' in

     

       389
       389
       +
               

     

       390
       390
       +
               (* Very simplified threading model - in a real implementation, 

     

       391
       391
       +
                  this would use In-Reply-To and References headers *)

     

       392
       392
       +
               sorted_emails |> List.iteri (fun i email ->

     

       393
       393
       +
                 let level = min i 4 in  (* Simplified nesting - would be based on real reply chain *)

     

       394
       394
       +
                 

     

       395
       395
       +
                 let id = Option.value (Types.Email.id email) ~default:"(unknown)" in

     

       396
       396
       +
                 

     

       397
       397
       +
                 let from_list = Option.value (Types.Email.from email) ~default:[] in

     

       398
       398
       +
                 let from = match from_list with

     

       399
       399
       +
                   | addr :: _ -> Types.Email_address.email addr

     

       400
       400
       +
                   | [] -> "(unknown)"

     

       401
       401
       +
                 in

     

       402
       402
       +
                 

     

       403
       403
       +
                 let date = match Types.Email.received_at email with

     

       404
       404
       +
                   | Some d -> 

     

       405
       405
       +
                       let datetime_str = ISO8601.string_of_datetime (Unix.gmtime d) in

     

       406
       406
       +
                       String.sub datetime_str 0 (min 19 (String.length datetime_str))

     

       407
       407
       +
                   | None -> "(unknown)"

     

       408
       408
       +
                 in

     

       409
       409
       +
                 

     

       410
       410
       +
                 Printf.printf "%s%s [%s] %s\n" 

     

       411
       411
       +
                   (indent level) 

     

       412
       412
       +
                   (if level = 0 then "+" else if level = 1 then "|-" else "|--")

     

       413
       413
       +
                   date from;

     

       414
       414
       +
                 

     

       415
       415
       +
                 Printf.printf "%s%s\n" (indent (level + 4)) (get_snippet id);

     

       416
       416
       +
               );

     

       417
       417
       +
               

     

       418
       418
       +
               Printf.printf "\n"

     

       419
       419
       +
       

     

       420
       420
       +
       (* Command implementation *)

     

       421
       421
       +
       let thread_command host user password thread_id search limit days subject 

     

       422
       422
       +
                           participant format include_body : int =

     

       423
       423
       +
         (* Pack arguments into a record for easier passing *)

     

       424
       424
       +
         let args : thread_analyzer_args = {

     

       425
       425
       +
           thread_id; search; limit; days; subject; 

     

       426
       426
       +
           participants = participant; format; include_body

     

       427
       427
       +
         } in

     

       428
       428
       +
         

     

       429
       429
       +
         (* Main workflow would be implemented here using the JMAP library *)

     

       430
       430
       +
         Printf.printf "JMAP Thread Analyzer\n";

     

       431
       431
       +
         Printf.printf "Server: %s\n" host;

     

       432
       432
       +
         Printf.printf "User: %s\n\n" user;

     

       433
       433
       +
         

     

       434
       434
       +
         (* This is where the actual JMAP calls would happen, like:

     

       435
       435
       +
         

     

       436
       436
       +
         let analyze_threads () =

     

       437
       437
       +
           let* (ctx, session) = Jmap.Unix.connect 

     

       438
       438
       +
             ~host ~username:user ~password 

     

       439
       439
       +
             ~auth_method:(Jmap.Unix.Basic(user, password)) () in

     

       440
       440
       +
           

     

       441
       441
       +
           (* Get primary account ID *)

     

       442
       442
       +
           let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       443
       443
       +
             | Ok id -> id

     

       444
       444
       +
             | Error _ -> failwith "No mail account found"

     

       445
       445
       +
           in

     

       446
       446
       +
           

     

       447
       447
       +
           match args.thread_id with

     

       448
       448
       +
           | Some id ->

     

       449
       449
       +
               (* Analyze a specific thread by ID *)

     

       450
       450
       +
               let* thread_result = Thread.get ctx

     

       451
       451
       +
                 ~account_id

     

       452
       452
       +
                 ~ids:[id] in

     

       453
       453
       +
               

     

       454
       454
       +
               (* Handle thread fetch result *)

     

       455
       455
       +
               ...

     

       456
       456
       +
               

     

       457
       457
       +
           | None ->

     

       458
       458
       +
               (* Search for threads based on criteria *)

     

       459
       459
       +
               let filter = create_thread_filter args in

     

       460
       460
       +
               

     

       461
       461
       +
               (* Email/query to find emails matching criteria *)

     

       462
       462
       +
               let* query_result = Email.query ctx

     

       463
       463
       +
                 ~account_id

     

       464
       464
       +
                 ~filter

     

       465
       465
       +
                 ~sort:[Email_sort.received_newest_first ()]

     

       466
       466
       +
                 ~collapse_threads:true

     

       467
       467
       +
                 ~limit:args.limit in

     

       468
       468
       +
               

     

       469
       469
       +
               (* Process query results to get thread IDs *)

     

       470
       470
       +
               ...

     

       471
       471
       +
         *)

     

       472
       472
       +
         

     

       473
       473
       +
         (match thread_id with

     

       474
       474
       +
         | Some id ->

     

       475
       475
       +
             Printf.printf "Analyzing thread: %s\n\n" id;

     

       476
       476
       +
             

     

       477
       477
       +
             (* Simulate a thread with some emails *)

     

       478
       478
       +
             let emails = 5 in

     

       479
       479
       +
             Printf.printf "Thread contains %d emails\n" emails;

     

       480
       480
       +
             

     

       481
       481
       +
             (* In a real implementation, we would display the actual thread data here *)

     

       482
       482
       +
             Printf.printf "Example output format would show thread details here\n"

     

       483
       483
       +
         

     

       484
       484
       +
         | None ->

     

       485
       485
       +
             if search <> None then

     

       486
       486
       +
               Printf.printf "Searching for threads containing: %s\n" (Option.get search)

     

       487
       487
       +
             else if subject <> None then

     

       488
       488
       +
               Printf.printf "Searching for threads with subject: %s\n" (Option.get subject)

     

       489
       489
       +
             else

     

       490
       490
       +
               Printf.printf "No specific thread or search criteria provided\n");

     

       491
       491
       +
             

     

       492
       492
       +
             if participant <> [] then

     

       493
       493
       +
               Printf.printf "Filtering to threads involving: %s\n" 

     

       494
       494
       +
                 (String.concat ", " participant);

     

       495
       495
       +
             

     

       496
       496
       +
             Printf.printf "Looking at threads from the past %d days\n" days;

     

       497
       497
       +
             Printf.printf "Showing up to %d threads\n\n" limit;

     

       498
       498
       +
             

     

       499
       499
       +
             (* Simulate finding some threads *)

     

       500
       500
       +
             let thread_count = min limit 3 in

     

       501
       501
       +
             Printf.printf "Found %d matching threads\n\n" thread_count;

     

       502
       502
       +
             

     

       503
       503
       +
             (* In a real implementation, we would display the actual threads here *)

     

       504
       504
       +
             for i = 1 to thread_count do

     

       505
       505
       +
               Printf.printf "Thread %d would be displayed here\n\n" i

     

       506
       506
       +
             done;

     

       507
       507
       +
         

     

       508
       508
       +
         (* Since we're only type checking, we'll exit with success *)

     

       509
       509
       +
         0

     

       510
       510
       +
       

     

       511
       511
       +
       (* Command definition *)

     

       512
       512
       +
       let thread_cmd =

     

       513
       513
       +
         let doc = "analyze email threads using JMAP" in

     

       514
       514
       +
         let man = [

     

       515
       515
       +
           `S Manpage.s_description;

     

       516
       516
       +
           `P "Analyzes email threads with detailed visualization options.";

     

       517
       517
       +
           `P "Demonstrates how to work with JMAP's thread capabilities.";

     

       518
       518
       +
           `S Manpage.s_examples;

     

       519
       519
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 -t thread123";

     

       520
       520
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --search \"project update\" --format timeline";

     

       521
       521
       +
         ] in

     

       522
       522
       +
         

     

       523
       523
       +
         let cmd =

     

       524
       524
       +
           Cmd.v

     

       525
       525
       +
             (Cmd.info "jmap-thread-analyzer" ~version:"1.0" ~doc ~man)

     

       526
       526
       +
             Term.(const thread_command $ host_arg $ user_arg $ password_arg $ 

     

       527
       527
       +
                   thread_id_arg $ search_arg $ limit_arg $ days_arg $ 

     

       528
       528
       +
                   subject_arg $ participant_arg $ format_arg $ include_body_arg)

     

       529
       529
       +
         in

     

       530
       530
       +
         cmd

     

       531
       531
       +
       

     

       532
       532
       +
       (* Main entry point *)

     

       533
       533
       +
       let () = exit (Cmd.eval' thread_cmd)

+406

bin/jmap_vacation_manager.ml

···

       1
       1
       +
       (*

     

       2
       2
       +
        * jmap_vacation_manager.ml - Manage vacation/out-of-office auto-responses

     

       3
       3
       +
        *

     

       4
       4
       +
        * This binary demonstrates JMAP's vacation response capabilities for setting

     

       5
       5
       +
        * up and managing automatic email responses.

     

       6
       6
       +
        *

     

       7
       7
       +
        * For step 2, we're only testing type checking. No implementations required.

     

       8
       8
       +
        *)

     

       9
       9
       +
       

     

       10
       10
       +
       open Cmdliner

     

       11
       11
       +
       

     

       12
       12
       +
       (** Vacation response actions **)

     

       13
       13
       +
       type vacation_action = 

     

       14
       14
       +
         | Show

     

       15
       15
       +
         | Enable of vacation_config

     

       16
       16
       +
         | Disable

     

       17
       17
       +
         | Update of vacation_config

     

       18
       18
       +
       

     

       19
       19
       +
       and vacation_config = {

     

       20
       20
       +
         subject : string option;

     

       21
       21
       +
         text_body : string;

     

       22
       22
       +
         html_body : string option;

     

       23
       23
       +
         from_date : float option;

     

       24
       24
       +
         to_date : float option;

     

       25
       25
       +
         exclude_addresses : string list;

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       (** Command-line arguments **)

     

       29
       29
       +
       

     

       30
       30
       +
       let host_arg =

     

       31
       31
       +
         Arg.(required & opt (some string) None & info ["h"; "host"] 

     

       32
       32
       +
              ~docv:"HOST" ~doc:"JMAP server hostname")

     

       33
       33
       +
       

     

       34
       34
       +
       let user_arg =

     

       35
       35
       +
         Arg.(required & opt (some string) None & info ["u"; "user"] 

     

       36
       36
       +
              ~docv:"USERNAME" ~doc:"Username for authentication")

     

       37
       37
       +
       

     

       38
       38
       +
       let password_arg =

     

       39
       39
       +
         Arg.(required & opt (some string) None & info ["p"; "password"] 

     

       40
       40
       +
              ~docv:"PASSWORD" ~doc:"Password for authentication")

     

       41
       41
       +
       

     

       42
       42
       +
       let enable_arg =

     

       43
       43
       +
         Arg.(value & flag & info ["e"; "enable"] 

     

       44
       44
       +
              ~doc:"Enable vacation response")

     

       45
       45
       +
       

     

       46
       46
       +
       let disable_arg =

     

       47
       47
       +
         Arg.(value & flag & info ["d"; "disable"] 

     

       48
       48
       +
              ~doc:"Disable vacation response")

     

       49
       49
       +
       

     

       50
       50
       +
       let show_arg =

     

       51
       51
       +
         Arg.(value & flag & info ["s"; "show"] 

     

       52
       52
       +
              ~doc:"Show current vacation settings")

     

       53
       53
       +
       

     

       54
       54
       +
       let subject_arg =

     

       55
       55
       +
         Arg.(value & opt (some string) None & info ["subject"] 

     

       56
       56
       +
              ~docv:"SUBJECT" ~doc:"Vacation email subject line")

     

       57
       57
       +
       

     

       58
       58
       +
       let message_arg =

     

       59
       59
       +
         Arg.(value & opt (some string) None & info ["m"; "message"] 

     

       60
       60
       +
              ~docv:"TEXT" ~doc:"Vacation message text")

     

       61
       61
       +
       

     

       62
       62
       +
       let message_file_arg =

     

       63
       63
       +
         Arg.(value & opt (some string) None & info ["message-file"] 

     

       64
       64
       +
              ~docv:"FILE" ~doc:"Read vacation message from file")

     

       65
       65
       +
       

     

       66
       66
       +
       let html_message_arg =

     

       67
       67
       +
         Arg.(value & opt (some string) None & info ["html-message"] 

     

       68
       68
       +
              ~docv:"HTML" ~doc:"HTML vacation message")

     

       69
       69
       +
       

     

       70
       70
       +
       let from_date_arg =

     

       71
       71
       +
         Arg.(value & opt (some string) None & info ["from-date"] 

     

       72
       72
       +
              ~docv:"DATE" ~doc:"Start date for vacation (YYYY-MM-DD)")

     

       73
       73
       +
       

     

       74
       74
       +
       let to_date_arg =

     

       75
       75
       +
         Arg.(value & opt (some string) None & info ["to-date"] 

     

       76
       76
       +
              ~docv:"DATE" ~doc:"End date for vacation (YYYY-MM-DD)")

     

       77
       77
       +
       

     

       78
       78
       +
       let exclude_arg =

     

       79
       79
       +
         Arg.(value & opt_all string [] & info ["exclude"] 

     

       80
       80
       +
              ~docv:"EMAIL" ~doc:"Email address to exclude from auto-response")

     

       81
       81
       +
       

     

       82
       82
       +
       (** Helper functions **)

     

       83
       83
       +
       

     

       84
       84
       +
       (* Parse date string to Unix timestamp *)

     

       85
       85
       +
       let parse_date date_str =

     

       86
       86
       +
         try

     

       87
       87
       +
           let (year, month, day) = Scanf.sscanf date_str "%d-%d-%d" (fun y m d -> (y, m, d)) in

     

       88
       88
       +
           let tm = Unix.{ tm_sec = 0; tm_min = 0; tm_hour = 0;

     

       89
       89
       +
                           tm_mday = day; tm_mon = month - 1; tm_year = year - 1900;

     

       90
       90
       +
                           tm_wday = 0; tm_yday = 0; tm_isdst = false } in

     

       91
       91
       +
           Some (Unix.mktime tm |> fst)

     

       92
       92
       +
         with _ ->

     

       93
       93
       +
           Printf.eprintf "Invalid date format: %s (use YYYY-MM-DD)\n" date_str;

     

       94
       94
       +
           None

     

       95
       95
       +
       

     

       96
       96
       +
       (* Format Unix timestamp as date string *)

     

       97
       97
       +
       let format_date timestamp =

     

       98
       98
       +
         let tm = Unix.localtime timestamp in

     

       99
       99
       +
         Printf.sprintf "%04d-%02d-%02d"

     

       100
       100
       +
           (tm.Unix.tm_year + 1900) (tm.Unix.tm_mon + 1) tm.Unix.tm_mday

     

       101
       101
       +
       

     

       102
       102
       +
       (* Read file contents *)

     

       103
       103
       +
       let read_file filename =

     

       104
       104
       +
         let ic = open_in filename in

     

       105
       105
       +
         let len = in_channel_length ic in

     

       106
       106
       +
         let content = really_input_string ic len in

     

       107
       107
       +
         close_in ic;

     

       108
       108
       +
         content

     

       109
       109
       +
       

     

       110
       110
       +
       (* Display vacation response settings *)

     

       111
       111
       +
       let show_vacation_response vacation =

     

       112
       112
       +
         Printf.printf "\nVacation Response Settings:\n";

     

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

     

       114
       114
       +
         

     

       115
       115
       +
         Printf.printf "Status: %s\n" 

     

       116
       116
       +
           (if Jmap_email.Vacation.Vacation_response.is_enabled vacation then "ENABLED" else "DISABLED");

     

       117
       117
       +
         

     

       118
       118
       +
         (match Jmap_email.Vacation.Vacation_response.subject vacation with

     

       119
       119
       +
         | Some subj -> Printf.printf "Subject: %s\n" subj

     

       120
       120
       +
         | None -> Printf.printf "Subject: (default)\n");

     

       121
       121
       +
         

     

       122
       122
       +
         (match Jmap_email.Vacation.Vacation_response.text_body vacation with

     

       123
       123
       +
         | Some body -> 

     

       124
       124
       +
             Printf.printf "\nMessage:\n";

     

       125
       125
       +
             Printf.printf "--------\n";

     

       126
       126
       +
             Printf.printf "%s\n" body;

     

       127
       127
       +
             Printf.printf "--------\n"

     

       128
       128
       +
         | None -> Printf.printf "\nMessage: (none set)\n");

     

       129
       129
       +
         

     

       130
       130
       +
         (match Jmap_email.Vacation.Vacation_response.from_date vacation with

     

       131
       131
       +
         | Some date -> Printf.printf "\nActive from: %s\n" (format_date date)

     

       132
       132
       +
         | None -> ());

     

       133
       133
       +
         

     

       134
       134
       +
         (match Jmap_email.Vacation.Vacation_response.to_date vacation with

     

       135
       135
       +
         | Some date -> Printf.printf "Active until: %s\n" (format_date date)

     

       136
       136
       +
         | None -> ());

     

       137
       137
       +
         

     

       138
       138
       +
         let excluded = match Jmap_email.Vacation.Vacation_response.id vacation with

     

       139
       139
       +
           | _ -> []  (* exclude_addresses not available in interface *) in

     

       140
       140
       +
         if excluded <> [] then (

     

       141
       141
       +
           Printf.printf "\nExcluded addresses:\n";

     

       142
       142
       +
           List.iter (Printf.printf "  - %s\n") excluded

     

       143
       143
       +
         )

     

       144
       144
       +
       

     

       145
       145
       +
       (* Get current vacation response *)

     

       146
       146
       +
       let get_vacation_response ctx session account_id =

     

       147
       147
       +
         let get_args = Jmap.Methods.Get_args.v

     

       148
       148
       +
           ~account_id

     

       149
       149
       +
           ~properties:["isEnabled"; "subject"; "textBody"; "htmlBody"; 

     

       150
       150
       +
                        "fromDate"; "toDate"; "excludeAddresses"]

     

       151
       151
       +
           () in

     

       152
       152
       +
           

     

       153
       153
       +
         let invocation = Jmap.Wire.Invocation.v

     

       154
       154
       +
           ~method_name:"VacationResponse/get"

     

       155
       155
       +
           ~arguments:(`Assoc []) (* Would serialize get_args *)

     

       156
       156
       +
           ~method_call_id:"get1"

     

       157
       157
       +
           () in

     

       158
       158
       +
           

     

       159
       159
       +
         let request = Jmap.Wire.Request.v

     

       160
       160
       +
           ~using:[Jmap.capability_core; Jmap_email.capability_mail; Jmap_email.capability_vacationresponse]

     

       161
       161
       +
           ~method_calls:[invocation]

     

       162
       162
       +
           () in

     

       163
       163
       +
           

     

       164
       164
       +
         match Jmap_unix.request ctx request with

     

       165
       165
       +
         | Ok _ ->

     

       166
       166
       +
             (* Would extract from response - for now create a sample *)

     

       167
       167
       +
             Ok (Jmap_email.Vacation.Vacation_response.v

     

       168
       168
       +
               ~id:"vacation1"

     

       169
       169
       +
               ~is_enabled:false

     

       170
       170
       +
               ~subject:"Out of Office"

     

       171
       171
       +
               ~text_body:"I am currently out of the office and will respond when I return."

     

       172
       172
       +
               ())

     

       173
       173
       +
         | Error e -> Error e

     

       174
       174
       +
       

     

       175
       175
       +
       (* Update vacation response *)

     

       176
       176
       +
       let update_vacation_response ctx session account_id vacation_id updates =

     

       177
       177
       +
         let update_map = Hashtbl.create 1 in

     

       178
       178
       +
         Hashtbl.add update_map vacation_id updates;

     

       179
       179
       +
         

     

       180
       180
       +
         let set_args = Jmap.Methods.Set_args.v

     

       181
       181
       +
           ~account_id

     

       182
       182
       +
           ~update:update_map

     

       183
       183
       +
           () in

     

       184
       184
       +
           

     

       185
       185
       +
         let invocation = Jmap.Wire.Invocation.v

     

       186
       186
       +
           ~method_name:"VacationResponse/set"

     

       187
       187
       +
           ~arguments:(`Assoc []) (* Would serialize set_args *)

     

       188
       188
       +
           ~method_call_id:"set1"

     

       189
       189
       +
           () in

     

       190
       190
       +
           

     

       191
       191
       +
         let request = Jmap.Wire.Request.v

     

       192
       192
       +
           ~using:[Jmap.capability_core; Jmap_email.capability_mail; Jmap_email.capability_vacationresponse]

     

       193
       193
       +
           ~method_calls:[invocation]

     

       194
       194
       +
           () in

     

       195
       195
       +
           

     

       196
       196
       +
         match Jmap_unix.request ctx request with

     

       197
       197
       +
         | Ok _ -> Ok ()

     

       198
       198
       +
         | Error e -> Error e

     

       199
       199
       +
       

     

       200
       200
       +
       (* Process vacation action *)

     

       201
       201
       +
       let process_vacation_action ctx session account_id action =

     

       202
       202
       +
         match action with

     

       203
       203
       +
         | Show ->

     

       204
       204
       +
             (match get_vacation_response ctx session account_id with

     

       205
       205
       +
             | Ok vacation ->

     

       206
       206
       +
                 show_vacation_response vacation;

     

       207
       207
       +
                 0

     

       208
       208
       +
             | Error e ->

     

       209
       209
       +
                 Printf.eprintf "Failed to get vacation response: %s\n" (Jmap.Error.error_to_string e);

     

       210
       210
       +
                 1)

     

       211
       211
       +
             

     

       212
       212
       +
         | Enable config ->

     

       213
       213
       +
             Printf.printf "Enabling vacation response...\n";

     

       214
       214
       +
             

     

       215
       215
       +
             (* Build the vacation response object *)

     

       216
       216
       +
             let vacation = Jmap_email.Vacation.Vacation_response.v

     

       217
       217
       +
               ~id:"singleton"

     

       218
       218
       +
               ~is_enabled:true

     

       219
       219
       +
               ?subject:config.subject

     

       220
       220
       +
               ~text_body:config.text_body

     

       221
       221
       +
               ?html_body:config.html_body

     

       222
       222
       +
               ?from_date:config.from_date

     

       223
       223
       +
               ?to_date:config.to_date

     

       224
       224
       +
               () in

     

       225
       225
       +
               

     

       226
       226
       +
             (match update_vacation_response ctx session account_id "singleton" vacation with

     

       227
       227
       +
             | Ok () ->

     

       228
       228
       +
                 Printf.printf "\nVacation response enabled successfully!\n";

     

       229
       229
       +
                 

     

       230
       230
       +
                 (* Show what was set *)

     

       231
       231
       +
                 show_vacation_response vacation;

     

       232
       232
       +
                 0

     

       233
       233
       +
             | Error e ->

     

       234
       234
       +
                 Printf.eprintf "Failed to enable vacation response: %s\n" (Jmap.Error.error_to_string e);

     

       235
       235
       +
                 1)

     

       236
       236
       +
             

     

       237
       237
       +
         | Disable ->

     

       238
       238
       +
             Printf.printf "Disabling vacation response...\n";

     

       239
       239
       +
             

     

       240
       240
       +
             let updates = Jmap_email.Vacation.Vacation_response.v

     

       241
       241
       +
               ~id:"singleton"

     

       242
       242
       +
               ~is_enabled:false

     

       243
       243
       +
               () in

     

       244
       244
       +
               

     

       245
       245
       +
             (match update_vacation_response ctx session account_id "singleton" updates with

     

       246
       246
       +
             | Ok () ->

     

       247
       247
       +
                 Printf.printf "Vacation response disabled successfully!\n";

     

       248
       248
       +
                 0

     

       249
       249
       +
             | Error e ->

     

       250
       250
       +
                 Printf.eprintf "Failed to disable vacation response: %s\n" (Jmap.Error.error_to_string e);

     

       251
       251
       +
                 1)

     

       252
       252
       +
             

     

       253
       253
       +
         | Update config ->

     

       254
       254
       +
             Printf.printf "Updating vacation response...\n";

     

       255
       255
       +
             

     

       256
       256
       +
             (* Only update specified fields *)

     

       257
       257
       +
             let vacation = Jmap_email.Vacation.Vacation_response.v

     

       258
       258
       +
               ~id:"singleton"

     

       259
       259
       +
               ?subject:config.subject

     

       260
       260
       +
               ~text_body:config.text_body

     

       261
       261
       +
               ?html_body:config.html_body

     

       262
       262
       +
               ?from_date:config.from_date

     

       263
       263
       +
               ?to_date:config.to_date

     

       264
       264
       +
               () in

     

       265
       265
       +
               

     

       266
       266
       +
             (match update_vacation_response ctx session account_id "singleton" vacation with

     

       267
       267
       +
             | Ok () ->

     

       268
       268
       +
                 Printf.printf "Vacation response updated successfully!\n";

     

       269
       269
       +
                 

     

       270
       270
       +
                 (* Show current settings *)

     

       271
       271
       +
                 (match get_vacation_response ctx session account_id with

     

       272
       272
       +
                 | Ok current -> show_vacation_response current

     

       273
       273
       +
                 | Error _ -> ());

     

       274
       274
       +
                 0

     

       275
       275
       +
             | Error e ->

     

       276
       276
       +
                 Printf.eprintf "Failed to update vacation response: %s\n" (Jmap.Error.error_to_string e);

     

       277
       277
       +
                 1)

     

       278
       278
       +
       

     

       279
       279
       +
       (* Command implementation *)

     

       280
       280
       +
       let vacation_command host user password enable disable show subject message 

     

       281
       281
       +
                            message_file html_message from_date to_date exclude : int =

     

       282
       282
       +
         Printf.printf "JMAP Vacation Manager\n";

     

       283
       283
       +
         Printf.printf "Server: %s\n" host;

     

       284
       284
       +
         Printf.printf "User: %s\n\n" user;

     

       285
       285
       +
         

     

       286
       286
       +
         (* Determine action *)

     

       287
       287
       +
         let action_count = (if enable then 1 else 0) + 

     

       288
       288
       +
                            (if disable then 1 else 0) + 

     

       289
       289
       +
                            (if show then 1 else 0) in

     

       290
       290
       +
                            

     

       291
       291
       +
         if action_count = 0 then (

     

       292
       292
       +
           Printf.eprintf "Error: Must specify an action: --enable, --disable, or --show\n";

     

       293
       293
       +
           exit 1

     

       294
       294
       +
         );

     

       295
       295
       +
         

     

       296
       296
       +
         if action_count > 1 then (

     

       297
       297
       +
           Printf.eprintf "Error: Can only specify one action at a time\n";

     

       298
       298
       +
           exit 1

     

       299
       299
       +
         );

     

       300
       300
       +
         

     

       301
       301
       +
         (* Build vacation config if enabling or updating *)

     

       302
       302
       +
         let config = if enable || (not disable && not show) then

     

       303
       303
       +
           (* Read message content *)

     

       304
       304
       +
           let text_body = match message, message_file with

     

       305
       305
       +
             | Some text, _ -> text

     

       306
       306
       +
             | None, Some file -> read_file file

     

       307
       307
       +
             | None, None ->

     

       308
       308
       +
                 if enable then (

     

       309
       309
       +
                   Printf.eprintf "Error: Must provide vacation message (--message or --message-file)\n";

     

       310
       310
       +
                   exit 1

     

       311
       311
       +
                 ) else ""

     

       312
       312
       +
           in

     

       313
       313
       +
           

     

       314
       314
       +
           (* Parse dates *)

     

       315
       315
       +
           let from_date = match from_date with

     

       316
       316
       +
             | Some date_str -> parse_date date_str

     

       317
       317
       +
             | None -> None

     

       318
       318
       +
           in

     

       319
       319
       +
           

     

       320
       320
       +
           let to_date = match to_date with

     

       321
       321
       +
             | Some date_str -> parse_date date_str

     

       322
       322
       +
             | None -> None

     

       323
       323
       +
           in

     

       324
       324
       +
           

     

       325
       325
       +
           Some {

     

       326
       326
       +
             subject;

     

       327
       327
       +
             text_body;

     

       328
       328
       +
             html_body = html_message;

     

       329
       329
       +
             from_date;

     

       330
       330
       +
             to_date;

     

       331
       331
       +
             exclude_addresses = exclude;

     

       332
       332
       +
           }

     

       333
       333
       +
         else

     

       334
       334
       +
           None

     

       335
       335
       +
         in

     

       336
       336
       +
         

     

       337
       337
       +
         (* Determine action *)

     

       338
       338
       +
         let action = 

     

       339
       339
       +
           if show then Show

     

       340
       340
       +
           else if disable then Disable

     

       341
       341
       +
           else if enable then Enable (Option.get config)

     

       342
       342
       +
           else Update (Option.get config)

     

       343
       343
       +
         in

     

       344
       344
       +
         

     

       345
       345
       +
         (* Connect to server *)

     

       346
       346
       +
         let ctx = Jmap_unix.create_client () in

     

       347
       347
       +
         let result = Jmap_unix.quick_connect ~host ~username:user ~password in

     

       348
       348
       +
         

     

       349
       349
       +
         let (ctx, session) = match result with

     

       350
       350
       +
           | Ok (ctx, session) -> (ctx, session)

     

       351
       351
       +
           | Error e -> 

     

       352
       352
       +
               Printf.eprintf "Connection failed: %s\n" (Jmap.Error.error_to_string e);

     

       353
       353
       +
               exit 1

     

       354
       354
       +
         in

     

       355
       355
       +
         

     

       356
       356
       +
         (* Check vacation capability *)

     

       357
       357
       +
         (* Note: has_capability not available in interface, assuming server supports it *)

     

       358
       358
       +
         

     

       359
       359
       +
         (* Get the primary account ID *)

     

       360
       360
       +
         let account_id = match Jmap.get_primary_account session Jmap_email.capability_mail with

     

       361
       361
       +
           | Ok id -> id

     

       362
       362
       +
           | Error e -> 

     

       363
       363
       +
               Printf.eprintf "No mail account found: %s\n" (Jmap.Error.error_to_string e);

     

       364
       364
       +
               exit 1

     

       365
       365
       +
         in

     

       366
       366
       +
         

     

       367
       367
       +
         (* Process the action *)

     

       368
       368
       +
         process_vacation_action ctx session account_id action

     

       369
       369
       +
       

     

       370
       370
       +
       (* Command definition *)

     

       371
       371
       +
       let vacation_cmd =

     

       372
       372
       +
         let doc = "manage vacation/out-of-office auto-responses" in

     

       373
       373
       +
         let man = [

     

       374
       374
       +
           `S Manpage.s_description;

     

       375
       375
       +
           `P "Manage vacation responses (out-of-office auto-replies) via JMAP.";

     

       376
       376
       +
           `P "Configure automatic email responses for when you're away.";

     

       377
       377
       +
           `S Manpage.s_examples;

     

       378
       378
       +
           `P "Show current vacation settings:";

     

       379
       379
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --show";

     

       380
       380
       +
           `P "";

     

       381
       381
       +
           `P "Enable vacation response:";

     

       382
       382
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --enable \\";

     

       383
       383
       +
           `P "    --subject \"Out of Office\" \\";

     

       384
       384
       +
           `P "    --message \"I am currently out of the office and will return on Monday.\"";

     

       385
       385
       +
           `P "";

     

       386
       386
       +
           `P "Enable with date range:";

     

       387
       387
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --enable \\";

     

       388
       388
       +
           `P "    --message-file vacation.txt \\";

     

       389
       389
       +
           `P "    --from-date 2024-07-01 --to-date 2024-07-15";

     

       390
       390
       +
           `P "";

     

       391
       391
       +
           `P "Disable vacation response:";

     

       392
       392
       +
           `P "  $(mname) -h jmap.example.com -u user@example.com -p secret123 --disable";

     

       393
       393
       +
         ] in

     

       394
       394
       +
         

     

       395
       395
       +
         let cmd =

     

       396
       396
       +
           Cmd.v

     

       397
       397
       +
             (Cmd.info "jmap-vacation-manager" ~version:"1.0" ~doc ~man)

     

       398
       398
       +
             Term.(const vacation_command $ host_arg $ user_arg $ password_arg $ 

     

       399
       399
       +
                   enable_arg $ disable_arg $ show_arg $ subject_arg $ message_arg $

     

       400
       400
       +
                   message_file_arg $ html_message_arg $ from_date_arg $ to_date_arg $

     

       401
       401
       +
                   exclude_arg)

     

       402
       402
       +
         in

     

       403
       403
       +
         cmd

     

       404
       404
       +
       

     

       405
       405
       +
       (* Main entry point *)

     

       406
       406
       +
       let () = exit (Cmd.eval' vacation_cmd)

+1 -22

dune-project

···

       1
       1
       -
       (lang dune 3.17)

     

       2
       2
       -
       (name jmap)

     

       3
       3
       -
       

     

       4
       4
       -
       (source (github avsm/jmap))

     

       5
       5
       -
       (license ISC)

     

       6
       6
       -
       (authors "Anil Madhavapeddy")

     

       7
       7
       -
       (maintainers "anil@recoil.org")

     

       8
       8
       -
       

     

       9
       9
       -
       (generate_opam_files true)

     

       10
       10
       -
       

     

       11
       11
       -
       (package

     

       12
       12
       -
        (name jmap)

     

       13
       13
       -
        (synopsis "JMAP protocol")

     

       14
       14
       -
        (description "This is all still a work in progress")

     

       15
       15
       -
        (depends

     

       16
       16
       -
         (ocaml (>= "5.2.0"))

     

       17
       17
       -
         ptime

     

       18
       18
       -
         cohttp

     

       19
       19
       -
         cohttp-lwt-unix

     

       20
       20
       -
         ezjsonm

     

       21
       21
       -
         uri

     

       22
       22
       -
         lwt))

     

       1
       1
       +
       (lang dune 3.17)

+15

jmap/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name jmap)

     

       3
       3
       +
        (public_name jmap)

     

       4
       4
       +
        (libraries yojson uri)

     

       5
       5
       +
        (modules_without_implementation jmap jmap_binary jmap_error jmap_methods

     

       6
       6
       +
         jmap_push jmap_session jmap_types jmap_wire)

     

       7
       7
       +
        (modules

     

       8
       8
       +
         jmap

     

       9
       9
       +
         jmap_types

     

       10
       10
       +
         jmap_error

     

       11
       11
       +
         jmap_wire

     

       12
       12
       +
         jmap_session

     

       13
       13
       +
         jmap_methods

     

       14
       14
       +
         jmap_binary

     

       15
       15
       +
         jmap_push))

+136

jmap/jmap.mli

···

       1
       1
       +
       (** JMAP Core Protocol Library Interface (RFC 8620)

     

       2
       2
       +
           

     

       3
       3
       +
           This library provides OCaml types and function signatures for interacting

     

       4
       4
       +
           with a JMAP server according to the core protocol specification in RFC 8620.

     

       5
       5
       +
           

     

       6
       6
       +
           Modules:

     

       7
       7
       +
           - {!Jmap.Types}: Basic data types (Id, Date, etc.).

     

       8
       8
       +
           - {!Jmap.Error}: Error types (ProblemDetails, MethodError, SetError).

     

       9
       9
       +
           - {!Jmap.Wire}: Request and Response structures.

     

       10
       10
       +
           - {!Jmap.Session}: Session object and discovery.

     

       11
       11
       +
           - {!Jmap.Methods}: Standard method patterns (/get, /set, etc.) and Core/echo.

     

       12
       12
       +
           - {!Jmap.Binary}: Binary data upload/download types.

     

       13
       13
       +
           - {!Jmap.Push}: Push notification types (StateChange, PushSubscription).

     

       14
       14
       +
           

     

       15
       15
       +
           For email-specific extensions (RFC 8621), see the Jmap_email library.

     

       16
       16
       +
           For Unix-specific implementation, see the Jmap_unix library.

     

       17
       17
       +
           

     

       18
       18
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html> RFC 8620: Core JMAP

     

       19
       19
       +
       *)

     

       20
       20
       +
       

     

       21
       21
       +
       (** {1 Core JMAP Types and Modules} *)

     

       22
       22
       +
       

     

       23
       23
       +
       module Types = Jmap_types

     

       24
       24
       +
       module Error = Jmap_error

     

       25
       25
       +
       module Wire = Jmap_wire

     

       26
       26
       +
       module Session = Jmap_session

     

       27
       27
       +
       module Methods = Jmap_methods

     

       28
       28
       +
       module Binary = Jmap_binary

     

       29
       29
       +
       module Push = Jmap_push

     

       30
       30
       +
       

     

       31
       31
       +
       (** {1 Example Usage} 

     

       32
       32
       +
       

     

       33
       33
       +
           The following example demonstrates using the Core JMAP library with the Unix implementation

     

       34
       34
       +
           to make a simple echo request.

     

       35
       35
       +
       

     

       36
       36
       +
       {[ 

     

       37
       37
       +
         (* OCaml 5.1 required for Lwt let operators *) 

     

       38
       38
       +
         open Lwt.Syntax 

     

       39
       39
       +
         open Jmap 

     

       40
       40
       +
         open Jmap.Types 

     

       41
       41
       +
         open Jmap.Wire 

     

       42
       42
       +
         open Jmap.Methods

     

       43
       43
       +
         open Jmap.Unix

     

       44
       44
       +
         

     

       45
       45
       +
         let simple_echo_request ctx session = 

     

       46
       46
       +
           (* Prepare an echo invocation *) 

     

       47
       47
       +
           let echo_args = Yojson.Safe.to_basic (`Assoc [

     

       48
       48
       +
             ("hello", `String "world");

     

       49
       49
       +
             ("array", `List [`Int 1; `Int 2; `Int 3]);

     

       50
       50
       +
           ]) in

     

       51
       51
       +
           

     

       52
       52
       +
           let echo_invocation = Invocation.v 

     

       53
       53
       +
             ~method_name:"Core/echo"

     

       54
       54
       +
             ~arguments:echo_args

     

       55
       55
       +
             ~method_call_id:"echo1"

     

       56
       56
       +
             ()

     

       57
       57
       +
           in

     

       58
       58
       +
       

     

       59
       59
       +
           (* Prepare the JMAP request *) 

     

       60
       60
       +
           let request = Request.v

     

       61
       61
       +
             ~using:[capability_core]

     

       62
       62
       +
             ~method_calls:[echo_invocation]

     

       63
       63
       +
             ()

     

       64
       64
       +
           in

     

       65
       65
       +
       

     

       66
       66
       +
           (* Send the request *) 

     

       67
       67
       +
           let* response = Jmap.Unix.request ctx request in

     

       68
       68
       +
       

     

       69
       69
       +
           (* Process the response *) 

     

       70
       70
       +
           match Wire.find_method_response response "echo1" with

     

       71
       71
       +
           | Some (method_name, args, _) when method_name = "Core/echo" ->

     

       72
       72
       +
               (* Echo response should contain the same arguments we sent *)

     

       73
       73
       +
               let hello_value = match Yojson.Safe.Util.member "hello" args with

     

       74
       74
       +
                 | `String s -> s

     

       75
       75
       +
                 | _ -> "not found"

     

       76
       76
       +
               in

     

       77
       77
       +
               Printf.printf "Echo response received: hello=%s\n" hello_value;

     

       78
       78
       +
               Lwt.return_unit

     

       79
       79
       +
           | _ ->

     

       80
       80
       +
               Printf.eprintf "Echo response not found or unexpected format\n";

     

       81
       81
       +
               Lwt.return_unit

     

       82
       82
       +
       

     

       83
       83
       +
         let main () = 

     

       84
       84
       +
           (* Authentication details are placeholder *) 

     

       85
       85
       +
           let credentials = "my_auth_token" in 

     

       86
       86
       +
           let* (ctx, session) = Jmap.Unix.connect ~host:"jmap.example.com" ~credentials in 

     

       87
       87
       +
           let* () = simple_echo_request ctx session in 

     

       88
       88
       +
           Jmap.Unix.close ctx 

     

       89
       89
       +
       

     

       90
       90
       +
         (* Lwt_main.run (main ()) *) 

     

       91
       91
       +
       ]} 

     

       92
       92
       +
       *)

     

       93
       93
       +
       

     

       94
       94
       +
       (** Capability URI for JMAP Core.

     

       95
       95
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       96
       96
       +
       val capability_core : string

     

       97
       97
       +
       

     

       98
       98
       +
       (** {1 Convenience Functions} *)

     

       99
       99
       +
       

     

       100
       100
       +
       (** Check if a session supports a given capability.

     

       101
       101
       +
           @param session The session object.

     

       102
       102
       +
           @param capability The capability URI to check.

     

       103
       103
       +
           @return True if supported, false otherwise.

     

       104
       104
       +
       *)

     

       105
       105
       +
       val supports_capability : Jmap_session.Session.t -> string -> bool

     

       106
       106
       +
       

     

       107
       107
       +
       (** Get the primary account ID for a given capability.

     

       108
       108
       +
           @param session The session object.

     

       109
       109
       +
           @param capability The capability URI.

     

       110
       110
       +
           @return The account ID or an error if not found.

     

       111
       111
       +
       *)

     

       112
       112
       +
       val get_primary_account : Jmap_session.Session.t -> string -> (Jmap_types.id, Error.error) result

     

       113
       113
       +
       

     

       114
       114
       +
       (** Get the download URL for a blob.

     

       115
       115
       +
           @param session The session object.

     

       116
       116
       +
           @param account_id The account ID.

     

       117
       117
       +
           @param blob_id The blob ID.

     

       118
       118
       +
           @param ?name Optional filename for the download.

     

       119
       119
       +
           @param ?content_type Optional content type for the download.

     

       120
       120
       +
           @return The download URL.

     

       121
       121
       +
       *)

     

       122
       122
       +
       val get_download_url : 

     

       123
       123
       +
         Jmap_session.Session.t -> 

     

       124
       124
       +
         account_id:Jmap_types.id -> 

     

       125
       125
       +
         blob_id:Jmap_types.id -> 

     

       126
       126
       +
         ?name:string -> 

     

       127
       127
       +
         ?content_type:string -> 

     

       128
       128
       +
         unit ->

     

       129
       129
       +
         Uri.t

     

       130
       130
       +
       

     

       131
       131
       +
       (** Get the upload URL for a blob.

     

       132
       132
       +
           @param session The session object.

     

       133
       133
       +
           @param account_id The account ID.

     

       134
       134
       +
           @return The upload URL.

     

       135
       135
       +
       *)

     

       136
       136
       +
       val get_upload_url : Jmap_session.Session.t -> account_id:Jmap_types.id -> Uri.t

+60

jmap/jmap_binary.mli

···

       1
       1
       +
       (** JMAP Binary Data Handling.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-6> RFC 8620, Section 6 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap_types

     

       5
       5
       +
       open Jmap_error

     

       6
       6
       +
       

     

       7
       7
       +
       (** Response from uploading binary data.

     

       8
       8
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-6.1> RFC 8620, Section 6.1 *)

     

       9
       9
       +
       module Upload_response : sig

     

       10
       10
       +
         type t

     

       11
       11
       +
         

     

       12
       12
       +
         val account_id : t -> id

     

       13
       13
       +
         val blob_id : t -> id

     

       14
       14
       +
         val type_ : t -> string

     

       15
       15
       +
         val size : t -> uint

     

       16
       16
       +
         

     

       17
       17
       +
         val v :

     

       18
       18
       +
           account_id:id ->

     

       19
       19
       +
           blob_id:id ->

     

       20
       20
       +
           type_:string ->

     

       21
       21
       +
           size:uint ->

     

       22
       22
       +
           unit ->

     

       23
       23
       +
           t

     

       24
       24
       +
       end

     

       25
       25
       +
       

     

       26
       26
       +
       (** Arguments for Blob/copy.

     

       27
       27
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-6.3> RFC 8620, Section 6.3 *)

     

       28
       28
       +
       module Blob_copy_args : sig

     

       29
       29
       +
         type t

     

       30
       30
       +
         

     

       31
       31
       +
         val from_account_id : t -> id

     

       32
       32
       +
         val account_id : t -> id

     

       33
       33
       +
         val blob_ids : t -> id list

     

       34
       34
       +
         

     

       35
       35
       +
         val v :

     

       36
       36
       +
           from_account_id:id ->

     

       37
       37
       +
           account_id:id ->

     

       38
       38
       +
           blob_ids:id list ->

     

       39
       39
       +
           unit ->

     

       40
       40
       +
           t

     

       41
       41
       +
       end

     

       42
       42
       +
       

     

       43
       43
       +
       (** Response for Blob/copy.

     

       44
       44
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-6.3> RFC 8620, Section 6.3 *)

     

       45
       45
       +
       module Blob_copy_response : sig

     

       46
       46
       +
         type t

     

       47
       47
       +
         

     

       48
       48
       +
         val from_account_id : t -> id

     

       49
       49
       +
         val account_id : t -> id

     

       50
       50
       +
         val copied : t -> id id_map option

     

       51
       51
       +
         val not_copied : t -> Set_error.t id_map option

     

       52
       52
       +
         

     

       53
       53
       +
         val v :

     

       54
       54
       +
           from_account_id:id ->

     

       55
       55
       +
           account_id:id ->

     

       56
       56
       +
           ?copied:id id_map ->

     

       57
       57
       +
           ?not_copied:Set_error.t id_map ->

     

       58
       58
       +
           unit ->

     

       59
       59
       +
           t

     

       60
       60
       +
       end

+189

jmap/jmap_error.mli

···

       1
       1
       +
       (** JMAP Error Types.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6> RFC 8620, Section 3.6 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap_types

     

       5
       5
       +
       

     

       6
       6
       +
       (** Standard Method-level error types.

     

       7
       7
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6.2> RFC 8620, Section 3.6.2 *)

     

       8
       8
       +
       type method_error_type = [

     

       9
       9
       +
         | `ServerUnavailable

     

       10
       10
       +
         | `ServerFail

     

       11
       11
       +
         | `ServerPartialFail

     

       12
       12
       +
         | `UnknownMethod

     

       13
       13
       +
         | `InvalidArguments

     

       14
       14
       +
         | `InvalidResultReference

     

       15
       15
       +
         | `Forbidden

     

       16
       16
       +
         | `AccountNotFound

     

       17
       17
       +
         | `AccountNotSupportedByMethod

     

       18
       18
       +
         | `AccountReadOnly

     

       19
       19
       +
         | `RequestTooLarge

     

       20
       20
       +
         | `CannotCalculateChanges

     

       21
       21
       +
         | `StateMismatch

     

       22
       22
       +
         | `AnchorNotFound

     

       23
       23
       +
         | `UnsupportedSort

     

       24
       24
       +
         | `UnsupportedFilter

     

       25
       25
       +
         | `TooManyChanges

     

       26
       26
       +
         | `FromAccountNotFound

     

       27
       27
       +
         | `FromAccountNotSupportedByMethod

     

       28
       28
       +
         | `Other_method_error of string

     

       29
       29
       +
       ]

     

       30
       30
       +
       

     

       31
       31
       +
       (** Standard SetError types.

     

       32
       32
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.3> RFC 8620, Section 5.3 *)

     

       33
       33
       +
       type set_error_type = [

     

       34
       34
       +
         | `Forbidden

     

       35
       35
       +
         | `OverQuota

     

       36
       36
       +
         | `TooLarge

     

       37
       37
       +
         | `RateLimit

     

       38
       38
       +
         | `NotFound

     

       39
       39
       +
         | `InvalidPatch

     

       40
       40
       +
         | `WillDestroy

     

       41
       41
       +
         | `InvalidProperties

     

       42
       42
       +
         | `Singleton

     

       43
       43
       +
         | `AlreadyExists (* From /copy *)

     

       44
       44
       +
         | `MailboxHasChild (* RFC 8621 *)

     

       45
       45
       +
         | `MailboxHasEmail (* RFC 8621 *)

     

       46
       46
       +
         | `BlobNotFound (* RFC 8621 *)

     

       47
       47
       +
         | `TooManyKeywords (* RFC 8621 *)

     

       48
       48
       +
         | `TooManyMailboxes (* RFC 8621 *)

     

       49
       49
       +
         | `InvalidEmail (* RFC 8621 *)

     

       50
       50
       +
         | `TooManyRecipients (* RFC 8621 *)

     

       51
       51
       +
         | `NoRecipients (* RFC 8621 *)

     

       52
       52
       +
         | `InvalidRecipients (* RFC 8621 *)

     

       53
       53
       +
         | `ForbiddenMailFrom (* RFC 8621 *)

     

       54
       54
       +
         | `ForbiddenFrom (* RFC 8621 *)

     

       55
       55
       +
         | `ForbiddenToSend (* RFC 8621 *)

     

       56
       56
       +
         | `CannotUnsend (* RFC 8621 *)

     

       57
       57
       +
         | `Other_set_error of string (* For future or custom errors *)

     

       58
       58
       +
       ]

     

       59
       59
       +
       

     

       60
       60
       +
       (** Primary error type that can represent all JMAP errors *)

     

       61
       61
       +
       type error =

     

       62
       62
       +
         | Transport of string     (** Network/HTTP-level error *)

     

       63
       63
       +
         | Parse of string         (** JSON parsing error *)

     

       64
       64
       +
         | Protocol of string      (** JMAP protocol error *)

     

       65
       65
       +
         | Problem of string       (** Problem Details object error *)

     

       66
       66
       +
         | Method of method_error_type * string option (** Method error with optional description *)

     

       67
       67
       +
         | SetItem of id * set_error_type * string option (** Error for a specific item in a /set operation *)

     

       68
       68
       +
         | Auth of string          (** Authentication error *)

     

       69
       69
       +
         | ServerError of string   (** Server reported an error *)

     

       70
       70
       +
       

     

       71
       71
       +
       (** Standard Result type for JMAP operations *)

     

       72
       72
       +
       type 'a result = ('a, error) Result.t

     

       73
       73
       +
       

     

       74
       74
       +
       (** Problem details object for HTTP-level errors.

     

       75
       75
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6.1> RFC 8620, Section 3.6.1

     

       76
       76
       +
           @see <https://www.rfc-editor.org/rfc/rfc7807.html> RFC 7807 *)

     

       77
       77
       +
       module Problem_details : sig

     

       78
       78
       +
         type t

     

       79
       79
       +
       

     

       80
       80
       +
         val problem_type : t -> string

     

       81
       81
       +
         val status : t -> int option

     

       82
       82
       +
         val detail : t -> string option

     

       83
       83
       +
         val limit : t -> string option

     

       84
       84
       +
         val other_fields : t -> Yojson.Safe.t string_map

     

       85
       85
       +
         

     

       86
       86
       +
         val v : 

     

       87
       87
       +
           ?status:int ->

     

       88
       88
       +
           ?detail:string ->

     

       89
       89
       +
           ?limit:string ->

     

       90
       90
       +
           ?other_fields:Yojson.Safe.t string_map ->

     

       91
       91
       +
           string ->

     

       92
       92
       +
           t

     

       93
       93
       +
       end

     

       94
       94
       +
       

     

       95
       95
       +
       (** Description for method errors. May contain additional details.

     

       96
       96
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6.2> RFC 8620, Section 3.6.2 *)

     

       97
       97
       +
       module Method_error_description : sig

     

       98
       98
       +
         type t

     

       99
       99
       +
         

     

       100
       100
       +
         val description : t -> string option

     

       101
       101
       +
         

     

       102
       102
       +
         val v : ?description:string -> unit -> t

     

       103
       103
       +
       end

     

       104
       104
       +
       

     

       105
       105
       +
       (** Represents a method-level error response invocation part.

     

       106
       106
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6.2> RFC 8620, Section 3.6.2 *)

     

       107
       107
       +
       module Method_error : sig

     

       108
       108
       +
         type t

     

       109
       109
       +
         

     

       110
       110
       +
         val type_ : t -> method_error_type

     

       111
       111
       +
         val description : t -> Method_error_description.t option

     

       112
       112
       +
         

     

       113
       113
       +
         val v : 

     

       114
       114
       +
           ?description:Method_error_description.t ->

     

       115
       115
       +
           method_error_type ->

     

       116
       116
       +
           t

     

       117
       117
       +
       end

     

       118
       118
       +
       

     

       119
       119
       +
       (** SetError object.

     

       120
       120
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.3> RFC 8620, Section 5.3 *)

     

       121
       121
       +
       module Set_error : sig

     

       122
       122
       +
         type t

     

       123
       123
       +
         

     

       124
       124
       +
         val type_ : t -> set_error_type

     

       125
       125
       +
         val description : t -> string option

     

       126
       126
       +
         val properties : t -> string list option

     

       127
       127
       +
         val existing_id : t -> id option

     

       128
       128
       +
         val max_recipients : t -> uint option

     

       129
       129
       +
         val invalid_recipients : t -> string list option

     

       130
       130
       +
         val max_size : t -> uint option

     

       131
       131
       +
         val not_found_blob_ids : t -> id list option

     

       132
       132
       +
         

     

       133
       133
       +
         val v :

     

       134
       134
       +
           ?description:string ->

     

       135
       135
       +
           ?properties:string list ->

     

       136
       136
       +
           ?existing_id:id ->

     

       137
       137
       +
           ?max_recipients:uint ->

     

       138
       138
       +
           ?invalid_recipients:string list ->

     

       139
       139
       +
           ?max_size:uint ->

     

       140
       140
       +
           ?not_found_blob_ids:id list ->

     

       141
       141
       +
           set_error_type ->

     

       142
       142
       +
           t

     

       143
       143
       +
       end

     

       144
       144
       +
       

     

       145
       145
       +
       (** {2 Error Handling Functions} *)

     

       146
       146
       +
       

     

       147
       147
       +
       (** Create a transport error *)

     

       148
       148
       +
       val transport_error : string -> error

     

       149
       149
       +
       

     

       150
       150
       +
       (** Create a parse error *)

     

       151
       151
       +
       val parse_error : string -> error

     

       152
       152
       +
       

     

       153
       153
       +
       (** Create a protocol error *)

     

       154
       154
       +
       val protocol_error : string -> error 

     

       155
       155
       +
       

     

       156
       156
       +
       (** Create a problem details error *)

     

       157
       157
       +
       val problem_error : Problem_details.t -> error

     

       158
       158
       +
       

     

       159
       159
       +
       (** Create a method error *)

     

       160
       160
       +
       val method_error : ?description:string -> method_error_type -> error

     

       161
       161
       +
       

     

       162
       162
       +
       (** Create a SetItem error *)

     

       163
       163
       +
       val set_item_error : id -> ?description:string -> set_error_type -> error

     

       164
       164
       +
       

     

       165
       165
       +
       (** Create an auth error *)

     

       166
       166
       +
       val auth_error : string -> error

     

       167
       167
       +
       

     

       168
       168
       +
       (** Create a server error *)

     

       169
       169
       +
       val server_error : string -> error

     

       170
       170
       +
       

     

       171
       171
       +
       (** Convert a Method_error.t to error *)

     

       172
       172
       +
       val of_method_error : Method_error.t -> error

     

       173
       173
       +
       

     

       174
       174
       +
       (** Convert a Set_error.t to error for a specific ID *)

     

       175
       175
       +
       val of_set_error : id -> Set_error.t -> error

     

       176
       176
       +
       

     

       177
       177
       +
       (** Get a human-readable description of an error *)

     

       178
       178
       +
       val error_to_string : error -> string

     

       179
       179
       +
       

     

       180
       180
       +
       (** {2 Result Handling} *)

     

       181
       181
       +
       

     

       182
       182
       +
       (** Map an error with additional context *)

     

       183
       183
       +
       val map_error : 'a result -> (error -> error) -> 'a result

     

       184
       184
       +
       

     

       185
       185
       +
       (** Add context to an error *)

     

       186
       186
       +
       val with_context : 'a result -> string -> 'a result

     

       187
       187
       +
       

     

       188
       188
       +
       (** Convert an option to a result with an error for None *)

     

       189
       189
       +
       val of_option : 'a option -> error -> 'a result

+417

jmap/jmap_methods.mli

···

       1
       1
       +
       (** Standard JMAP Methods and Core/echo.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-4> RFC 8620, Section 4

     

       3
       3
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5> RFC 8620, Section 5 *)

     

       4
       4
       +
       

     

       5
       5
       +
       open Jmap_types

     

       6
       6
       +
       open Jmap_error

     

       7
       7
       +
       

     

       8
       8
       +
       (** Generic representation of a record type. Actual types defined elsewhere. *)

     

       9
       9
       +
       type generic_record

     

       10
       10
       +
       

     

       11
       11
       +
       (** Arguments for /get methods.

     

       12
       12
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.1> RFC 8620, Section 5.1 *)

     

       13
       13
       +
       module Get_args : sig

     

       14
       14
       +
         type 'record t

     

       15
       15
       +
         

     

       16
       16
       +
         val account_id : 'record t -> id

     

       17
       17
       +
         val ids : 'record t -> id list option

     

       18
       18
       +
         val properties : 'record t -> string list option

     

       19
       19
       +
         

     

       20
       20
       +
         val v :

     

       21
       21
       +
           account_id:id ->

     

       22
       22
       +
           ?ids:id list ->

     

       23
       23
       +
           ?properties:string list ->

     

       24
       24
       +
           unit ->

     

       25
       25
       +
           'record t

     

       26
       26
       +
       end

     

       27
       27
       +
       

     

       28
       28
       +
       (** Response for /get methods.

     

       29
       29
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.1> RFC 8620, Section 5.1 *)

     

       30
       30
       +
       module Get_response : sig

     

       31
       31
       +
         type 'record t

     

       32
       32
       +
         

     

       33
       33
       +
         val account_id : 'record t -> id

     

       34
       34
       +
         val state : 'record t -> string

     

       35
       35
       +
         val list : 'record t -> 'record list

     

       36
       36
       +
         val not_found : 'record t -> id list

     

       37
       37
       +
         

     

       38
       38
       +
         val v :

     

       39
       39
       +
           account_id:id ->

     

       40
       40
       +
           state:string ->

     

       41
       41
       +
           list:'record list ->

     

       42
       42
       +
           not_found:id list ->

     

       43
       43
       +
           unit ->

     

       44
       44
       +
           'record t

     

       45
       45
       +
       end

     

       46
       46
       +
       

     

       47
       47
       +
       (** Arguments for /changes methods.

     

       48
       48
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.2> RFC 8620, Section 5.2 *)

     

       49
       49
       +
       module Changes_args : sig

     

       50
       50
       +
         type t

     

       51
       51
       +
         

     

       52
       52
       +
         val account_id : t -> id

     

       53
       53
       +
         val since_state : t -> string

     

       54
       54
       +
         val max_changes : t -> uint option

     

       55
       55
       +
         

     

       56
       56
       +
         val v :

     

       57
       57
       +
           account_id:id ->

     

       58
       58
       +
           since_state:string ->

     

       59
       59
       +
           ?max_changes:uint ->

     

       60
       60
       +
           unit ->

     

       61
       61
       +
           t

     

       62
       62
       +
       end

     

       63
       63
       +
       

     

       64
       64
       +
       (** Response for /changes methods.

     

       65
       65
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.2> RFC 8620, Section 5.2 *)

     

       66
       66
       +
       module Changes_response : sig

     

       67
       67
       +
         type t

     

       68
       68
       +
         

     

       69
       69
       +
         val account_id : t -> id

     

       70
       70
       +
         val old_state : t -> string

     

       71
       71
       +
         val new_state : t -> string

     

       72
       72
       +
         val has_more_changes : t -> bool

     

       73
       73
       +
         val created : t -> id list

     

       74
       74
       +
         val updated : t -> id list

     

       75
       75
       +
         val destroyed : t -> id list

     

       76
       76
       +
         val updated_properties : t -> string list option

     

       77
       77
       +
         

     

       78
       78
       +
         val v :

     

       79
       79
       +
           account_id:id ->

     

       80
       80
       +
           old_state:string ->

     

       81
       81
       +
           new_state:string ->

     

       82
       82
       +
           has_more_changes:bool ->

     

       83
       83
       +
           created:id list ->

     

       84
       84
       +
           updated:id list ->

     

       85
       85
       +
           destroyed:id list ->

     

       86
       86
       +
           ?updated_properties:string list ->

     

       87
       87
       +
           unit ->

     

       88
       88
       +
           t

     

       89
       89
       +
       end

     

       90
       90
       +
       

     

       91
       91
       +
       (** Patch object for /set update.

     

       92
       92
       +
           A list of (JSON Pointer path, value) pairs.

     

       93
       93
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.3> RFC 8620, Section 5.3 *)

     

       94
       94
       +
       type patch_object = (json_pointer * Yojson.Safe.t) list

     

       95
       95
       +
       

     

       96
       96
       +
       (** Arguments for /set methods.

     

       97
       97
       +
           ['create_record] is the record type without server-set/immutable fields.

     

       98
       98
       +
           ['update_record] is the patch object type (usually [patch_object]).

     

       99
       99
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.3> RFC 8620, Section 5.3 *)

     

       100
       100
       +
       module Set_args : sig

     

       101
       101
       +
         type ('create_record, 'update_record) t

     

       102
       102
       +
         

     

       103
       103
       +
         val account_id : ('a, 'b) t -> id

     

       104
       104
       +
         val if_in_state : ('a, 'b) t -> string option

     

       105
       105
       +
         val create : ('a, 'b) t -> 'a id_map option

     

       106
       106
       +
         val update : ('a, 'b) t -> 'b id_map option

     

       107
       107
       +
         val destroy : ('a, 'b) t -> id list option

     

       108
       108
       +
         val on_success_destroy_original : ('a, 'b) t -> bool option

     

       109
       109
       +
         val destroy_from_if_in_state : ('a, 'b) t -> string option

     

       110
       110
       +
         val on_destroy_remove_emails : ('a, 'b) t -> bool option

     

       111
       111
       +
         

     

       112
       112
       +
         val v :

     

       113
       113
       +
           account_id:id ->

     

       114
       114
       +
           ?if_in_state:string ->

     

       115
       115
       +
           ?create:'a id_map ->

     

       116
       116
       +
           ?update:'b id_map ->

     

       117
       117
       +
           ?destroy:id list ->

     

       118
       118
       +
           ?on_success_destroy_original:bool ->

     

       119
       119
       +
           ?destroy_from_if_in_state:string ->

     

       120
       120
       +
           ?on_destroy_remove_emails:bool ->

     

       121
       121
       +
           unit ->

     

       122
       122
       +
           ('a, 'b) t

     

       123
       123
       +
       end

     

       124
       124
       +
       

     

       125
       125
       +
       (** Response for /set methods.

     

       126
       126
       +
           ['created_record_info] is the server-set info for created records.

     

       127
       127
       +
           ['updated_record_info] is the server-set/computed info for updated records.

     

       128
       128
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.3> RFC 8620, Section 5.3 *)

     

       129
       129
       +
       module Set_response : sig

     

       130
       130
       +
         type ('created_record_info, 'updated_record_info) t

     

       131
       131
       +
         

     

       132
       132
       +
         val account_id : ('a, 'b) t -> id

     

       133
       133
       +
         val old_state : ('a, 'b) t -> string option

     

       134
       134
       +
         val new_state : ('a, 'b) t -> string

     

       135
       135
       +
         val created : ('a, 'b) t -> 'a id_map option

     

       136
       136
       +
         val updated : ('a, 'b) t -> 'b option id_map option

     

       137
       137
       +
         val destroyed : ('a, 'b) t -> id list option

     

       138
       138
       +
         val not_created : ('a, 'b) t -> Set_error.t id_map option

     

       139
       139
       +
         val not_updated : ('a, 'b) t -> Set_error.t id_map option

     

       140
       140
       +
         val not_destroyed : ('a, 'b) t -> Set_error.t id_map option

     

       141
       141
       +
         

     

       142
       142
       +
         val v :

     

       143
       143
       +
           account_id:id ->

     

       144
       144
       +
           ?old_state:string ->

     

       145
       145
       +
           new_state:string ->

     

       146
       146
       +
           ?created:'a id_map ->

     

       147
       147
       +
           ?updated:'b option id_map ->

     

       148
       148
       +
           ?destroyed:id list ->

     

       149
       149
       +
           ?not_created:Set_error.t id_map ->

     

       150
       150
       +
           ?not_updated:Set_error.t id_map ->

     

       151
       151
       +
           ?not_destroyed:Set_error.t id_map ->

     

       152
       152
       +
           unit ->

     

       153
       153
       +
           ('a, 'b) t

     

       154
       154
       +
       end

     

       155
       155
       +
       

     

       156
       156
       +
       (** Arguments for /copy methods.

     

       157
       157
       +
           ['copy_record_override] contains the record id and override properties.

     

       158
       158
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.4> RFC 8620, Section 5.4 *)

     

       159
       159
       +
       module Copy_args : sig

     

       160
       160
       +
         type 'copy_record_override t

     

       161
       161
       +
         

     

       162
       162
       +
         val from_account_id : 'a t -> id

     

       163
       163
       +
         val if_from_in_state : 'a t -> string option

     

       164
       164
       +
         val account_id : 'a t -> id

     

       165
       165
       +
         val if_in_state : 'a t -> string option

     

       166
       166
       +
         val create : 'a t -> 'a id_map

     

       167
       167
       +
         val on_success_destroy_original : 'a t -> bool

     

       168
       168
       +
         val destroy_from_if_in_state : 'a t -> string option

     

       169
       169
       +
         

     

       170
       170
       +
         val v :

     

       171
       171
       +
           from_account_id:id ->

     

       172
       172
       +
           ?if_from_in_state:string ->

     

       173
       173
       +
           account_id:id ->

     

       174
       174
       +
           ?if_in_state:string ->

     

       175
       175
       +
           create:'a id_map ->

     

       176
       176
       +
           ?on_success_destroy_original:bool ->

     

       177
       177
       +
           ?destroy_from_if_in_state:string ->

     

       178
       178
       +
           unit ->

     

       179
       179
       +
           'a t

     

       180
       180
       +
       end

     

       181
       181
       +
       

     

       182
       182
       +
       (** Response for /copy methods.

     

       183
       183
       +
           ['created_record_info] is the server-set info for the created copy.

     

       184
       184
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.4> RFC 8620, Section 5.4 *)

     

       185
       185
       +
       module Copy_response : sig

     

       186
       186
       +
         type 'created_record_info t

     

       187
       187
       +
         

     

       188
       188
       +
         val from_account_id : 'a t -> id

     

       189
       189
       +
         val account_id : 'a t -> id

     

       190
       190
       +
         val old_state : 'a t -> string option

     

       191
       191
       +
         val new_state : 'a t -> string

     

       192
       192
       +
         val created : 'a t -> 'a id_map option

     

       193
       193
       +
         val not_created : 'a t -> Set_error.t id_map option

     

       194
       194
       +
         

     

       195
       195
       +
         val v :

     

       196
       196
       +
           from_account_id:id ->

     

       197
       197
       +
           account_id:id ->

     

       198
       198
       +
           ?old_state:string ->

     

       199
       199
       +
           new_state:string ->

     

       200
       200
       +
           ?created:'a id_map ->

     

       201
       201
       +
           ?not_created:Set_error.t id_map ->

     

       202
       202
       +
           unit ->

     

       203
       203
       +
           'a t

     

       204
       204
       +
       end

     

       205
       205
       +
       

     

       206
       206
       +
       (** Module for generic filter representation.

     

       207
       207
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.5> RFC 8620, Section 5.5 *)

     

       208
       208
       +
       module Filter : sig

     

       209
       209
       +
         type t

     

       210
       210
       +
         

     

       211
       211
       +
         (** Create a filter from a raw JSON condition *)

     

       212
       212
       +
         val condition : Yojson.Safe.t -> t

     

       213
       213
       +
         

     

       214
       214
       +
         (** Create a filter with a logical operator (AND, OR, NOT) *)

     

       215
       215
       +
         val operator : [ `AND | `OR | `NOT ] -> t list -> t

     

       216
       216
       +
         

     

       217
       217
       +
         (** Combine filters with AND *)

     

       218
       218
       +
         val and_ : t list -> t

     

       219
       219
       +
         

     

       220
       220
       +
         (** Combine filters with OR *)

     

       221
       221
       +
         val or_ : t list -> t

     

       222
       222
       +
         

     

       223
       223
       +
         (** Negate a filter with NOT *)

     

       224
       224
       +
         val not_ : t -> t

     

       225
       225
       +
         

     

       226
       226
       +
         (** Convert a filter to JSON *)

     

       227
       227
       +
         val to_json : t -> Yojson.Safe.t

     

       228
       228
       +
         

     

       229
       229
       +
         (** Predefined filter helpers *)

     

       230
       230
       +
         

     

       231
       231
       +
         (** Create a filter for a text property containing a string *)

     

       232
       232
       +
         val text_contains : string -> string -> t

     

       233
       233
       +
         

     

       234
       234
       +
         (** Create a filter for a property being equal to a value *)

     

       235
       235
       +
         val property_equals : string -> Yojson.Safe.t -> t

     

       236
       236
       +
         

     

       237
       237
       +
         (** Create a filter for a property being not equal to a value *)

     

       238
       238
       +
         val property_not_equals : string -> Yojson.Safe.t -> t

     

       239
       239
       +
         

     

       240
       240
       +
         (** Create a filter for a property being greater than a value *)

     

       241
       241
       +
         val property_gt : string -> Yojson.Safe.t -> t

     

       242
       242
       +
         

     

       243
       243
       +
         (** Create a filter for a property being greater than or equal to a value *)

     

       244
       244
       +
         val property_ge : string -> Yojson.Safe.t -> t

     

       245
       245
       +
         

     

       246
       246
       +
         (** Create a filter for a property being less than a value *)

     

       247
       247
       +
         val property_lt : string -> Yojson.Safe.t -> t

     

       248
       248
       +
         

     

       249
       249
       +
         (** Create a filter for a property being less than or equal to a value *)

     

       250
       250
       +
         val property_le : string -> Yojson.Safe.t -> t

     

       251
       251
       +
         

     

       252
       252
       +
         (** Create a filter for a property value being in a list *)

     

       253
       253
       +
         val property_in : string -> Yojson.Safe.t list -> t

     

       254
       254
       +
         

     

       255
       255
       +
         (** Create a filter for a property value not being in a list *)

     

       256
       256
       +
         val property_not_in : string -> Yojson.Safe.t list -> t

     

       257
       257
       +
         

     

       258
       258
       +
         (** Create a filter for a property being present (not null) *)

     

       259
       259
       +
         val property_exists : string -> t

     

       260
       260
       +
         

     

       261
       261
       +
         (** Create a filter for a string property starting with a prefix *)

     

       262
       262
       +
         val string_starts_with : string -> string -> t

     

       263
       263
       +
         

     

       264
       264
       +
         (** Create a filter for a string property ending with a suffix *)

     

       265
       265
       +
         val string_ends_with : string -> string -> t

     

       266
       266
       +
       end

     

       267
       267
       +
       

     

       268
       268
       +
       

     

       269
       269
       +
       

     

       270
       270
       +
       (** Comparator for sorting.

     

       271
       271
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.5> RFC 8620, Section 5.5 *)

     

       272
       272
       +
       module Comparator : sig

     

       273
       273
       +
         type t

     

       274
       274
       +
         

     

       275
       275
       +
         val property : t -> string

     

       276
       276
       +
         val is_ascending : t -> bool option

     

       277
       277
       +
         val collation : t -> string option

     

       278
       278
       +
         val keyword : t -> string option

     

       279
       279
       +
         val other_fields : t -> Yojson.Safe.t string_map

     

       280
       280
       +
         

     

       281
       281
       +
         val v :

     

       282
       282
       +
           property:string ->

     

       283
       283
       +
           ?is_ascending:bool ->

     

       284
       284
       +
           ?collation:string ->

     

       285
       285
       +
           ?keyword:string ->

     

       286
       286
       +
           ?other_fields:Yojson.Safe.t string_map ->

     

       287
       287
       +
           unit ->

     

       288
       288
       +
           t

     

       289
       289
       +
       end

     

       290
       290
       +
       

     

       291
       291
       +
       (** Arguments for /query methods.

     

       292
       292
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.5> RFC 8620, Section 5.5 *)

     

       293
       293
       +
       module Query_args : sig

     

       294
       294
       +
         type t

     

       295
       295
       +
         

     

       296
       296
       +
         val account_id : t -> id

     

       297
       297
       +
         val filter : t -> Filter.t option

     

       298
       298
       +
         val sort : t -> Comparator.t list option

     

       299
       299
       +
         val position : t -> jint option

     

       300
       300
       +
         val anchor : t -> id option

     

       301
       301
       +
         val anchor_offset : t -> jint option

     

       302
       302
       +
         val limit : t -> uint option

     

       303
       303
       +
         val calculate_total : t -> bool option

     

       304
       304
       +
         val collapse_threads : t -> bool option

     

       305
       305
       +
         val sort_as_tree : t -> bool option

     

       306
       306
       +
         val filter_as_tree : t -> bool option

     

       307
       307
       +
         

     

       308
       308
       +
         val v :

     

       309
       309
       +
           account_id:id ->

     

       310
       310
       +
           ?filter:Filter.t ->

     

       311
       311
       +
           ?sort:Comparator.t list ->

     

       312
       312
       +
           ?position:jint ->

     

       313
       313
       +
           ?anchor:id ->

     

       314
       314
       +
           ?anchor_offset:jint ->

     

       315
       315
       +
           ?limit:uint ->

     

       316
       316
       +
           ?calculate_total:bool ->

     

       317
       317
       +
           ?collapse_threads:bool ->

     

       318
       318
       +
           ?sort_as_tree:bool ->

     

       319
       319
       +
           ?filter_as_tree:bool ->

     

       320
       320
       +
           unit ->

     

       321
       321
       +
           t

     

       322
       322
       +
       end

     

       323
       323
       +
       

     

       324
       324
       +
       (** Response for /query methods.

     

       325
       325
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.5> RFC 8620, Section 5.5 *)

     

       326
       326
       +
       module Query_response : sig

     

       327
       327
       +
         type t

     

       328
       328
       +
         

     

       329
       329
       +
         val account_id : t -> id

     

       330
       330
       +
         val query_state : t -> string

     

       331
       331
       +
         val can_calculate_changes : t -> bool

     

       332
       332
       +
         val position : t -> uint

     

       333
       333
       +
         val ids : t -> id list

     

       334
       334
       +
         val total : t -> uint option

     

       335
       335
       +
         val limit : t -> uint option

     

       336
       336
       +
         

     

       337
       337
       +
         val v :

     

       338
       338
       +
           account_id:id ->

     

       339
       339
       +
           query_state:string ->

     

       340
       340
       +
           can_calculate_changes:bool ->

     

       341
       341
       +
           position:uint ->

     

       342
       342
       +
           ids:id list ->

     

       343
       343
       +
           ?total:uint ->

     

       344
       344
       +
           ?limit:uint ->

     

       345
       345
       +
           unit ->

     

       346
       346
       +
           t

     

       347
       347
       +
       end

     

       348
       348
       +
       

     

       349
       349
       +
       (** Item indicating an added record in /queryChanges.

     

       350
       350
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.6> RFC 8620, Section 5.6 *)

     

       351
       351
       +
       module Added_item : sig

     

       352
       352
       +
         type t

     

       353
       353
       +
         

     

       354
       354
       +
         val id : t -> id

     

       355
       355
       +
         val index : t -> uint

     

       356
       356
       +
         

     

       357
       357
       +
         val v :

     

       358
       358
       +
           id:id ->

     

       359
       359
       +
           index:uint ->

     

       360
       360
       +
           unit ->

     

       361
       361
       +
           t

     

       362
       362
       +
       end

     

       363
       363
       +
       

     

       364
       364
       +
       (** Arguments for /queryChanges methods.

     

       365
       365
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.6> RFC 8620, Section 5.6 *)

     

       366
       366
       +
       module Query_changes_args : sig

     

       367
       367
       +
         type t

     

       368
       368
       +
         

     

       369
       369
       +
         val account_id : t -> id

     

       370
       370
       +
         val filter : t -> Filter.t option

     

       371
       371
       +
         val sort : t -> Comparator.t list option

     

       372
       372
       +
         val since_query_state : t -> string

     

       373
       373
       +
         val max_changes : t -> uint option

     

       374
       374
       +
         val up_to_id : t -> id option

     

       375
       375
       +
         val calculate_total : t -> bool option

     

       376
       376
       +
         val collapse_threads : t -> bool option

     

       377
       377
       +
         

     

       378
       378
       +
         val v :

     

       379
       379
       +
           account_id:id ->

     

       380
       380
       +
           ?filter:Filter.t ->

     

       381
       381
       +
           ?sort:Comparator.t list ->

     

       382
       382
       +
           since_query_state:string ->

     

       383
       383
       +
           ?max_changes:uint ->

     

       384
       384
       +
           ?up_to_id:id ->

     

       385
       385
       +
           ?calculate_total:bool ->

     

       386
       386
       +
           ?collapse_threads:bool ->

     

       387
       387
       +
           unit ->

     

       388
       388
       +
           t

     

       389
       389
       +
       end

     

       390
       390
       +
       

     

       391
       391
       +
       (** Response for /queryChanges methods.

     

       392
       392
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-5.6> RFC 8620, Section 5.6 *)

     

       393
       393
       +
       module Query_changes_response : sig

     

       394
       394
       +
         type t

     

       395
       395
       +
         

     

       396
       396
       +
         val account_id : t -> id

     

       397
       397
       +
         val old_query_state : t -> string

     

       398
       398
       +
         val new_query_state : t -> string

     

       399
       399
       +
         val total : t -> uint option

     

       400
       400
       +
         val removed : t -> id list

     

       401
       401
       +
         val added : t -> Added_item.t list

     

       402
       402
       +
         

     

       403
       403
       +
         val v :

     

       404
       404
       +
           account_id:id ->

     

       405
       405
       +
           old_query_state:string ->

     

       406
       406
       +
           new_query_state:string ->

     

       407
       407
       +
           ?total:uint ->

     

       408
       408
       +
           removed:id list ->

     

       409
       409
       +
           added:Added_item.t list ->

     

       410
       410
       +
           unit ->

     

       411
       411
       +
           t

     

       412
       412
       +
       end

     

       413
       413
       +
       

     

       414
       414
       +
       (** Core/echo method: Arguments are mirrored in the response.

     

       415
       415
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-4> RFC 8620, Section 4 *)

     

       416
       416
       +
       type core_echo_args = Yojson.Safe.t

     

       417
       417
       +
       type core_echo_response = Yojson.Safe.t

+230

jmap/jmap_push.mli

···

       1
       1
       +
       (** JMAP Push Notifications.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7> RFC 8620, Section 7 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap_types

     

       5
       5
       +
       open Jmap_methods

     

       6
       6
       +
       open Jmap_error

     

       7
       7
       +
       

     

       8
       8
       +
       (** TypeState object map (TypeName -> StateString).

     

       9
       9
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.1> RFC 8620, Section 7.1 *)

     

       10
       10
       +
       type type_state = string string_map

     

       11
       11
       +
       

     

       12
       12
       +
       (** StateChange object.

     

       13
       13
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.1> RFC 8620, Section 7.1 *)

     

       14
       14
       +
       module State_change : sig

     

       15
       15
       +
         type t

     

       16
       16
       +
         

     

       17
       17
       +
         val changed : t -> type_state id_map

     

       18
       18
       +
         

     

       19
       19
       +
         val v :

     

       20
       20
       +
           changed:type_state id_map ->

     

       21
       21
       +
           unit ->

     

       22
       22
       +
           t

     

       23
       23
       +
       end

     

       24
       24
       +
       

     

       25
       25
       +
       (** PushSubscription encryption keys.

     

       26
       26
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2> RFC 8620, Section 7.2 *)

     

       27
       27
       +
       module Push_encryption_keys : sig

     

       28
       28
       +
         type t

     

       29
       29
       +
         

     

       30
       30
       +
         (** P-256 ECDH public key (URL-safe base64) *)

     

       31
       31
       +
         val p256dh : t -> string

     

       32
       32
       +
         

     

       33
       33
       +
         (** Authentication secret (URL-safe base64) *)

     

       34
       34
       +
         val auth : t -> string

     

       35
       35
       +
         

     

       36
       36
       +
         val v :

     

       37
       37
       +
           p256dh:string ->

     

       38
       38
       +
           auth:string ->

     

       39
       39
       +
           unit ->

     

       40
       40
       +
           t

     

       41
       41
       +
       end

     

       42
       42
       +
       

     

       43
       43
       +
       (** PushSubscription object.

     

       44
       44
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2> RFC 8620, Section 7.2 *)

     

       45
       45
       +
       module Push_subscription : sig

     

       46
       46
       +
         type t

     

       47
       47
       +
         

     

       48
       48
       +
         (** Id of the subscription (server-set, immutable) *)

     

       49
       49
       +
         val id : t -> id

     

       50
       50
       +
         

     

       51
       51
       +
         (** Device client id (immutable) *)

     

       52
       52
       +
         val device_client_id : t -> string

     

       53
       53
       +
         

     

       54
       54
       +
         (** Notification URL (immutable) *)

     

       55
       55
       +
         val url : t -> Uri.t

     

       56
       56
       +
         

     

       57
       57
       +
         (** Encryption keys (immutable) *)

     

       58
       58
       +
         val keys : t -> Push_encryption_keys.t option

     

       59
       59
       +
         val verification_code : t -> string option

     

       60
       60
       +
         val expires : t -> utc_date option

     

       61
       61
       +
         val types : t -> string list option

     

       62
       62
       +
         

     

       63
       63
       +
         val v :

     

       64
       64
       +
           id:id ->

     

       65
       65
       +
           device_client_id:string ->

     

       66
       66
       +
           url:Uri.t ->

     

       67
       67
       +
           ?keys:Push_encryption_keys.t ->

     

       68
       68
       +
           ?verification_code:string ->

     

       69
       69
       +
           ?expires:utc_date ->

     

       70
       70
       +
           ?types:string list ->

     

       71
       71
       +
           unit ->

     

       72
       72
       +
           t

     

       73
       73
       +
       end

     

       74
       74
       +
       

     

       75
       75
       +
       (** PushSubscription object for creation (omits server-set fields).

     

       76
       76
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2> RFC 8620, Section 7.2 *)

     

       77
       77
       +
       module Push_subscription_create : sig

     

       78
       78
       +
         type t

     

       79
       79
       +
         

     

       80
       80
       +
         val device_client_id : t -> string

     

       81
       81
       +
         val url : t -> Uri.t

     

       82
       82
       +
         val keys : t -> Push_encryption_keys.t option

     

       83
       83
       +
         val expires : t -> utc_date option

     

       84
       84
       +
         val types : t -> string list option

     

       85
       85
       +
         

     

       86
       86
       +
         val v :

     

       87
       87
       +
           device_client_id:string ->

     

       88
       88
       +
           url:Uri.t ->

     

       89
       89
       +
           ?keys:Push_encryption_keys.t ->

     

       90
       90
       +
           ?expires:utc_date ->

     

       91
       91
       +
           ?types:string list ->

     

       92
       92
       +
           unit ->

     

       93
       93
       +
           t

     

       94
       94
       +
       end

     

       95
       95
       +
       

     

       96
       96
       +
       (** PushSubscription object for update patch.

     

       97
       97
       +
           Only verification_code and expires can be updated.

     

       98
       98
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2> RFC 8620, Section 7.2

     

       99
       99
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.2> RFC 8620, Section 7.2.2 *)

     

       100
       100
       +
       type push_subscription_update = patch_object

     

       101
       101
       +
       

     

       102
       102
       +
       (** Arguments for PushSubscription/get.

     

       103
       103
       +
           Extends standard /get args.

     

       104
       104
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.1> RFC 8620, Section 7.2.1 *)

     

       105
       105
       +
       module Push_subscription_get_args : sig

     

       106
       106
       +
         type t

     

       107
       107
       +
         

     

       108
       108
       +
         val ids : t -> id list option

     

       109
       109
       +
         val properties : t -> string list option

     

       110
       110
       +
         

     

       111
       111
       +
         val v :

     

       112
       112
       +
           ?ids:id list ->

     

       113
       113
       +
           ?properties:string list ->

     

       114
       114
       +
           unit ->

     

       115
       115
       +
           t

     

       116
       116
       +
       end

     

       117
       117
       +
       

     

       118
       118
       +
       (** Response for PushSubscription/get.

     

       119
       119
       +
           Extends standard /get response.

     

       120
       120
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.1> RFC 8620, Section 7.2.1 *)

     

       121
       121
       +
       module Push_subscription_get_response : sig

     

       122
       122
       +
         type t

     

       123
       123
       +
         

     

       124
       124
       +
         val list : t -> Push_subscription.t list

     

       125
       125
       +
         val not_found : t -> id list

     

       126
       126
       +
         

     

       127
       127
       +
         val v :

     

       128
       128
       +
           list:Push_subscription.t list ->

     

       129
       129
       +
           not_found:id list ->

     

       130
       130
       +
           unit ->

     

       131
       131
       +
           t

     

       132
       132
       +
       end

     

       133
       133
       +
       

     

       134
       134
       +
       (** Arguments for PushSubscription/set.

     

       135
       135
       +
           Extends standard /set args.

     

       136
       136
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.2> RFC 8620, Section 7.2.2 *)

     

       137
       137
       +
       module Push_subscription_set_args : sig

     

       138
       138
       +
         type t

     

       139
       139
       +
         

     

       140
       140
       +
         val create : t -> Push_subscription_create.t id_map option

     

       141
       141
       +
         val update : t -> push_subscription_update id_map option

     

       142
       142
       +
         val destroy : t -> id list option

     

       143
       143
       +
         

     

       144
       144
       +
         val v :

     

       145
       145
       +
           ?create:Push_subscription_create.t id_map ->

     

       146
       146
       +
           ?update:push_subscription_update id_map ->

     

       147
       147
       +
           ?destroy:id list ->

     

       148
       148
       +
           unit ->

     

       149
       149
       +
           t

     

       150
       150
       +
       end

     

       151
       151
       +
       

     

       152
       152
       +
       (** Server-set information for created PushSubscription.

     

       153
       153
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.2> RFC 8620, Section 7.2.2 *)

     

       154
       154
       +
       module Push_subscription_created_info : sig

     

       155
       155
       +
         type t

     

       156
       156
       +
         

     

       157
       157
       +
         val id : t -> id

     

       158
       158
       +
         val expires : t -> utc_date option

     

       159
       159
       +
         

     

       160
       160
       +
         val v :

     

       161
       161
       +
           id:id ->

     

       162
       162
       +
           ?expires:utc_date ->

     

       163
       163
       +
           unit ->

     

       164
       164
       +
           t

     

       165
       165
       +
       end

     

       166
       166
       +
       

     

       167
       167
       +
       (** Server-set information for updated PushSubscription.

     

       168
       168
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.2> RFC 8620, Section 7.2.2 *)

     

       169
       169
       +
       module Push_subscription_updated_info : sig

     

       170
       170
       +
         type t

     

       171
       171
       +
         

     

       172
       172
       +
         val expires : t -> utc_date option

     

       173
       173
       +
         

     

       174
       174
       +
         val v :

     

       175
       175
       +
           ?expires:utc_date ->

     

       176
       176
       +
           unit ->

     

       177
       177
       +
           t

     

       178
       178
       +
       end

     

       179
       179
       +
       

     

       180
       180
       +
       (** Response for PushSubscription/set.

     

       181
       181
       +
           Extends standard /set response.

     

       182
       182
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.2> RFC 8620, Section 7.2.2 *)

     

       183
       183
       +
       module Push_subscription_set_response : sig

     

       184
       184
       +
         type t

     

       185
       185
       +
         

     

       186
       186
       +
         val created : t -> Push_subscription_created_info.t id_map option

     

       187
       187
       +
         val updated : t -> Push_subscription_updated_info.t option id_map option

     

       188
       188
       +
         val destroyed : t -> id list option

     

       189
       189
       +
         val not_created : t -> Set_error.t id_map option

     

       190
       190
       +
         val not_updated : t -> Set_error.t id_map option

     

       191
       191
       +
         val not_destroyed : t -> Set_error.t id_map option

     

       192
       192
       +
         

     

       193
       193
       +
         val v :

     

       194
       194
       +
           ?created:Push_subscription_created_info.t id_map ->

     

       195
       195
       +
           ?updated:Push_subscription_updated_info.t option id_map ->

     

       196
       196
       +
           ?destroyed:id list ->

     

       197
       197
       +
           ?not_created:Set_error.t id_map ->

     

       198
       198
       +
           ?not_updated:Set_error.t id_map ->

     

       199
       199
       +
           ?not_destroyed:Set_error.t id_map ->

     

       200
       200
       +
           unit ->

     

       201
       201
       +
           t

     

       202
       202
       +
       end

     

       203
       203
       +
       

     

       204
       204
       +
       (** PushVerification object.

     

       205
       205
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.2.2> RFC 8620, Section 7.2.2 *)

     

       206
       206
       +
       module Push_verification : sig

     

       207
       207
       +
         type t

     

       208
       208
       +
         

     

       209
       209
       +
         val push_subscription_id : t -> id

     

       210
       210
       +
         val verification_code : t -> string

     

       211
       211
       +
         

     

       212
       212
       +
         val v :

     

       213
       213
       +
           push_subscription_id:id ->

     

       214
       214
       +
           verification_code:string ->

     

       215
       215
       +
           unit ->

     

       216
       216
       +
           t

     

       217
       217
       +
       end

     

       218
       218
       +
       

     

       219
       219
       +
       (** Data for EventSource ping event.

     

       220
       220
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.3> RFC 8620, Section 7.3 *)

     

       221
       221
       +
       module Event_source_ping_data : sig

     

       222
       222
       +
         type t

     

       223
       223
       +
         

     

       224
       224
       +
         val interval : t -> uint

     

       225
       225
       +
         

     

       226
       226
       +
         val v :

     

       227
       227
       +
           interval:uint ->

     

       228
       228
       +
           unit ->

     

       229
       229
       +
           t

     

       230
       230
       +
       end

+98

jmap/jmap_session.mli

···

       1
       1
       +
       (** JMAP Session Resource.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap_types

     

       5
       5
       +
       

     

       6
       6
       +
       (** Account capability information.

     

       7
       7
       +
           The value is capability-specific.

     

       8
       8
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       9
       9
       +
       type account_capability_value = Yojson.Safe.t

     

       10
       10
       +
       

     

       11
       11
       +
       (** Server capability information.

     

       12
       12
       +
           The value is capability-specific.

     

       13
       13
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       14
       14
       +
       type server_capability_value = Yojson.Safe.t

     

       15
       15
       +
       

     

       16
       16
       +
       (** Core capability information.

     

       17
       17
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       18
       18
       +
       module Core_capability : sig

     

       19
       19
       +
         type t

     

       20
       20
       +
         

     

       21
       21
       +
         val max_size_upload : t -> uint

     

       22
       22
       +
         val max_concurrent_upload : t -> uint

     

       23
       23
       +
         val max_size_request : t -> uint

     

       24
       24
       +
         val max_concurrent_requests : t -> uint

     

       25
       25
       +
         val max_calls_in_request : t -> uint

     

       26
       26
       +
         val max_objects_in_get : t -> uint

     

       27
       27
       +
         val max_objects_in_set : t -> uint

     

       28
       28
       +
         val collation_algorithms : t -> string list

     

       29
       29
       +
         

     

       30
       30
       +
         val v :

     

       31
       31
       +
           max_size_upload:uint ->

     

       32
       32
       +
           max_concurrent_upload:uint ->

     

       33
       33
       +
           max_size_request:uint ->

     

       34
       34
       +
           max_concurrent_requests:uint ->

     

       35
       35
       +
           max_calls_in_request:uint ->

     

       36
       36
       +
           max_objects_in_get:uint ->

     

       37
       37
       +
           max_objects_in_set:uint ->

     

       38
       38
       +
           collation_algorithms:string list ->

     

       39
       39
       +
           unit ->

     

       40
       40
       +
           t

     

       41
       41
       +
       end

     

       42
       42
       +
       

     

       43
       43
       +
       (** An Account object.

     

       44
       44
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       45
       45
       +
       module Account : sig

     

       46
       46
       +
         type t

     

       47
       47
       +
         

     

       48
       48
       +
         val name : t -> string

     

       49
       49
       +
         val is_personal : t -> bool

     

       50
       50
       +
         val is_read_only : t -> bool

     

       51
       51
       +
         val account_capabilities : t -> account_capability_value string_map

     

       52
       52
       +
         

     

       53
       53
       +
         val v :

     

       54
       54
       +
           name:string ->

     

       55
       55
       +
           ?is_personal:bool ->

     

       56
       56
       +
           ?is_read_only:bool ->

     

       57
       57
       +
           ?account_capabilities:account_capability_value string_map ->

     

       58
       58
       +
           unit ->

     

       59
       59
       +
           t

     

       60
       60
       +
       end

     

       61
       61
       +
       

     

       62
       62
       +
       (** The Session object.

     

       63
       63
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2> RFC 8620, Section 2 *)

     

       64
       64
       +
       module Session : sig

     

       65
       65
       +
         type t

     

       66
       66
       +
         

     

       67
       67
       +
         val capabilities : t -> server_capability_value string_map

     

       68
       68
       +
         val accounts : t -> Account.t id_map

     

       69
       69
       +
         val primary_accounts : t -> id string_map

     

       70
       70
       +
         val username : t -> string

     

       71
       71
       +
         val api_url : t -> Uri.t

     

       72
       72
       +
         val download_url : t -> Uri.t

     

       73
       73
       +
         val upload_url : t -> Uri.t

     

       74
       74
       +
         val event_source_url : t -> Uri.t

     

       75
       75
       +
         val state : t -> string

     

       76
       76
       +
         

     

       77
       77
       +
         val v :

     

       78
       78
       +
           capabilities:server_capability_value string_map ->

     

       79
       79
       +
           accounts:Account.t id_map ->

     

       80
       80
       +
           primary_accounts:id string_map ->

     

       81
       81
       +
           username:string ->

     

       82
       82
       +
           api_url:Uri.t ->

     

       83
       83
       +
           download_url:Uri.t ->

     

       84
       84
       +
           upload_url:Uri.t ->

     

       85
       85
       +
           event_source_url:Uri.t ->

     

       86
       86
       +
           state:string ->

     

       87
       87
       +
           unit ->

     

       88
       88
       +
           t

     

       89
       89
       +
       end

     

       90
       90
       +
       

     

       91
       91
       +
       (** Function to perform service autodiscovery.

     

       92
       92
       +
           Returns the session URL if found.

     

       93
       93
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-2.2> RFC 8620, Section 2.2 *)

     

       94
       94
       +
       val discover : domain:string -> Uri.t option

     

       95
       95
       +
       

     

       96
       96
       +
       (** Function to fetch the session object from a given URL.

     

       97
       97
       +
           Requires authentication handling (details TBD/outside this signature). *)

     

       98
       98
       +
       val get_session : url:Uri.t -> Session.t

+38

jmap/jmap_types.mli

···

       1
       1
       +
       (** Basic JMAP types as defined in RFC 8620. *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** The Id data type.

     

       4
       4
       +
           A string of 1 to 255 octets, using URL-safe base64 characters.

     

       5
       5
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-1.2> RFC 8620, Section 1.2 *)

     

       6
       6
       +
       type id = string

     

       7
       7
       +
       

     

       8
       8
       +
       (** The Int data type.

     

       9
       9
       +
           An integer in the range [-2^53+1, 2^53-1]. Represented as OCaml's standard [int].

     

       10
       10
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-1.3> RFC 8620, Section 1.3 *)

     

       11
       11
       +
       type jint = int

     

       12
       12
       +
       

     

       13
       13
       +
       (** The UnsignedInt data type.

     

       14
       14
       +
           An integer in the range [0, 2^53-1]. Represented as OCaml's standard [int].

     

       15
       15
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-1.3> RFC 8620, Section 1.3 *)

     

       16
       16
       +
       type uint = int

     

       17
       17
       +
       

     

       18
       18
       +
       (** The Date data type.

     

       19
       19
       +
           A string in RFC 3339 "date-time" format.

     

       20
       20
       +
           Represented as a float using Unix time.

     

       21
       21
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-1.4> RFC 8620, Section 1.4 *)

     

       22
       22
       +
       type date = float

     

       23
       23
       +
       

     

       24
       24
       +
       (** The UTCDate data type.

     

       25
       25
       +
           A string in RFC 3339 "date-time" format, restricted to UTC (Z timezone).

     

       26
       26
       +
           Represented as a float using Unix time.

     

       27
       27
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-1.4> RFC 8620, Section 1.4 *)

     

       28
       28
       +
       type utc_date = float

     

       29
       29
       +
       

     

       30
       30
       +
       (** Represents a JSON object used as a map String -> V. *)

     

       31
       31
       +
       type 'v string_map = (string, 'v) Hashtbl.t

     

       32
       32
       +
       

     

       33
       33
       +
       (** Represents a JSON object used as a map Id -> V. *)

     

       34
       34
       +
       type 'v id_map = (id, 'v) Hashtbl.t

     

       35
       35
       +
       

     

       36
       36
       +
       (** Represents a JSON Pointer path with JMAP extensions.

     

       37
       37
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.7> RFC 8620, Section 3.7 *)

     

       38
       38
       +
       type json_pointer = string

+80

jmap/jmap_wire.mli

···

       1
       1
       +
       (** JMAP Wire Protocol Structures (Request/Response). *)

     

       2
       2
       +
       

     

       3
       3
       +
       open Jmap_types

     

       4
       4
       +
       

     

       5
       5
       +
       (** An invocation tuple within a request or response.

     

       6
       6
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.2> RFC 8620, Section 3.2 *)

     

       7
       7
       +
       module Invocation : sig

     

       8
       8
       +
         type t

     

       9
       9
       +
         

     

       10
       10
       +
         val method_name : t -> string

     

       11
       11
       +
         val arguments : t -> Yojson.Safe.t

     

       12
       12
       +
         val method_call_id : t -> string

     

       13
       13
       +
         

     

       14
       14
       +
         val v : 

     

       15
       15
       +
           ?arguments:Yojson.Safe.t ->

     

       16
       16
       +
           method_name:string ->

     

       17
       17
       +
           method_call_id:string ->

     

       18
       18
       +
           unit ->

     

       19
       19
       +
           t

     

       20
       20
       +
       end

     

       21
       21
       +
       

     

       22
       22
       +
       (** Method error type with context.

     

       23
       23
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6.2> RFC 8620, Section 3.6.2 *)

     

       24
       24
       +
       type method_error = Jmap_error.Method_error.t * string

     

       25
       25
       +
       

     

       26
       26
       +
       (** A response invocation part, which can be a standard response or an error.

     

       27
       27
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.4> RFC 8620, Section 3.4

     

       28
       28
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.6.2> RFC 8620, Section 3.6.2 *)

     

       29
       29
       +
       type response_invocation = (Invocation.t, method_error) result

     

       30
       30
       +
       

     

       31
       31
       +
       (** A reference to a previous method call's result.

     

       32
       32
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.7> RFC 8620, Section 3.7 *)

     

       33
       33
       +
       module Result_reference : sig

     

       34
       34
       +
         type t

     

       35
       35
       +
         

     

       36
       36
       +
         val result_of : t -> string

     

       37
       37
       +
         val name : t -> string

     

       38
       38
       +
         val path : t -> json_pointer

     

       39
       39
       +
         

     

       40
       40
       +
         val v :

     

       41
       41
       +
           result_of:string ->

     

       42
       42
       +
           name:string ->

     

       43
       43
       +
           path:json_pointer ->

     

       44
       44
       +
           unit ->

     

       45
       45
       +
           t

     

       46
       46
       +
       end

     

       47
       47
       +
       

     

       48
       48
       +
       (** The Request object.

     

       49
       49
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.3> RFC 8620, Section 3.3 *)

     

       50
       50
       +
       module Request : sig

     

       51
       51
       +
         type t

     

       52
       52
       +
         

     

       53
       53
       +
         val using : t -> string list

     

       54
       54
       +
         val method_calls : t -> Invocation.t list

     

       55
       55
       +
         val created_ids : t -> id id_map option

     

       56
       56
       +
         

     

       57
       57
       +
         val v :

     

       58
       58
       +
           using:string list ->

     

       59
       59
       +
           method_calls:Invocation.t list ->

     

       60
       60
       +
           ?created_ids:id id_map ->

     

       61
       61
       +
           unit ->

     

       62
       62
       +
           t

     

       63
       63
       +
       end

     

       64
       64
       +
       

     

       65
       65
       +
       (** The Response object.

     

       66
       66
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-3.4> RFC 8620, Section 3.4 *)

     

       67
       67
       +
       module Response : sig

     

       68
       68
       +
         type t

     

       69
       69
       +
         

     

       70
       70
       +
         val method_responses : t -> response_invocation list

     

       71
       71
       +
         val created_ids : t -> id id_map option

     

       72
       72
       +
         val session_state : t -> string

     

       73
       73
       +
         

     

       74
       74
       +
         val v :

     

       75
       75
       +
           method_responses:response_invocation list ->

     

       76
       76
       +
           ?created_ids:id id_map ->

     

       77
       77
       +
           session_state:string ->

     

       78
       78
       +
           unit ->

     

       79
       79
       +
           t

     

       80
       80
       +
       end

+15

jmap-email/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name jmap_email)

     

       3
       3
       +
        (public_name jmap-email)

     

       4
       4
       +
        (libraries jmap yojson uri)

     

       5
       5
       +
        (modules_without_implementation jmap_email jmap_email_types jmap_identity

     

       6
       6
       +
         jmap_mailbox jmap_search_snippet jmap_submission jmap_thread jmap_vacation)

     

       7
       7
       +
        (modules

     

       8
       8
       +
         jmap_email

     

       9
       9
       +
         jmap_email_types

     

       10
       10
       +
         jmap_mailbox

     

       11
       11
       +
         jmap_thread

     

       12
       12
       +
         jmap_search_snippet

     

       13
       13
       +
         jmap_identity

     

       14
       14
       +
         jmap_submission

     

       15
       15
       +
         jmap_vacation))

+503

jmap-email/jmap_email.mli

···

       1
       1
       +
       (** JMAP Mail Extension Library (RFC 8621).

     

       2
       2
       +
       

     

       3
       3
       +
           This library extends the core JMAP protocol with email-specific

     

       4
       4
       +
           functionality as defined in RFC 8621. It provides types and signatures

     

       5
       5
       +
           for interacting with JMAP Mail data types: Mailbox, Thread, Email, 

     

       6
       6
       +
           SearchSnippet, Identity, EmailSubmission, and VacationResponse.

     

       7
       7
       +
           

     

       8
       8
       +
           Requires the core Jmap library and Jmap_unix library for network operations.

     

       9
       9
       +
           

     

       10
       10
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html> RFC 8621: JMAP for Mail

     

       11
       11
       +
       *)

     

       12
       12
       +
       

     

       13
       13
       +
       open Jmap.Types

     

       14
       14
       +
       

     

       15
       15
       +
       (** {1 Core Types} *)

     

       16
       16
       +
       module Types = Jmap_email_types

     

       17
       17
       +
       

     

       18
       18
       +
       (** {1 Mailbox} 

     

       19
       19
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       20
       20
       +
       module Mailbox = Jmap_mailbox

     

       21
       21
       +
       

     

       22
       22
       +
       (** {1 Thread}

     

       23
       23
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3> RFC 8621, Section 3 *)

     

       24
       24
       +
       module Thread = Jmap_thread

     

       25
       25
       +
       

     

       26
       26
       +
       (** {1 Search Snippet}

     

       27
       27
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-5> RFC 8621, Section 5 *)

     

       28
       28
       +
       module SearchSnippet = Jmap_search_snippet

     

       29
       29
       +
       

     

       30
       30
       +
       (** {1 Identity}

     

       31
       31
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-6> RFC 8621, Section 6 *)

     

       32
       32
       +
       module Identity = Jmap_identity

     

       33
       33
       +
       

     

       34
       34
       +
       (** {1 Email Submission}

     

       35
       35
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       36
       36
       +
       module Submission = Jmap_submission

     

       37
       37
       +
       

     

       38
       38
       +
       (** {1 Vacation Response}

     

       39
       39
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-8> RFC 8621, Section 8 *)

     

       40
       40
       +
       module Vacation = Jmap_vacation

     

       41
       41
       +
       

     

       42
       42
       +
       (** {1 Example Usage}

     

       43
       43
       +
       

     

       44
       44
       +
           The following example demonstrates using the JMAP Email library to fetch unread emails

     

       45
       45
       +
           from a specific sender.

     

       46
       46
       +
       

     

       47
       47
       +
       {[

     

       48
       48
       +
         (* OCaml 5.1 required for Lwt let operators *)

     

       49
       49
       +
         open Lwt.Syntax

     

       50
       50
       +
         open Jmap

     

       51
       51
       +
         open Jmap.Types

     

       52
       52
       +
         open Jmap.Wire

     

       53
       53
       +
         open Jmap.Methods

     

       54
       54
       +
         open Jmap_email

     

       55
       55
       +
         open Jmap.Unix

     

       56
       56
       +
         

     

       57
       57
       +
         let list_unread_from_sender ctx session sender_email =

     

       58
       58
       +
           (* Find the primary mail account *)

     

       59
       59
       +
           let primary_mail_account_id =

     

       60
       60
       +
             Hashtbl.find session.primary_accounts capability_mail

     

       61
       61
       +
           in

     

       62
       62
       +
           (* Construct the filter *)

     

       63
       63
       +
           let filter : filter =

     

       64
       64
       +
             Filter_operator (Filter_operator.v

     

       65
       65
       +
               ~operator:`AND

     

       66
       66
       +
               ~conditions:[

     

       67
       67
       +
                 Filter_condition (Yojson.Safe.to_basic (`Assoc [

     

       68
       68
       +
                   ("from", `String sender_email);

     

       69
       69
       +
                 ]));

     

       70
       70
       +
                 Filter_condition (Yojson.Safe.to_basic (`Assoc [

     

       71
       71
       +
                   ("hasKeyword", `String keyword_seen);

     

       72
       72
       +
                   ("value", `Bool false);

     

       73
       73
       +
                 ]));

     

       74
       74
       +
               ]

     

       75
       75
       +
               ())

     

       76
       76
       +
           in

     

       77
       77
       +
           (* Prepare the Email/query invocation *)

     

       78
       78
       +
           let query_args = Query_args.v

     

       79
       79
       +
             ~account_id:primary_mail_account_id

     

       80
       80
       +
             ~filter

     

       81
       81
       +
             ~sort:[

     

       82
       82
       +
               Comparator.v

     

       83
       83
       +
                 ~property:"receivedAt"

     

       84
       84
       +
                 ~is_ascending:false

     

       85
       85
       +
                 ()

     

       86
       86
       +
             ]

     

       87
       87
       +
             ~position:0

     

       88
       88
       +
             ~limit:20 (* Get latest 20 *)

     

       89
       89
       +
             ~calculate_total:false

     

       90
       90
       +
             ~collapse_threads:false

     

       91
       91
       +
             ()

     

       92
       92
       +
           in

     

       93
       93
       +
           let query_invocation = Invocation.v

     

       94
       94
       +
             ~method_name:"Email/query"

     

       95
       95
       +
             ~arguments:(* Yojson conversion of query_args needed here *)

     

       96
       96
       +
             ~method_call_id:"q1"

     

       97
       97
       +
             ()

     

       98
       98
       +
           in

     

       99
       99
       +
       

     

       100
       100
       +
           (* Prepare the Email/get invocation using a back-reference *)

     

       101
       101
       +
           let get_args = Get_args.v

     

       102
       102
       +
             ~account_id:primary_mail_account_id

     

       103
       103
       +
             ~properties:["id"; "subject"; "receivedAt"; "from"]

     

       104
       104
       +
             ()

     

       105
       105
       +
           in

     

       106
       106
       +
           let get_invocation = Invocation.v

     

       107
       107
       +
             ~method_name:"Email/get"

     

       108
       108
       +
             ~arguments:(* Yojson conversion of get_args, with ids replaced by a ResultReference to q1 needed here *)

     

       109
       109
       +
             ~method_call_id:"g1"

     

       110
       110
       +
             ()

     

       111
       111
       +
           in

     

       112
       112
       +
       

     

       113
       113
       +
           (* Prepare the JMAP request *)

     

       114
       114
       +
           let request = Request.v

     

       115
       115
       +
             ~using:[ Jmap.capability_core; capability_mail ]

     

       116
       116
       +
             ~method_calls:[ query_invocation; get_invocation ]

     

       117
       117
       +
             ()

     

       118
       118
       +
           in

     

       119
       119
       +
       

     

       120
       120
       +
           (* Send the request *)

     

       121
       121
       +
           let* response = Jmap.Unix.request ctx request in

     

       122
       122
       +
       

     

       123
       123
       +
           (* Process the response (extract Email/get results) *)

     

       124
       124
       +
           (* ... Omitted: find the Email/get response in response.method_responses ... *)

     

       125
       125
       +
           Lwt.return_unit

     

       126
       126
       +
       ]}

     

       127
       127
       +
       *)

     

       128
       128
       +
       

     

       129
       129
       +
       (** Capability URI for JMAP Mail.

     

       130
       130
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-1.3.1> RFC 8621, Section 1.3.1 *)

     

       131
       131
       +
       val capability_mail : string

     

       132
       132
       +
       

     

       133
       133
       +
       (** Capability URI for JMAP Submission.

     

       134
       134
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-1.3.2> RFC 8621, Section 1.3.2 *)

     

       135
       135
       +
       val capability_submission : string

     

       136
       136
       +
       

     

       137
       137
       +
       (** Capability URI for JMAP Vacation Response.

     

       138
       138
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-1.3.3> RFC 8621, Section 1.3.3 *)

     

       139
       139
       +
       val capability_vacationresponse : string

     

       140
       140
       +
       

     

       141
       141
       +
       (** Type name for EmailDelivery push notifications.

     

       142
       142
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-1.5> RFC 8621, Section 1.5 *)

     

       143
       143
       +
       val push_event_type_email_delivery : string

     

       144
       144
       +
       

     

       145
       145
       +
       (** Keyword string constants for JMAP email flags.

     

       146
       146
       +
           Provides easy access to standardized keyword string values.

     

       147
       147
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.1> RFC 8621, Section 4.1.1 *)

     

       148
       148
       +
       module Keyword : sig

     

       149
       149
       +
         (** {1 IMAP System Flags} *)

     

       150
       150
       +
         

     

       151
       151
       +
         (** "$draft": The Email is a draft the user is composing *)

     

       152
       152
       +
         val draft : string

     

       153
       153
       +
         

     

       154
       154
       +
         (** "$seen": The Email has been read *)

     

       155
       155
       +
         val seen : string

     

       156
       156
       +
         

     

       157
       157
       +
         (** "$flagged": The Email has been flagged for urgent/special attention *)

     

       158
       158
       +
         val flagged : string

     

       159
       159
       +
         

     

       160
       160
       +
         (** "$answered": The Email has been replied to *)

     

       161
       161
       +
         val answered : string

     

       162
       162
       +
         

     

       163
       163
       +
         (** {1 Common Extension Keywords} *)

     

       164
       164
       +
         

     

       165
       165
       +
         (** "$forwarded": The Email has been forwarded *)

     

       166
       166
       +
         val forwarded : string

     

       167
       167
       +
         

     

       168
       168
       +
         (** "$phishing": The Email is likely to be phishing *)

     

       169
       169
       +
         val phishing : string

     

       170
       170
       +
         

     

       171
       171
       +
         (** "$junk": The Email is spam/junk *)

     

       172
       172
       +
         val junk : string

     

       173
       173
       +
         

     

       174
       174
       +
         (** "$notjunk": The Email is explicitly marked as not spam/junk *)

     

       175
       175
       +
         val notjunk : string

     

       176
       176
       +
         

     

       177
       177
       +
         (** {1 Apple Mail and Vendor Extensions} 

     

       178
       178
       +
             @see <https://datatracker.ietf.org/doc/draft-ietf-mailmaint-messageflag-mailboxattribute/> *)

     

       179
       179
       +
         

     

       180
       180
       +
         (** "$notify": Request to be notified when this email gets a reply *)

     

       181
       181
       +
         val notify : string

     

       182
       182
       +
         

     

       183
       183
       +
         (** "$muted": Email is muted (notifications disabled) *)

     

       184
       184
       +
         val muted : string

     

       185
       185
       +
         

     

       186
       186
       +
         (** "$followed": Email thread is followed for notifications *)

     

       187
       187
       +
         val followed : string

     

       188
       188
       +
         

     

       189
       189
       +
         (** "$memo": Email has a memo/note associated with it *)

     

       190
       190
       +
         val memo : string

     

       191
       191
       +
         

     

       192
       192
       +
         (** "$hasmemo": Email has a memo, annotation or note property *)

     

       193
       193
       +
         val hasmemo : string

     

       194
       194
       +
         

     

       195
       195
       +
         (** "$autosent": Email was generated or sent automatically *)

     

       196
       196
       +
         val autosent : string

     

       197
       197
       +
         

     

       198
       198
       +
         (** "$unsubscribed": User has unsubscribed from this sender *)

     

       199
       199
       +
         val unsubscribed : string

     

       200
       200
       +
         

     

       201
       201
       +
         (** "$canunsubscribe": Email contains unsubscribe information *)

     

       202
       202
       +
         val canunsubscribe : string

     

       203
       203
       +
         

     

       204
       204
       +
         (** "$imported": Email was imported from another system *)

     

       205
       205
       +
         val imported : string

     

       206
       206
       +
         

     

       207
       207
       +
         (** "$istrusted": Email is from a trusted/verified sender *)

     

       208
       208
       +
         val istrusted : string

     

       209
       209
       +
         

     

       210
       210
       +
         (** "$maskedemail": Email is to/from a masked/anonymous address *)

     

       211
       211
       +
         val maskedemail : string

     

       212
       212
       +
         

     

       213
       213
       +
         (** "$new": Email was recently delivered *)

     

       214
       214
       +
         val new_mail : string

     

       215
       215
       +
         

     

       216
       216
       +
         (** {1 Apple Mail Color Flag Bits} *)

     

       217
       217
       +
         

     

       218
       218
       +
         (** "$MailFlagBit0": First color flag bit (red) *)

     

       219
       219
       +
         val mailflagbit0 : string

     

       220
       220
       +
         

     

       221
       221
       +
         (** "$MailFlagBit1": Second color flag bit (orange) *)

     

       222
       222
       +
         val mailflagbit1 : string

     

       223
       223
       +
         

     

       224
       224
       +
         (** "$MailFlagBit2": Third color flag bit (yellow) *)

     

       225
       225
       +
         val mailflagbit2 : string

     

       226
       226
       +
         

     

       227
       227
       +
         (** {1 Color Flag Combinations} *)

     

       228
       228
       +
         

     

       229
       229
       +
         (** Get color flag bit values for a specific color 

     

       230
       230
       +
             @return A list of flags to set to create the requested color *)

     

       231
       231
       +
         val color_flags : [`Red | `Orange | `Yellow | `Green | `Blue | `Purple | `Gray] -> string list

     

       232
       232
       +
         

     

       233
       233
       +
         (** Check if a string is a valid keyword according to the RFC

     

       234
       234
       +
             @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.1> RFC 8621, Section 4.1.1 *)

     

       235
       235
       +
         val is_valid : string -> bool

     

       236
       236
       +
       end

     

       237
       237
       +
       

     

       238
       238
       +
       (** For backward compatibility - DEPRECATED, use Keyword.draft instead *)

     

       239
       239
       +
       val keyword_draft : string

     

       240
       240
       +
       

     

       241
       241
       +
       (** For backward compatibility - DEPRECATED, use Keyword.seen instead *)

     

       242
       242
       +
       val keyword_seen : string

     

       243
       243
       +
       

     

       244
       244
       +
       (** For backward compatibility - DEPRECATED, use Keyword.flagged instead *)

     

       245
       245
       +
       val keyword_flagged : string

     

       246
       246
       +
       

     

       247
       247
       +
       (** For backward compatibility - DEPRECATED, use Keyword.answered instead *)

     

       248
       248
       +
       val keyword_answered : string

     

       249
       249
       +
       

     

       250
       250
       +
       (** For backward compatibility - DEPRECATED, use Keyword.forwarded instead *)

     

       251
       251
       +
       val keyword_forwarded : string

     

       252
       252
       +
       

     

       253
       253
       +
       (** For backward compatibility - DEPRECATED, use Keyword.phishing instead *)

     

       254
       254
       +
       val keyword_phishing : string

     

       255
       255
       +
       

     

       256
       256
       +
       (** For backward compatibility - DEPRECATED, use Keyword.junk instead *)

     

       257
       257
       +
       val keyword_junk : string

     

       258
       258
       +
       

     

       259
       259
       +
       (** For backward compatibility - DEPRECATED, use Keyword.notjunk instead *)

     

       260
       260
       +
       val keyword_notjunk : string

     

       261
       261
       +
       

     

       262
       262
       +
       (** Email keyword operations.

     

       263
       263
       +
           Functions to manipulate and update email keywords/flags. *)

     

       264
       264
       +
       module Keyword_ops : sig

     

       265
       265
       +
         (** Add a keyword/flag to an email *)

     

       266
       266
       +
         val add : Types.Email.t -> Types.Keywords.keyword -> Types.Email.t

     

       267
       267
       +
         

     

       268
       268
       +
         (** Remove a keyword/flag from an email *)

     

       269
       269
       +
         val remove : Types.Email.t -> Types.Keywords.keyword -> Types.Email.t

     

       270
       270
       +
         

     

       271
       271
       +
         (** {1 System Flag Operations} *)

     

       272
       272
       +
         

     

       273
       273
       +
         (** Mark an email as seen/read *)

     

       274
       274
       +
         val mark_as_seen : Types.Email.t -> Types.Email.t

     

       275
       275
       +
         

     

       276
       276
       +
         (** Mark an email as unseen/unread *)

     

       277
       277
       +
         val mark_as_unseen : Types.Email.t -> Types.Email.t

     

       278
       278
       +
         

     

       279
       279
       +
         (** Mark an email as flagged/important *)

     

       280
       280
       +
         val mark_as_flagged : Types.Email.t -> Types.Email.t

     

       281
       281
       +
         

     

       282
       282
       +
         (** Remove flagged/important marking from an email *)

     

       283
       283
       +
         val unmark_flagged : Types.Email.t -> Types.Email.t

     

       284
       284
       +
         

     

       285
       285
       +
         (** Mark an email as a draft *)

     

       286
       286
       +
         val mark_as_draft : Types.Email.t -> Types.Email.t

     

       287
       287
       +
         

     

       288
       288
       +
         (** Remove draft marking from an email *)

     

       289
       289
       +
         val unmark_draft : Types.Email.t -> Types.Email.t

     

       290
       290
       +
         

     

       291
       291
       +
         (** Mark an email as answered/replied *)

     

       292
       292
       +
         val mark_as_answered : Types.Email.t -> Types.Email.t

     

       293
       293
       +
         

     

       294
       294
       +
         (** Remove answered/replied marking from an email *)

     

       295
       295
       +
         val unmark_answered : Types.Email.t -> Types.Email.t

     

       296
       296
       +
         

     

       297
       297
       +
         (** Mark an email as forwarded *)

     

       298
       298
       +
         val mark_as_forwarded : Types.Email.t -> Types.Email.t

     

       299
       299
       +
         

     

       300
       300
       +
         (** Mark an email as spam/junk *)

     

       301
       301
       +
         val mark_as_junk : Types.Email.t -> Types.Email.t

     

       302
       302
       +
         

     

       303
       303
       +
         (** Mark an email as not spam/junk *)

     

       304
       304
       +
         val mark_as_not_junk : Types.Email.t -> Types.Email.t

     

       305
       305
       +
         

     

       306
       306
       +
         (** Mark an email as phishing *)

     

       307
       307
       +
         val mark_as_phishing : Types.Email.t -> Types.Email.t

     

       308
       308
       +
         

     

       309
       309
       +
         (** {1 Extension Flag Operations} *)

     

       310
       310
       +
         

     

       311
       311
       +
         (** Mark an email for notification when replied to *)

     

       312
       312
       +
         val mark_as_notify : Types.Email.t -> Types.Email.t

     

       313
       313
       +
         

     

       314
       314
       +
         (** Remove notification flag from an email *)

     

       315
       315
       +
         val unmark_notify : Types.Email.t -> Types.Email.t

     

       316
       316
       +
         

     

       317
       317
       +
         (** Mark an email as muted (no notifications) *)

     

       318
       318
       +
         val mark_as_muted : Types.Email.t -> Types.Email.t

     

       319
       319
       +
         

     

       320
       320
       +
         (** Unmute an email (allow notifications) *)

     

       321
       321
       +
         val unmark_muted : Types.Email.t -> Types.Email.t

     

       322
       322
       +
         

     

       323
       323
       +
         (** Mark an email thread as followed for notifications *)

     

       324
       324
       +
         val mark_as_followed : Types.Email.t -> Types.Email.t

     

       325
       325
       +
         

     

       326
       326
       +
         (** Remove followed status from an email thread *)

     

       327
       327
       +
         val unmark_followed : Types.Email.t -> Types.Email.t

     

       328
       328
       +
         

     

       329
       329
       +
         (** Mark an email with a memo *)

     

       330
       330
       +
         val mark_as_memo : Types.Email.t -> Types.Email.t

     

       331
       331
       +
         

     

       332
       332
       +
         (** Mark an email with the hasmemo flag *)

     

       333
       333
       +
         val mark_as_hasmemo : Types.Email.t -> Types.Email.t

     

       334
       334
       +
         

     

       335
       335
       +
         (** Mark an email as automatically sent *)

     

       336
       336
       +
         val mark_as_autosent : Types.Email.t -> Types.Email.t

     

       337
       337
       +
         

     

       338
       338
       +
         (** Mark an email as being from an unsubscribed sender *)

     

       339
       339
       +
         val mark_as_unsubscribed : Types.Email.t -> Types.Email.t

     

       340
       340
       +
         

     

       341
       341
       +
         (** Mark an email as having unsubscribe capability *)

     

       342
       342
       +
         val mark_as_canunsubscribe : Types.Email.t -> Types.Email.t

     

       343
       343
       +
         

     

       344
       344
       +
         (** Mark an email as imported from another system *)

     

       345
       345
       +
         val mark_as_imported : Types.Email.t -> Types.Email.t

     

       346
       346
       +
         

     

       347
       347
       +
         (** Mark an email as from a trusted/verified sender *)

     

       348
       348
       +
         val mark_as_trusted : Types.Email.t -> Types.Email.t

     

       349
       349
       +
         

     

       350
       350
       +
         (** Mark an email as having masked/anonymous address *)

     

       351
       351
       +
         val mark_as_maskedemail : Types.Email.t -> Types.Email.t

     

       352
       352
       +
         

     

       353
       353
       +
         (** Mark an email as new/recent *)

     

       354
       354
       +
         val mark_as_new : Types.Email.t -> Types.Email.t

     

       355
       355
       +
         

     

       356
       356
       +
         (** Remove new/recent flag from an email *)

     

       357
       357
       +
         val unmark_new : Types.Email.t -> Types.Email.t

     

       358
       358
       +
         

     

       359
       359
       +
         (** {1 Color Flag Operations} *)

     

       360
       360
       +
         

     

       361
       361
       +
         (** Set color flag bits on an email *)

     

       362
       362
       +
         val set_color_flags : Types.Email.t -> red:bool -> orange:bool -> yellow:bool -> Types.Email.t

     

       363
       363
       +
         

     

       364
       364
       +
         (** Mark an email with a predefined color *)

     

       365
       365
       +
         val mark_as_color : Types.Email.t -> 

     

       366
       366
       +
           [`Red | `Orange | `Yellow | `Green | `Blue | `Purple | `Gray] -> Types.Email.t

     

       367
       367
       +
         

     

       368
       368
       +
         (** Remove all color flag bits from an email *)

     

       369
       369
       +
         val clear_color_flags : Types.Email.t -> Types.Email.t

     

       370
       370
       +
         

     

       371
       371
       +
         (** {1 Custom Flag Operations} *)

     

       372
       372
       +
         

     

       373
       373
       +
         (** Add a custom keyword to an email *)

     

       374
       374
       +
         val add_custom : Types.Email.t -> string -> Types.Email.t

     

       375
       375
       +
         

     

       376
       376
       +
         (** Remove a custom keyword from an email *)

     

       377
       377
       +
         val remove_custom : Types.Email.t -> string -> Types.Email.t

     

       378
       378
       +
       

     

       379
       379
       +
         (** {1 Patch Object Creation} *)

     

       380
       380
       +
       

     

       381
       381
       +
         (** Create a patch object to add a keyword to emails *)

     

       382
       382
       +
         val add_keyword_patch : Types.Keywords.keyword -> Jmap.Methods.patch_object

     

       383
       383
       +
       

     

       384
       384
       +
         (** Create a patch object to remove a keyword from emails *)

     

       385
       385
       +
         val remove_keyword_patch : Types.Keywords.keyword -> Jmap.Methods.patch_object

     

       386
       386
       +
       

     

       387
       387
       +
         (** Create a patch object to mark emails as seen/read *)

     

       388
       388
       +
         val mark_seen_patch : unit -> Jmap.Methods.patch_object

     

       389
       389
       +
       

     

       390
       390
       +
         (** Create a patch object to mark emails as unseen/unread *)

     

       391
       391
       +
         val mark_unseen_patch : unit -> Jmap.Methods.patch_object

     

       392
       392
       +
         

     

       393
       393
       +
         (** Create a patch object to set a specific color on emails *)

     

       394
       394
       +
         val set_color_patch : [`Red | `Orange | `Yellow | `Green | `Blue | `Purple | `Gray] -> 

     

       395
       395
       +
           Jmap.Methods.patch_object

     

       396
       396
       +
       end

     

       397
       397
       +
       

     

       398
       398
       +
       (** Conversion functions for JMAP/IMAP compatibility *)

     

       399
       399
       +
       module Conversion : sig

     

       400
       400
       +
         (** {1 Keyword/Flag Conversion} *)

     

       401
       401
       +
         

     

       402
       402
       +
         (** Convert a JMAP keyword variant to IMAP flag *)

     

       403
       403
       +
         val keyword_to_imap_flag : Types.Keywords.keyword -> string

     

       404
       404
       +
         

     

       405
       405
       +
         (** Convert an IMAP flag to JMAP keyword variant *)

     

       406
       406
       +
         val imap_flag_to_keyword : string -> Types.Keywords.keyword

     

       407
       407
       +
         

     

       408
       408
       +
         (** Check if a string is valid for use as a custom keyword according to RFC 8621.

     

       409
       409
       +
             @deprecated Use Keyword.is_valid instead. *)

     

       410
       410
       +
         val is_valid_custom_keyword : string -> bool

     

       411
       411
       +
         

     

       412
       412
       +
         (** Get the JMAP protocol string representation of a keyword *)

     

       413
       413
       +
         val keyword_to_string : Types.Keywords.keyword -> string

     

       414
       414
       +
         

     

       415
       415
       +
         (** Parse a JMAP protocol string into a keyword variant *)

     

       416
       416
       +
         val string_to_keyword : string -> Types.Keywords.keyword

     

       417
       417
       +
         

     

       418
       418
       +
         (** {1 Color Conversion} *)

     

       419
       419
       +
         

     

       420
       420
       +
         (** Convert a color name to the corresponding flag bit combination *)

     

       421
       421
       +
         val color_to_flags : [`Red | `Orange | `Yellow | `Green | `Blue | `Purple | `Gray] -> 

     

       422
       422
       +
           Types.Keywords.keyword list

     

       423
       423
       +
           

     

       424
       424
       +
         (** Try to determine a color from a set of keywords *)

     

       425
       425
       +
         val keywords_to_color : Types.Keywords.t -> 

     

       426
       426
       +
           [`Red | `Orange | `Yellow | `Green | `Blue | `Purple | `Gray | `None] option

     

       427
       427
       +
       end

     

       428
       428
       +
       

     

       429
       429
       +
       (** {1 Helper Functions} *)

     

       430
       430
       +
       

     

       431
       431
       +
       (** Email query filter helpers *)

     

       432
       432
       +
       module Email_filter : sig

     

       433
       433
       +
         (** Create a filter to find messages in a specific mailbox *)

     

       434
       434
       +
         val in_mailbox : id -> Jmap.Methods.Filter.t

     

       435
       435
       +
         

     

       436
       436
       +
         (** Create a filter to find messages with a specific keyword/flag *)

     

       437
       437
       +
         val has_keyword : Types.Keywords.keyword -> Jmap.Methods.Filter.t

     

       438
       438
       +
         

     

       439
       439
       +
         (** Create a filter to find messages without a specific keyword/flag *)

     

       440
       440
       +
         val not_has_keyword : Types.Keywords.keyword -> Jmap.Methods.Filter.t

     

       441
       441
       +
         

     

       442
       442
       +
         (** Create a filter to find unread messages *)

     

       443
       443
       +
         val unread : unit -> Jmap.Methods.Filter.t

     

       444
       444
       +
         

     

       445
       445
       +
         (** Create a filter to find messages with a specific subject *)

     

       446
       446
       +
         val subject : string -> Jmap.Methods.Filter.t

     

       447
       447
       +
         

     

       448
       448
       +
         (** Create a filter to find messages from a specific sender *)

     

       449
       449
       +
         val from : string -> Jmap.Methods.Filter.t

     

       450
       450
       +
         

     

       451
       451
       +
         (** Create a filter to find messages sent to a specific recipient *)

     

       452
       452
       +
         val to_ : string -> Jmap.Methods.Filter.t

     

       453
       453
       +
         

     

       454
       454
       +
         (** Create a filter to find messages with attachments *)

     

       455
       455
       +
         val has_attachment : unit -> Jmap.Methods.Filter.t

     

       456
       456
       +
         

     

       457
       457
       +
         (** Create a filter to find messages received before a date *)

     

       458
       458
       +
         val before : date -> Jmap.Methods.Filter.t

     

       459
       459
       +
         

     

       460
       460
       +
         (** Create a filter to find messages received after a date *)

     

       461
       461
       +
         val after : date -> Jmap.Methods.Filter.t

     

       462
       462
       +
         

     

       463
       463
       +
         (** Create a filter to find messages with size larger than the given bytes *)

     

       464
       464
       +
         val larger_than : uint -> Jmap.Methods.Filter.t

     

       465
       465
       +
         

     

       466
       466
       +
         (** Create a filter to find messages with size smaller than the given bytes *)

     

       467
       467
       +
         val smaller_than : uint -> Jmap.Methods.Filter.t

     

       468
       468
       +
       end

     

       469
       469
       +
       

     

       470
       470
       +
       (** Common email sorting comparators *)

     

       471
       471
       +
       module Email_sort : sig

     

       472
       472
       +
         (** Sort by received date (most recent first) *)

     

       473
       473
       +
         val received_newest_first : unit -> Jmap.Methods.Comparator.t

     

       474
       474
       +
         

     

       475
       475
       +
         (** Sort by received date (oldest first) *)

     

       476
       476
       +
         val received_oldest_first : unit -> Jmap.Methods.Comparator.t

     

       477
       477
       +
         

     

       478
       478
       +
         (** Sort by sent date (most recent first) *)

     

       479
       479
       +
         val sent_newest_first : unit -> Jmap.Methods.Comparator.t

     

       480
       480
       +
         

     

       481
       481
       +
         (** Sort by sent date (oldest first) *)

     

       482
       482
       +
         val sent_oldest_first : unit -> Jmap.Methods.Comparator.t

     

       483
       483
       +
         

     

       484
       484
       +
         (** Sort by subject (A-Z) *)

     

       485
       485
       +
         val subject_asc : unit -> Jmap.Methods.Comparator.t

     

       486
       486
       +
         

     

       487
       487
       +
         (** Sort by subject (Z-A) *)

     

       488
       488
       +
         val subject_desc : unit -> Jmap.Methods.Comparator.t

     

       489
       489
       +
         

     

       490
       490
       +
         (** Sort by size (largest first) *)

     

       491
       491
       +
         val size_largest_first : unit -> Jmap.Methods.Comparator.t

     

       492
       492
       +
         

     

       493
       493
       +
         (** Sort by size (smallest first) *)

     

       494
       494
       +
         val size_smallest_first : unit -> Jmap.Methods.Comparator.t

     

       495
       495
       +
         

     

       496
       496
       +
         (** Sort by from address (A-Z) *)

     

       497
       497
       +
         val from_asc : unit -> Jmap.Methods.Comparator.t

     

       498
       498
       +
         

     

       499
       499
       +
         (** Sort by from address (Z-A) *)

     

       500
       500
       +
         val from_desc : unit -> Jmap.Methods.Comparator.t

     

       501
       501
       +
       end

     

       502
       502
       +
       

     

       503
       503
       +
       (** High-level email operations are implemented in the Jmap.Unix.Email module *)

+519

jmap-email/jmap_email_types.mli

···

       1
       1
       +
       (** Common types for JMAP Mail (RFC 8621). *)

     

       2
       2
       +
       

     

       3
       3
       +
       open Jmap.Types

     

       4
       4
       +
       

     

       5
       5
       +
       (** Represents an email address with an optional name.

     

       6
       6
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.2.3> RFC 8621, Section 4.1.2.3 *)

     

       7
       7
       +
       module Email_address : sig

     

       8
       8
       +
         type t

     

       9
       9
       +
       

     

       10
       10
       +
         (** Get the display name for the address (if any) *)

     

       11
       11
       +
         val name : t -> string option

     

       12
       12
       +
         

     

       13
       13
       +
         (** Get the email address *)

     

       14
       14
       +
         val email : t -> string

     

       15
       15
       +
         

     

       16
       16
       +
         (** Create a new email address *)

     

       17
       17
       +
         val v : 

     

       18
       18
       +
           ?name:string -> 

     

       19
       19
       +
           email:string -> 

     

       20
       20
       +
           unit -> t

     

       21
       21
       +
       end

     

       22
       22
       +
       

     

       23
       23
       +
       (** Represents a group of email addresses.

     

       24
       24
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.2.4> RFC 8621, Section 4.1.2.4 *)

     

       25
       25
       +
       module Email_address_group : sig

     

       26
       26
       +
         type t

     

       27
       27
       +
         

     

       28
       28
       +
         (** Get the name of the group (if any) *)

     

       29
       29
       +
         val name : t -> string option

     

       30
       30
       +
         

     

       31
       31
       +
         (** Get the list of addresses in the group *)

     

       32
       32
       +
         val addresses : t -> Email_address.t list

     

       33
       33
       +
         

     

       34
       34
       +
         (** Create a new address group *)

     

       35
       35
       +
         val v : 

     

       36
       36
       +
           ?name:string -> 

     

       37
       37
       +
           addresses:Email_address.t list -> 

     

       38
       38
       +
           unit -> t

     

       39
       39
       +
       end

     

       40
       40
       +
       

     

       41
       41
       +
       (** Represents a header field (name and raw value).

     

       42
       42
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.3> RFC 8621, Section 4.1.3 *)

     

       43
       43
       +
       module Email_header : sig

     

       44
       44
       +
         type t

     

       45
       45
       +
         

     

       46
       46
       +
         (** Get the header field name *)

     

       47
       47
       +
         val name : t -> string

     

       48
       48
       +
         

     

       49
       49
       +
         (** Get the raw header field value *)

     

       50
       50
       +
         val value : t -> string

     

       51
       51
       +
         

     

       52
       52
       +
         (** Create a new header field *)

     

       53
       53
       +
         val v : 

     

       54
       54
       +
           name:string -> 

     

       55
       55
       +
           value:string -> 

     

       56
       56
       +
           unit -> t

     

       57
       57
       +
       end

     

       58
       58
       +
       

     

       59
       59
       +
       (** Represents a body part within an Email's MIME structure.

     

       60
       60
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.4> RFC 8621, Section 4.1.4 *)

     

       61
       61
       +
       module Email_body_part : sig

     

       62
       62
       +
         type t

     

       63
       63
       +
         

     

       64
       64
       +
         (** Get the part ID (null only for multipart types) *)

     

       65
       65
       +
         val id : t -> string option

     

       66
       66
       +
         

     

       67
       67
       +
         (** Get the blob ID (null only for multipart types) *)

     

       68
       68
       +
         val blob_id : t -> id option

     

       69
       69
       +
         

     

       70
       70
       +
         (** Get the size of the part in bytes *)

     

       71
       71
       +
         val size : t -> uint

     

       72
       72
       +
         

     

       73
       73
       +
         (** Get the list of headers for this part *)

     

       74
       74
       +
         val headers : t -> Email_header.t list

     

       75
       75
       +
         

     

       76
       76
       +
         (** Get the filename (if any) *)

     

       77
       77
       +
         val name : t -> string option

     

       78
       78
       +
         

     

       79
       79
       +
         (** Get the MIME type *)

     

       80
       80
       +
         val mime_type : t -> string

     

       81
       81
       +
         

     

       82
       82
       +
         (** Get the charset (if any) *)

     

       83
       83
       +
         val charset : t -> string option

     

       84
       84
       +
         

     

       85
       85
       +
         (** Get the content disposition (if any) *)

     

       86
       86
       +
         val disposition : t -> string option

     

       87
       87
       +
         

     

       88
       88
       +
         (** Get the content ID (if any) *)

     

       89
       89
       +
         val cid : t -> string option

     

       90
       90
       +
         

     

       91
       91
       +
         (** Get the list of languages (if any) *)

     

       92
       92
       +
         val language : t -> string list option

     

       93
       93
       +
         

     

       94
       94
       +
         (** Get the content location (if any) *)

     

       95
       95
       +
         val location : t -> string option

     

       96
       96
       +
         

     

       97
       97
       +
         (** Get the sub-parts (only for multipart types) *)

     

       98
       98
       +
         val sub_parts : t -> t list option

     

       99
       99
       +
         

     

       100
       100
       +
         (** Get any other requested headers (header properties) *)

     

       101
       101
       +
         val other_headers : t -> Yojson.Safe.t string_map

     

       102
       102
       +
         

     

       103
       103
       +
         (** Create a new body part *)

     

       104
       104
       +
         val v :

     

       105
       105
       +
           ?id:string ->

     

       106
       106
       +
           ?blob_id:id ->

     

       107
       107
       +
           size:uint ->

     

       108
       108
       +
           headers:Email_header.t list ->

     

       109
       109
       +
           ?name:string ->

     

       110
       110
       +
           mime_type:string ->

     

       111
       111
       +
           ?charset:string ->

     

       112
       112
       +
           ?disposition:string ->

     

       113
       113
       +
           ?cid:string ->

     

       114
       114
       +
           ?language:string list ->

     

       115
       115
       +
           ?location:string ->

     

       116
       116
       +
           ?sub_parts:t list ->

     

       117
       117
       +
           ?other_headers:Yojson.Safe.t string_map ->

     

       118
       118
       +
           unit -> t

     

       119
       119
       +
       end

     

       120
       120
       +
       

     

       121
       121
       +
       (** Represents the decoded value of a text body part.

     

       122
       122
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.4> RFC 8621, Section 4.1.4 *)

     

       123
       123
       +
       module Email_body_value : sig

     

       124
       124
       +
         type t 

     

       125
       125
       +
         

     

       126
       126
       +
         (** Get the decoded text content *)

     

       127
       127
       +
         val value : t -> string

     

       128
       128
       +
         

     

       129
       129
       +
         (** Check if there was an encoding problem *)

     

       130
       130
       +
         val has_encoding_problem : t -> bool

     

       131
       131
       +
         

     

       132
       132
       +
         (** Check if the content was truncated *)

     

       133
       133
       +
         val is_truncated : t -> bool

     

       134
       134
       +
         

     

       135
       135
       +
         (** Create a new body value *)

     

       136
       136
       +
         val v :

     

       137
       137
       +
           value:string ->

     

       138
       138
       +
           ?encoding_problem:bool ->

     

       139
       139
       +
           ?truncated:bool ->

     

       140
       140
       +
           unit -> t

     

       141
       141
       +
       end

     

       142
       142
       +
       

     

       143
       143
       +
       (** Type to represent email message flags/keywords.

     

       144
       144
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1.1> RFC 8621, Section 4.1.1 *)

     

       145
       145
       +
       module Keywords : sig

     

       146
       146
       +
         (** Represents different types of JMAP keywords *)

     

       147
       147
       +
         type keyword =

     

       148
       148
       +
           | Draft      (** "$draft": The Email is a draft the user is composing *)

     

       149
       149
       +
           | Seen       (** "$seen": The Email has been read *)

     

       150
       150
       +
           | Flagged    (** "$flagged": The Email has been flagged for urgent/special attention *)

     

       151
       151
       +
           | Answered   (** "$answered": The Email has been replied to *)

     

       152
       152
       +
           

     

       153
       153
       +
           (* Common extension keywords from RFC 5788 *)

     

       154
       154
       +
           | Forwarded  (** "$forwarded": The Email has been forwarded *)

     

       155
       155
       +
           | Phishing   (** "$phishing": The Email is likely to be phishing *)

     

       156
       156
       +
           | Junk       (** "$junk": The Email is spam/junk *)

     

       157
       157
       +
           | NotJunk    (** "$notjunk": The Email is explicitly marked as not spam/junk *)

     

       158
       158
       +
           

     

       159
       159
       +
           (* Apple Mail and other vendor extension keywords from draft-ietf-mailmaint-messageflag-mailboxattribute *)

     

       160
       160
       +
           | Notify     (** "$notify": Request to be notified when this email gets a reply *)

     

       161
       161
       +
           | Muted      (** "$muted": Email is muted (notifications disabled) *)

     

       162
       162
       +
           | Followed   (** "$followed": Email thread is followed for notifications *)

     

       163
       163
       +
           | Memo       (** "$memo": Email has a memo/note associated with it *)

     

       164
       164
       +
           | HasMemo    (** "$hasmemo": Email has a memo, annotation or note property *)

     

       165
       165
       +
           | Autosent   (** "$autosent": Email was generated or sent automatically *)

     

       166
       166
       +
           | Unsubscribed (** "$unsubscribed": User has unsubscribed from this sender *)

     

       167
       167
       +
           | CanUnsubscribe (** "$canunsubscribe": Email contains unsubscribe information *)

     

       168
       168
       +
           | Imported   (** "$imported": Email was imported from another system *)

     

       169
       169
       +
           | IsTrusted  (** "$istrusted": Email is from a trusted/verified sender *)

     

       170
       170
       +
           | MaskedEmail (** "$maskedemail": Email is to/from a masked/anonymous address *)

     

       171
       171
       +
           | New        (** "$new": Email was recently delivered *)

     

       172
       172
       +
           

     

       173
       173
       +
           (* Apple Mail flag colors (color bit flags) *)

     

       174
       174
       +
           | MailFlagBit0 (** "$MailFlagBit0": First color flag bit (red) *)

     

       175
       175
       +
           | MailFlagBit1 (** "$MailFlagBit1": Second color flag bit (orange) *)

     

       176
       176
       +
           | MailFlagBit2 (** "$MailFlagBit2": Third color flag bit (yellow) *)

     

       177
       177
       +
           | Custom of string  (** Arbitrary user-defined keyword *)

     

       178
       178
       +
       

     

       179
       179
       +
         (** A set of keywords applied to an email *)

     

       180
       180
       +
         type t = keyword list

     

       181
       181
       +
       

     

       182
       182
       +
         (** Check if an email has the draft flag *)

     

       183
       183
       +
         val is_draft : t -> bool

     

       184
       184
       +
         

     

       185
       185
       +
         (** Check if an email has been read *)

     

       186
       186
       +
         val is_seen : t -> bool

     

       187
       187
       +
         

     

       188
       188
       +
         (** Check if an email has neither been read nor is a draft *)

     

       189
       189
       +
         val is_unread : t -> bool

     

       190
       190
       +
         

     

       191
       191
       +
         (** Check if an email has been flagged *)

     

       192
       192
       +
         val is_flagged : t -> bool

     

       193
       193
       +
         

     

       194
       194
       +
         (** Check if an email has been replied to *)

     

       195
       195
       +
         val is_answered : t -> bool

     

       196
       196
       +
         

     

       197
       197
       +
         (** Check if an email has been forwarded *)

     

       198
       198
       +
         val is_forwarded : t -> bool

     

       199
       199
       +
         

     

       200
       200
       +
         (** Check if an email is marked as likely phishing *)

     

       201
       201
       +
         val is_phishing : t -> bool

     

       202
       202
       +
         

     

       203
       203
       +
         (** Check if an email is marked as junk/spam *)

     

       204
       204
       +
         val is_junk : t -> bool

     

       205
       205
       +
         

     

       206
       206
       +
         (** Check if an email is explicitly marked as not junk/spam *)

     

       207
       207
       +
         val is_not_junk : t -> bool

     

       208
       208
       +
         

     

       209
       209
       +
         (** Check if a specific custom keyword is set *)

     

       210
       210
       +
         val has_keyword : t -> string -> bool

     

       211
       211
       +
         

     

       212
       212
       +
         (** Get a list of all custom keywords (excluding system keywords) *)

     

       213
       213
       +
         val custom_keywords : t -> string list

     

       214
       214
       +
         

     

       215
       215
       +
         (** Add a keyword to the set *)

     

       216
       216
       +
         val add : t -> keyword -> t

     

       217
       217
       +
         

     

       218
       218
       +
         (** Remove a keyword from the set *)

     

       219
       219
       +
         val remove : t -> keyword -> t

     

       220
       220
       +
         

     

       221
       221
       +
         (** Create an empty keyword set *)

     

       222
       222
       +
         val empty : unit -> t

     

       223
       223
       +
         

     

       224
       224
       +
         (** Create a new keyword set with the specified keywords *)

     

       225
       225
       +
         val of_list : keyword list -> t

     

       226
       226
       +
         

     

       227
       227
       +
         (** Get the string representation of a keyword as used in the JMAP protocol *)

     

       228
       228
       +
         val to_string : keyword -> string

     

       229
       229
       +
         

     

       230
       230
       +
         (** Parse a string into a keyword *)

     

       231
       231
       +
         val of_string : string -> keyword

     

       232
       232
       +
         

     

       233
       233
       +
         (** Convert keyword set to string map representation as used in JMAP *)

     

       234
       234
       +
         val to_map : t -> bool string_map

     

       235
       235
       +
       end

     

       236
       236
       +
       

     

       237
       237
       +
       (** Email properties enum.

     

       238
       238
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1> RFC 8621, Section 4.1 *)

     

       239
       239
       +
       type email_property =

     

       240
       240
       +
         | Id               (** The id of the email *)

     

       241
       241
       +
         | BlobId           (** The id of the blob containing the raw message *)

     

       242
       242
       +
         | ThreadId         (** The id of the thread this email belongs to *)

     

       243
       243
       +
         | MailboxIds       (** The mailboxes this email belongs to *)

     

       244
       244
       +
         | Keywords         (** The keywords/flags for this email *)

     

       245
       245
       +
         | Size             (** Size of the message in bytes *)

     

       246
       246
       +
         | ReceivedAt       (** When the message was received by the server *)

     

       247
       247
       +
         | MessageId        (** Value of the Message-ID header *)

     

       248
       248
       +
         | InReplyTo        (** Value of the In-Reply-To header *)

     

       249
       249
       +
         | References       (** Value of the References header *)

     

       250
       250
       +
         | Sender           (** Value of the Sender header *)

     

       251
       251
       +
         | From             (** Value of the From header *)

     

       252
       252
       +
         | To               (** Value of the To header *)

     

       253
       253
       +
         | Cc               (** Value of the Cc header *)

     

       254
       254
       +
         | Bcc              (** Value of the Bcc header *)

     

       255
       255
       +
         | ReplyTo          (** Value of the Reply-To header *)

     

       256
       256
       +
         | Subject          (** Value of the Subject header *)

     

       257
       257
       +
         | SentAt           (** Value of the Date header *)

     

       258
       258
       +
         | HasAttachment    (** Whether the email has attachments *)

     

       259
       259
       +
         | Preview          (** Preview text of the email *)

     

       260
       260
       +
         | BodyStructure    (** MIME structure of the email *)

     

       261
       261
       +
         | BodyValues       (** Decoded body part values *)

     

       262
       262
       +
         | TextBody         (** Text body parts *)

     

       263
       263
       +
         | HtmlBody         (** HTML body parts *)

     

       264
       264
       +
         | Attachments      (** Attachments *)

     

       265
       265
       +
         | Header of string (** Specific header *)

     

       266
       266
       +
         | Other of string  (** Extension property *)

     

       267
       267
       +
       

     

       268
       268
       +
       (** Represents an Email object.

     

       269
       269
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.1> RFC 8621, Section 4.1 *)

     

       270
       270
       +
       module Email : sig

     

       271
       271
       +
         (** Email type *)

     

       272
       272
       +
         type t

     

       273
       273
       +
         

     

       274
       274
       +
         (** ID of the email *)

     

       275
       275
       +
         val id : t -> id option

     

       276
       276
       +
         

     

       277
       277
       +
         (** ID of the blob containing the raw message *)

     

       278
       278
       +
         val blob_id : t -> id option

     

       279
       279
       +
         

     

       280
       280
       +
         (** ID of the thread this email belongs to *)

     

       281
       281
       +
         val thread_id : t -> id option

     

       282
       282
       +
         

     

       283
       283
       +
         (** The set of mailbox IDs this email belongs to *)

     

       284
       284
       +
         val mailbox_ids : t -> bool id_map option

     

       285
       285
       +
         

     

       286
       286
       +
         (** The set of keywords/flags for this email *)

     

       287
       287
       +
         val keywords : t -> Keywords.t option

     

       288
       288
       +
         

     

       289
       289
       +
         (** Size of the message in bytes *)

     

       290
       290
       +
         val size : t -> uint option

     

       291
       291
       +
         

     

       292
       292
       +
         (** When the message was received by the server *)

     

       293
       293
       +
         val received_at : t -> date option

     

       294
       294
       +
         

     

       295
       295
       +
         (** Subject of the email (if requested) *)

     

       296
       296
       +
         val subject : t -> string option

     

       297
       297
       +
         

     

       298
       298
       +
         (** Preview text of the email (if requested) *)

     

       299
       299
       +
         val preview : t -> string option

     

       300
       300
       +
         

     

       301
       301
       +
         (** From addresses (if requested) *)

     

       302
       302
       +
         val from : t -> Email_address.t list option

     

       303
       303
       +
         

     

       304
       304
       +
         (** To addresses (if requested) *)

     

       305
       305
       +
         val to_ : t -> Email_address.t list option

     

       306
       306
       +
         

     

       307
       307
       +
         (** CC addresses (if requested) *)

     

       308
       308
       +
         val cc : t -> Email_address.t list option

     

       309
       309
       +
         

     

       310
       310
       +
         (** Message ID values (if requested) *)

     

       311
       311
       +
         val message_id : t -> string list option

     

       312
       312
       +
         

     

       313
       313
       +
         (** Get whether the email has attachments (if requested) *)

     

       314
       314
       +
         val has_attachment : t -> bool option

     

       315
       315
       +
         

     

       316
       316
       +
         (** Get text body parts (if requested) *)

     

       317
       317
       +
         val text_body : t -> Email_body_part.t list option

     

       318
       318
       +
         

     

       319
       319
       +
         (** Get HTML body parts (if requested) *)

     

       320
       320
       +
         val html_body : t -> Email_body_part.t list option

     

       321
       321
       +
         

     

       322
       322
       +
         (** Get attachments (if requested) *)

     

       323
       323
       +
         val attachments : t -> Email_body_part.t list option

     

       324
       324
       +
         

     

       325
       325
       +
         (** Create a new Email object from a server response or for a new email *)

     

       326
       326
       +
         val create :

     

       327
       327
       +
           ?id:id ->

     

       328
       328
       +
           ?blob_id:id ->

     

       329
       329
       +
           ?thread_id:id ->

     

       330
       330
       +
           ?mailbox_ids:bool id_map ->

     

       331
       331
       +
           ?keywords:Keywords.t ->

     

       332
       332
       +
           ?size:uint ->

     

       333
       333
       +
           ?received_at:date ->

     

       334
       334
       +
           ?subject:string ->

     

       335
       335
       +
           ?preview:string ->

     

       336
       336
       +
           ?from:Email_address.t list ->

     

       337
       337
       +
           ?to_:Email_address.t list ->

     

       338
       338
       +
           ?cc:Email_address.t list ->

     

       339
       339
       +
           ?message_id:string list ->

     

       340
       340
       +
           ?has_attachment:bool ->

     

       341
       341
       +
           ?text_body:Email_body_part.t list ->

     

       342
       342
       +
           ?html_body:Email_body_part.t list ->

     

       343
       343
       +
           ?attachments:Email_body_part.t list ->

     

       344
       344
       +
           unit -> t

     

       345
       345
       +
           

     

       346
       346
       +
         (** Create a patch object for updating email properties *)

     

       347
       347
       +
         val make_patch :

     

       348
       348
       +
           ?add_keywords:Keywords.t ->

     

       349
       349
       +
           ?remove_keywords:Keywords.t ->

     

       350
       350
       +
           ?add_mailboxes:id list ->

     

       351
       351
       +
           ?remove_mailboxes:id list ->

     

       352
       352
       +
           unit -> Jmap.Methods.patch_object

     

       353
       353
       +
         

     

       354
       354
       +
         (** Extract the ID from an email, returning a Result *)

     

       355
       355
       +
         val get_id : t -> (id, string) result

     

       356
       356
       +
         

     

       357
       357
       +
         (** Take the ID from an email (fails with an exception if not present) *)

     

       358
       358
       +
         val take_id : t -> id

     

       359
       359
       +
       end

     

       360
       360
       +
       

     

       361
       361
       +
       (** Email/import method arguments and responses.

     

       362
       362
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.8> RFC 8621, Section 4.8 *)

     

       363
       363
       +
       module Import : sig

     

       364
       364
       +
         (** Arguments for Email/import method *)

     

       365
       365
       +
         type args = {

     

       366
       366
       +
           account_id : id;

     

       367
       367
       +
           blob_ids : id list;

     

       368
       368
       +
           mailbox_ids : id id_map;

     

       369
       369
       +
           keywords : Keywords.t option;

     

       370
       370
       +
           received_at : date option;

     

       371
       371
       +
         }

     

       372
       372
       +
       

     

       373
       373
       +
         (** Create import arguments *)

     

       374
       374
       +
         val create_args :

     

       375
       375
       +
           account_id:id ->

     

       376
       376
       +
           blob_ids:id list ->

     

       377
       377
       +
           mailbox_ids:id id_map ->

     

       378
       378
       +
           ?keywords:Keywords.t ->

     

       379
       379
       +
           ?received_at:date ->

     

       380
       380
       +
           unit -> args

     

       381
       381
       +
       

     

       382
       382
       +
         (** Response for a single imported email *)

     

       383
       383
       +
         type email_import_result = {

     

       384
       384
       +
           blob_id : id;

     

       385
       385
       +
           email : Email.t;

     

       386
       386
       +
         }

     

       387
       387
       +
       

     

       388
       388
       +
         (** Create an email import result *)

     

       389
       389
       +
         val create_result :

     

       390
       390
       +
           blob_id:id ->

     

       391
       391
       +
           email:Email.t ->

     

       392
       392
       +
           unit -> email_import_result

     

       393
       393
       +
       

     

       394
       394
       +
         (** Response for Email/import method *)

     

       395
       395
       +
         type response = {

     

       396
       396
       +
           account_id : id;

     

       397
       397
       +
           created : email_import_result id_map;

     

       398
       398
       +
           not_created : Jmap.Error.Set_error.t id_map;

     

       399
       399
       +
         }

     

       400
       400
       +
       

     

       401
       401
       +
         (** Create import response *)

     

       402
       402
       +
         val create_response :

     

       403
       403
       +
           account_id:id ->

     

       404
       404
       +
           created:email_import_result id_map ->

     

       405
       405
       +
           not_created:Jmap.Error.Set_error.t id_map ->

     

       406
       406
       +
           unit -> response

     

       407
       407
       +
       end

     

       408
       408
       +
       

     

       409
       409
       +
       (** Email/parse method arguments and responses.

     

       410
       410
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.9> RFC 8621, Section 4.9 *)

     

       411
       411
       +
       module Parse : sig

     

       412
       412
       +
         (** Arguments for Email/parse method *)

     

       413
       413
       +
         type args = {

     

       414
       414
       +
           account_id : id;

     

       415
       415
       +
           blob_ids : id list;

     

       416
       416
       +
           properties : string list option;

     

       417
       417
       +
         }

     

       418
       418
       +
       

     

       419
       419
       +
         (** Create parse arguments *)

     

       420
       420
       +
         val create_args :

     

       421
       421
       +
           account_id:id ->

     

       422
       422
       +
           blob_ids:id list ->

     

       423
       423
       +
           ?properties:string list ->

     

       424
       424
       +
           unit -> args

     

       425
       425
       +
       

     

       426
       426
       +
         (** Response for a single parsed email *)

     

       427
       427
       +
         type email_parse_result = {

     

       428
       428
       +
           blob_id : id;

     

       429
       429
       +
           parsed : Email.t;

     

       430
       430
       +
         }

     

       431
       431
       +
       

     

       432
       432
       +
         (** Create an email parse result *)

     

       433
       433
       +
         val create_result :

     

       434
       434
       +
           blob_id:id ->

     

       435
       435
       +
           parsed:Email.t ->

     

       436
       436
       +
           unit -> email_parse_result

     

       437
       437
       +
       

     

       438
       438
       +
         (** Response for Email/parse method *)

     

       439
       439
       +
         type response = {

     

       440
       440
       +
           account_id : id;

     

       441
       441
       +
           parsed : email_parse_result id_map;

     

       442
       442
       +
           not_parsed : string id_map;

     

       443
       443
       +
         }

     

       444
       444
       +
       

     

       445
       445
       +
         (** Create parse response *)

     

       446
       446
       +
         val create_response :

     

       447
       447
       +
           account_id:id ->

     

       448
       448
       +
           parsed:email_parse_result id_map ->

     

       449
       449
       +
           not_parsed:string id_map ->

     

       450
       450
       +
           unit -> response

     

       451
       451
       +
       end

     

       452
       452
       +
       

     

       453
       453
       +
       (** Email import options. 

     

       454
       454
       +
           @deprecated Use Import.args instead.

     

       455
       455
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.8> RFC 8621, Section 4.8 *)

     

       456
       456
       +
       type email_import_options = {

     

       457
       457
       +
         import_to_mailboxes : id list;

     

       458
       458
       +
         import_keywords : Keywords.t option;

     

       459
       459
       +
         import_received_at : date option;

     

       460
       460
       +
       }

     

       461
       461
       +
       

     

       462
       462
       +
       (** Email/copy method arguments and responses.

     

       463
       463
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.7> RFC 8621, Section 4.7 *)

     

       464
       464
       +
       module Copy : sig

     

       465
       465
       +
         (** Arguments for Email/copy method *)

     

       466
       466
       +
         type args = {

     

       467
       467
       +
           from_account_id : id;

     

       468
       468
       +
           account_id : id;

     

       469
       469
       +
           create : (id * id id_map) id_map;

     

       470
       470
       +
           on_success_destroy_original : bool option;

     

       471
       471
       +
           destroy_from_if_in_state : string option;

     

       472
       472
       +
         }

     

       473
       473
       +
       

     

       474
       474
       +
         (** Create copy arguments *)

     

       475
       475
       +
         val create_args :

     

       476
       476
       +
           from_account_id:id ->

     

       477
       477
       +
           account_id:id ->

     

       478
       478
       +
           create:(id * id id_map) id_map ->

     

       479
       479
       +
           ?on_success_destroy_original:bool ->

     

       480
       480
       +
           ?destroy_from_if_in_state:string ->

     

       481
       481
       +
           unit -> args

     

       482
       482
       +
       

     

       483
       483
       +
         (** Response for Email/copy method *)

     

       484
       484
       +
         type response = {

     

       485
       485
       +
           from_account_id : id;

     

       486
       486
       +
           account_id : id;

     

       487
       487
       +
           created : Email.t id_map option;

     

       488
       488
       +
           not_created : Jmap.Error.Set_error.t id_map option;

     

       489
       489
       +
         }

     

       490
       490
       +
       

     

       491
       491
       +
         (** Create copy response *)

     

       492
       492
       +
         val create_response :

     

       493
       493
       +
           from_account_id:id ->

     

       494
       494
       +
           account_id:id ->

     

       495
       495
       +
           ?created:Email.t id_map ->

     

       496
       496
       +
           ?not_created:Jmap.Error.Set_error.t id_map ->

     

       497
       497
       +
           unit -> response

     

       498
       498
       +
       end

     

       499
       499
       +
       

     

       500
       500
       +
       (** Email copy options.

     

       501
       501
       +
           @deprecated Use Copy.args instead.

     

       502
       502
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-4.7> RFC 8621, Section 4.7 *)

     

       503
       503
       +
       type email_copy_options = {

     

       504
       504
       +
         copy_to_account_id : id;

     

       505
       505
       +
         copy_to_mailboxes : id list;

     

       506
       506
       +
         copy_on_success_destroy_original : bool option;

     

       507
       507
       +
       }

     

       508
       508
       +
       

     

       509
       509
       +
       (** Convert a property variant to its string representation *)

     

       510
       510
       +
       val email_property_to_string : email_property -> string

     

       511
       511
       +
       

     

       512
       512
       +
       (** Parse a string into a property variant *)

     

       513
       513
       +
       val string_to_email_property : string -> email_property

     

       514
       514
       +
       

     

       515
       515
       +
       (** Get a list of common properties useful for displaying email lists *)

     

       516
       516
       +
       val common_email_properties : email_property list

     

       517
       517
       +
       

     

       518
       518
       +
       (** Get a list of common properties for detailed email view *)

     

       519
       519
       +
       val detailed_email_properties : email_property list

+114

jmap-email/jmap_identity.mli

···

       1
       1
       +
       (** JMAP Identity.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-6> RFC 8621, Section 6 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap.Types

     

       5
       5
       +
       open Jmap.Methods

     

       6
       6
       +
       

     

       7
       7
       +
       (** Identity object.

     

       8
       8
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-6> RFC 8621, Section 6 *)

     

       9
       9
       +
       type t

     

       10
       10
       +
       

     

       11
       11
       +
       (** Get the identity ID (immutable, server-set) *)

     

       12
       12
       +
       val id : t -> id

     

       13
       13
       +
       

     

       14
       14
       +
       (** Get the display name (defaults to "") *)

     

       15
       15
       +
       val name : t -> string

     

       16
       16
       +
       

     

       17
       17
       +
       (** Get the email address (immutable) *)

     

       18
       18
       +
       val email : t -> string

     

       19
       19
       +
       

     

       20
       20
       +
       (** Get the reply-to addresses (if any) *)

     

       21
       21
       +
       val reply_to : t -> Jmap_email_types.Email_address.t list option

     

       22
       22
       +
       

     

       23
       23
       +
       (** Get the bcc addresses (if any) *)

     

       24
       24
       +
       val bcc : t -> Jmap_email_types.Email_address.t list option

     

       25
       25
       +
       

     

       26
       26
       +
       (** Get the plain text signature (defaults to "") *)

     

       27
       27
       +
       val text_signature : t -> string

     

       28
       28
       +
       

     

       29
       29
       +
       (** Get the HTML signature (defaults to "") *)

     

       30
       30
       +
       val html_signature : t -> string

     

       31
       31
       +
       

     

       32
       32
       +
       (** Check if this identity may be deleted (server-set) *)

     

       33
       33
       +
       val may_delete : t -> bool

     

       34
       34
       +
       

     

       35
       35
       +
       (** Create a new identity object *)

     

       36
       36
       +
       val v :

     

       37
       37
       +
         id:id ->

     

       38
       38
       +
         ?name:string ->

     

       39
       39
       +
         email:string ->

     

       40
       40
       +
         ?reply_to:Jmap_email_types.Email_address.t list ->

     

       41
       41
       +
         ?bcc:Jmap_email_types.Email_address.t list ->

     

       42
       42
       +
         ?text_signature:string ->

     

       43
       43
       +
         ?html_signature:string ->

     

       44
       44
       +
         may_delete:bool ->

     

       45
       45
       +
         unit -> t

     

       46
       46
       +
         

     

       47
       47
       +
       (** Types and functions for identity creation and updates *)

     

       48
       48
       +
       module Create : sig

     

       49
       49
       +
         type t

     

       50
       50
       +
         

     

       51
       51
       +
         (** Get the name (if specified) *)

     

       52
       52
       +
         val name : t -> string option

     

       53
       53
       +
         

     

       54
       54
       +
         (** Get the email address *)

     

       55
       55
       +
         val email : t -> string

     

       56
       56
       +
         

     

       57
       57
       +
         (** Get the reply-to addresses (if any) *)

     

       58
       58
       +
         val reply_to : t -> Jmap_email_types.Email_address.t list option

     

       59
       59
       +
         

     

       60
       60
       +
         (** Get the bcc addresses (if any) *)

     

       61
       61
       +
         val bcc : t -> Jmap_email_types.Email_address.t list option

     

       62
       62
       +
         

     

       63
       63
       +
         (** Get the plain text signature (if specified) *)

     

       64
       64
       +
         val text_signature : t -> string option

     

       65
       65
       +
         

     

       66
       66
       +
         (** Get the HTML signature (if specified) *)

     

       67
       67
       +
         val html_signature : t -> string option

     

       68
       68
       +
         

     

       69
       69
       +
         (** Create a new identity creation object *)

     

       70
       70
       +
         val v :

     

       71
       71
       +
           ?name:string ->

     

       72
       72
       +
           email:string ->

     

       73
       73
       +
           ?reply_to:Jmap_email_types.Email_address.t list ->

     

       74
       74
       +
           ?bcc:Jmap_email_types.Email_address.t list ->

     

       75
       75
       +
           ?text_signature:string ->

     

       76
       76
       +
           ?html_signature:string ->

     

       77
       77
       +
           unit -> t

     

       78
       78
       +
           

     

       79
       79
       +
         (** Server response with info about the created identity *)

     

       80
       80
       +
         module Response : sig

     

       81
       81
       +
           type t

     

       82
       82
       +
           

     

       83
       83
       +
           (** Get the server-assigned ID for the created identity *)

     

       84
       84
       +
           val id : t -> id

     

       85
       85
       +
           

     

       86
       86
       +
           (** Check if this identity may be deleted *)

     

       87
       87
       +
           val may_delete : t -> bool

     

       88
       88
       +
           

     

       89
       89
       +
           (** Create a new response object *)

     

       90
       90
       +
           val v :

     

       91
       91
       +
             id:id ->

     

       92
       92
       +
             may_delete:bool ->

     

       93
       93
       +
             unit -> t

     

       94
       94
       +
         end

     

       95
       95
       +
       end

     

       96
       96
       +
       

     

       97
       97
       +
       (** Identity object for update.

     

       98
       98
       +
           Patch object, specific structure not enforced here.

     

       99
       99
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-6.3> RFC 8621, Section 6.3 *)

     

       100
       100
       +
       type update = patch_object

     

       101
       101
       +
       

     

       102
       102
       +
       (** Server-set/computed info for updated identity.

     

       103
       103
       +
           Contains only changed server-set props.

     

       104
       104
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-6.3> RFC 8621, Section 6.3 *)

     

       105
       105
       +
       module Update_response : sig

     

       106
       106
       +
         type t

     

       107
       107
       +
         

     

       108
       108
       +
         (** Convert to a full Identity object (contains only changed server-set props) *)

     

       109
       109
       +
         val to_identity : t -> t

     

       110
       110
       +
         

     

       111
       111
       +
         (** Create from a full Identity object *)

     

       112
       112
       +
         val of_identity : t -> t

     

       113
       113
       +
       end

     

       114
       114
       +

+187

jmap-email/jmap_mailbox.mli

···

       1
       1
       +
       (** JMAP Mailbox.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap.Types

     

       5
       5
       +
       open Jmap.Methods

     

       6
       6
       +
       

     

       7
       7
       +
       (** Standard mailbox roles as defined in RFC 8621.

     

       8
       8
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       9
       9
       +
       type role =

     

       10
       10
       +
         | Inbox     (** Messages in the primary inbox *)

     

       11
       11
       +
         | Archive   (** Archived messages *)

     

       12
       12
       +
         | Drafts    (** Draft messages being composed *)

     

       13
       13
       +
         | Sent      (** Messages that have been sent *)

     

       14
       14
       +
         | Trash     (** Messages that have been deleted *)

     

       15
       15
       +
         | Junk      (** Messages determined to be spam *)

     

       16
       16
       +
         | Important (** Messages deemed important *)

     

       17
       17
       +
         | Snoozed    (** Messages snoozed for later notification/reappearance, from draft-ietf-mailmaint-messageflag-mailboxattribute *)

     

       18
       18
       +
         | Scheduled  (** Messages scheduled for sending at a later time, from draft-ietf-mailmaint-messageflag-mailboxattribute *)

     

       19
       19
       +
         | Memos      (** Messages containing memos or notes, from draft-ietf-mailmaint-messageflag-mailboxattribute *)

     

       20
       20
       +
         

     

       21
       21
       +
         | Other of string (** Custom or non-standard role *)

     

       22
       22
       +
         | None      (** No specific role assigned *)

     

       23
       23
       +
       

     

       24
       24
       +
       (** Mailbox property identifiers.

     

       25
       25
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       26
       26
       +
       type property =

     

       27
       27
       +
         | Id            (** The id of the mailbox *)

     

       28
       28
       +
         | Name          (** The name of the mailbox *)

     

       29
       29
       +
         | ParentId      (** The id of the parent mailbox *)

     

       30
       30
       +
         | Role          (** The role of the mailbox *)

     

       31
       31
       +
         | SortOrder     (** The sort order of the mailbox *)

     

       32
       32
       +
         | TotalEmails   (** The total number of emails in the mailbox *)

     

       33
       33
       +
         | UnreadEmails  (** The number of unread emails in the mailbox *)

     

       34
       34
       +
         | TotalThreads  (** The total number of threads in the mailbox *)

     

       35
       35
       +
         | UnreadThreads (** The number of unread threads in the mailbox *)

     

       36
       36
       +
         | MyRights      (** The rights the user has for the mailbox *)

     

       37
       37
       +
         | IsSubscribed  (** Whether the mailbox is subscribed to *)

     

       38
       38
       +
         | Other of string (** Any server-specific extension properties *)

     

       39
       39
       +
       

     

       40
       40
       +
       (** Mailbox access rights.

     

       41
       41
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       42
       42
       +
       type mailbox_rights = {

     

       43
       43
       +
         may_read_items : bool;

     

       44
       44
       +
         may_add_items : bool;

     

       45
       45
       +
         may_remove_items : bool;

     

       46
       46
       +
         may_set_seen : bool;

     

       47
       47
       +
         may_set_keywords : bool;

     

       48
       48
       +
         may_create_child : bool;

     

       49
       49
       +
         may_rename : bool;

     

       50
       50
       +
         may_delete : bool;

     

       51
       51
       +
         may_submit : bool;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       (** Mailbox object.

     

       55
       55
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       56
       56
       +
       type mailbox = {

     

       57
       57
       +
         mailbox_id : id; (** immutable, server-set *)

     

       58
       58
       +
         name : string;

     

       59
       59
       +
         parent_id : id option;

     

       60
       60
       +
         role : role option;

     

       61
       61
       +
         sort_order : uint; (* default: 0 *)

     

       62
       62
       +
         total_emails : uint; (** server-set *)

     

       63
       63
       +
         unread_emails : uint; (** server-set *)

     

       64
       64
       +
         total_threads : uint; (** server-set *)

     

       65
       65
       +
         unread_threads : uint; (** server-set *)

     

       66
       66
       +
         my_rights : mailbox_rights; (** server-set *)

     

       67
       67
       +
         is_subscribed : bool;

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

       70
       70
       +
       (** Mailbox object for creation.

     

       71
       71
       +
           Excludes server-set fields.

     

       72
       72
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2> RFC 8621, Section 2 *)

     

       73
       73
       +
       type mailbox_create = {

     

       74
       74
       +
         mailbox_create_name : string;

     

       75
       75
       +
         mailbox_create_parent_id : id option;

     

       76
       76
       +
         mailbox_create_role : role option;

     

       77
       77
       +
         mailbox_create_sort_order : uint option;

     

       78
       78
       +
         mailbox_create_is_subscribed : bool option;

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       (** Mailbox object for update.

     

       82
       82
       +
           Patch object, specific structure not enforced here.

     

       83
       83
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2.5> RFC 8621, Section 2.5 *)

     

       84
       84
       +
       type mailbox_update = patch_object

     

       85
       85
       +
       

     

       86
       86
       +
       (** Server-set info for created mailbox.

     

       87
       87
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2.5> RFC 8621, Section 2.5 *)

     

       88
       88
       +
       type mailbox_created_info = {

     

       89
       89
       +
         mailbox_created_id : id;

     

       90
       90
       +
         mailbox_created_role : role option; (** If default used *)

     

       91
       91
       +
         mailbox_created_sort_order : uint; (** If default used *)

     

       92
       92
       +
         mailbox_created_total_emails : uint;

     

       93
       93
       +
         mailbox_created_unread_emails : uint;

     

       94
       94
       +
         mailbox_created_total_threads : uint;

     

       95
       95
       +
         mailbox_created_unread_threads : uint;

     

       96
       96
       +
         mailbox_created_my_rights : mailbox_rights;

     

       97
       97
       +
         mailbox_created_is_subscribed : bool; (** If default used *)

     

       98
       98
       +
       }

     

       99
       99
       +
       

     

       100
       100
       +
       (** Server-set/computed info for updated mailbox.

     

       101
       101
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2.5> RFC 8621, Section 2.5 *)

     

       102
       102
       +
       type mailbox_updated_info = mailbox (* Contains only changed server-set props *)

     

       103
       103
       +
       

     

       104
       104
       +
       (** FilterCondition for Mailbox/query.

     

       105
       105
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-2.3> RFC 8621, Section 2.3 *)

     

       106
       106
       +
       type mailbox_filter_condition = {

     

       107
       107
       +
         filter_parent_id : id option option; (* Use option option for explicit null *)

     

       108
       108
       +
         filter_name : string option;

     

       109
       109
       +
         filter_role : role option option; (* Use option option for explicit null *)

     

       110
       110
       +
         filter_has_any_role : bool option;

     

       111
       111
       +
         filter_is_subscribed : bool option;

     

       112
       112
       +
       }

     

       113
       113
       +
       

     

       114
       114
       +
       (** {2 Role and Property Conversion Functions} *)

     

       115
       115
       +
       

     

       116
       116
       +
       (** Convert a role variant to its string representation *)

     

       117
       117
       +
       val role_to_string : role -> string

     

       118
       118
       +
       

     

       119
       119
       +
       (** Parse a string into a role variant *)

     

       120
       120
       +
       val string_to_role : string -> role

     

       121
       121
       +
       

     

       122
       122
       +
       (** Convert a property variant to its string representation *)

     

       123
       123
       +
       val property_to_string : property -> string

     

       124
       124
       +
       

     

       125
       125
       +
       (** Parse a string into a property variant *)

     

       126
       126
       +
       val string_to_property : string -> property

     

       127
       127
       +
       

     

       128
       128
       +
       (** Get a list of common properties useful for displaying mailboxes *)

     

       129
       129
       +
       val common_properties : property list

     

       130
       130
       +
       

     

       131
       131
       +
       (** Get a list of all standard properties *)

     

       132
       132
       +
       val all_properties : property list

     

       133
       133
       +
       

     

       134
       134
       +
       (** Check if a property is a count property (TotalEmails, UnreadEmails, etc.) *)

     

       135
       135
       +
       val is_count_property : property -> bool

     

       136
       136
       +
       

     

       137
       137
       +
       (** {2 Mailbox Creation and Manipulation} *)

     

       138
       138
       +
       

     

       139
       139
       +
       (** Create a set of default rights with all permissions *)

     

       140
       140
       +
       val default_rights : unit -> mailbox_rights

     

       141
       141
       +
       

     

       142
       142
       +
       (** Create a set of read-only rights *)

     

       143
       143
       +
       val readonly_rights : unit -> mailbox_rights

     

       144
       144
       +
       

     

       145
       145
       +
       (** Create a new mailbox object with minimal required fields *)

     

       146
       146
       +
       val create : 

     

       147
       147
       +
         name:string -> 

     

       148
       148
       +
         ?parent_id:id -> 

     

       149
       149
       +
         ?role:role -> 

     

       150
       150
       +
         ?sort_order:uint -> 

     

       151
       151
       +
         ?is_subscribed:bool -> 

     

       152
       152
       +
         unit -> mailbox_create

     

       153
       153
       +
         

     

       154
       154
       +
       (** Build a patch object for updating mailbox properties *)

     

       155
       155
       +
       val update :

     

       156
       156
       +
         ?name:string ->

     

       157
       157
       +
         ?parent_id:id option ->

     

       158
       158
       +
         ?role:role option ->

     

       159
       159
       +
         ?sort_order:uint ->

     

       160
       160
       +
         ?is_subscribed:bool ->

     

       161
       161
       +
         unit -> mailbox_update

     

       162
       162
       +
         

     

       163
       163
       +
       (** Get the list of standard role names and their string representations *)

     

       164
       164
       +
       val standard_role_names : (role * string) list

     

       165
       165
       +
       

     

       166
       166
       +
       (** {2 Filter Construction} *)

     

       167
       167
       +
       

     

       168
       168
       +
       (** Create a filter to match mailboxes with a specific role *)

     

       169
       169
       +
       val filter_has_role : role -> Jmap.Methods.Filter.t

     

       170
       170
       +
       

     

       171
       171
       +
       (** Create a filter to match mailboxes with no role *)

     

       172
       172
       +
       val filter_has_no_role : unit -> Jmap.Methods.Filter.t

     

       173
       173
       +
       

     

       174
       174
       +
       (** Create a filter to match mailboxes that are child of a given parent *)

     

       175
       175
       +
       val filter_has_parent : id -> Jmap.Methods.Filter.t

     

       176
       176
       +
       

     

       177
       177
       +
       (** Create a filter to match mailboxes at the root level (no parent) *)

     

       178
       178
       +
       val filter_is_root : unit -> Jmap.Methods.Filter.t

     

       179
       179
       +
       

     

       180
       180
       +
       (** Create a filter to match subscribed mailboxes *)

     

       181
       181
       +
       val filter_is_subscribed : unit -> Jmap.Methods.Filter.t

     

       182
       182
       +
       

     

       183
       183
       +
       (** Create a filter to match unsubscribed mailboxes *)

     

       184
       184
       +
       val filter_is_not_subscribed : unit -> Jmap.Methods.Filter.t

     

       185
       185
       +
       

     

       186
       186
       +
       (** Create a filter to match mailboxes by name (using case-insensitive substring matching) *)

     

       187
       187
       +
       val filter_name_contains : string -> Jmap.Methods.Filter.t

+89

jmap-email/jmap_search_snippet.mli

···

       1
       1
       +
       (** JMAP Search Snippet.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-5> RFC 8621, Section 5 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap.Types

     

       5
       5
       +
       open Jmap.Methods

     

       6
       6
       +
       

     

       7
       7
       +
       (** SearchSnippet object.

     

       8
       8
       +
           Provides highlighted snippets of emails matching search criteria.

     

       9
       9
       +
           Note: Does not have an 'id' property; the key is the emailId.

     

       10
       10
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-5> RFC 8621, Section 5 *)

     

       11
       11
       +
       module SearchSnippet : sig

     

       12
       12
       +
         type t

     

       13
       13
       +
       

     

       14
       14
       +
         (** Get the email ID this snippet is for *)

     

       15
       15
       +
         val email_id : t -> id

     

       16
       16
       +
         

     

       17
       17
       +
         (** Get the highlighted subject snippet (if matched) *)

     

       18
       18
       +
         val subject : t -> string option

     

       19
       19
       +
         

     

       20
       20
       +
         (** Get the highlighted preview snippet (if matched) *)

     

       21
       21
       +
         val preview : t -> string option

     

       22
       22
       +
         

     

       23
       23
       +
         (** Create a new SearchSnippet object *)

     

       24
       24
       +
         val v : 

     

       25
       25
       +
           email_id:id -> 

     

       26
       26
       +
           ?subject:string -> 

     

       27
       27
       +
           ?preview:string -> 

     

       28
       28
       +
           unit -> t

     

       29
       29
       +
       end

     

       30
       30
       +
       

     

       31
       31
       +
       (** {1 SearchSnippet Methods} *)

     

       32
       32
       +
       

     

       33
       33
       +
       (** Arguments for SearchSnippet/get.

     

       34
       34
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-5.1> RFC 8621, Section 5.1 *)

     

       35
       35
       +
       module Get_args : sig

     

       36
       36
       +
         type t

     

       37
       37
       +
         

     

       38
       38
       +
         (** The account ID *)

     

       39
       39
       +
         val account_id : t -> id

     

       40
       40
       +
         

     

       41
       41
       +
         (** The filter to use for the search *)

     

       42
       42
       +
         val filter : t -> Filter.t

     

       43
       43
       +
         

     

       44
       44
       +
         (** Email IDs to return snippets for. If null, all matching emails are included *)

     

       45
       45
       +
         val email_ids : t -> id list option

     

       46
       46
       +
         

     

       47
       47
       +
         (** Creation arguments *)

     

       48
       48
       +
         val v :

     

       49
       49
       +
           account_id:id ->

     

       50
       50
       +
           filter:Filter.t ->

     

       51
       51
       +
           ?email_ids:id list ->

     

       52
       52
       +
           unit -> t

     

       53
       53
       +
       end

     

       54
       54
       +
       

     

       55
       55
       +
       (** Response for SearchSnippet/get.

     

       56
       56
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-5.1> RFC 8621, Section 5.1 *)

     

       57
       57
       +
       module Get_response : sig

     

       58
       58
       +
         type t

     

       59
       59
       +
         

     

       60
       60
       +
         (** The account ID *)

     

       61
       61
       +
         val account_id : t -> id

     

       62
       62
       +
         

     

       63
       63
       +
         (** The search state string (for caching) *)

     

       64
       64
       +
         val list : t -> SearchSnippet.t id_map

     

       65
       65
       +
         

     

       66
       66
       +
         (** IDs requested that weren't found *)

     

       67
       67
       +
         val not_found : t -> id list

     

       68
       68
       +
         

     

       69
       69
       +
         (** Creation *)

     

       70
       70
       +
         val v :

     

       71
       71
       +
           account_id:id ->

     

       72
       72
       +
           list:SearchSnippet.t id_map ->

     

       73
       73
       +
           not_found:id list ->

     

       74
       74
       +
           unit -> t

     

       75
       75
       +
       end

     

       76
       76
       +
       

     

       77
       77
       +
       (** {1 Helper Functions} *)

     

       78
       78
       +
       

     

       79
       79
       +
       (** Helper to extract all matched keywords from a snippet.

     

       80
       80
       +
           This parses highlighted portions from the snippet to get the actual search terms. *)

     

       81
       81
       +
       val extract_matched_terms : string -> string list

     

       82
       82
       +
       

     

       83
       83
       +
       (** Helper to create a filter that searches in email body text.

     

       84
       84
       +
           This is commonly used for SearchSnippet/get requests. *)

     

       85
       85
       +
       val create_body_text_filter : string -> Filter.t

     

       86
       86
       +
       

     

       87
       87
       +
       (** Helper to create a filter that searches across multiple email fields.

     

       88
       88
       +
           This searches subject, body, and headers for the given text. *)

     

       89
       89
       +
       val create_fulltext_filter : string -> Filter.t

+136

jmap-email/jmap_submission.mli

···

       1
       1
       +
       (** JMAP Email Submission.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap.Types

     

       5
       5
       +
       open Jmap.Methods

     

       6
       6
       +
       

     

       7
       7
       +
       (** Address object for Envelope.

     

       8
       8
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       9
       9
       +
       type envelope_address = {

     

       10
       10
       +
         env_addr_email : string;

     

       11
       11
       +
         env_addr_parameters : Yojson.Safe.t string_map option;

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       (** Envelope object.

     

       15
       15
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       16
       16
       +
       type envelope = {

     

       17
       17
       +
         env_mail_from : envelope_address;

     

       18
       18
       +
         env_rcpt_to : envelope_address list;

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       (** Delivery status for a recipient.

     

       22
       22
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       23
       23
       +
       type delivery_status = {

     

       24
       24
       +
         delivery_smtp_reply : string;

     

       25
       25
       +
         delivery_delivered : [ `Queued | `Yes | `No | `Unknown ];

     

       26
       26
       +
         delivery_displayed : [ `Yes | `Unknown ];

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       (** EmailSubmission object.

     

       30
       30
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       31
       31
       +
       type email_submission = {

     

       32
       32
       +
         email_sub_id : id; (** immutable, server-set *)

     

       33
       33
       +
         identity_id : id; (** immutable *)

     

       34
       34
       +
         email_id : id; (** immutable *)

     

       35
       35
       +
         thread_id : id; (** immutable, server-set *)

     

       36
       36
       +
         envelope : envelope option; (** immutable *)

     

       37
       37
       +
         send_at : utc_date; (** immutable, server-set *)

     

       38
       38
       +
         undo_status : [ `Pending | `Final | `Canceled ];

     

       39
       39
       +
         delivery_status : delivery_status string_map option; (** server-set *)

     

       40
       40
       +
         dsn_blob_ids : id list; (** server-set *)

     

       41
       41
       +
         mdn_blob_ids : id list; (** server-set *)

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       (** EmailSubmission object for creation.

     

       45
       45
       +
           Excludes server-set fields.

     

       46
       46
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       47
       47
       +
       type email_submission_create = {

     

       48
       48
       +
         email_sub_create_identity_id : id;

     

       49
       49
       +
         email_sub_create_email_id : id;

     

       50
       50
       +
         email_sub_create_envelope : envelope option;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       (** EmailSubmission object for update.

     

       54
       54
       +
           Only undoStatus can be updated (to 'canceled').

     

       55
       55
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7> RFC 8621, Section 7 *)

     

       56
       56
       +
       type email_submission_update = patch_object

     

       57
       57
       +
       

     

       58
       58
       +
       (** Server-set info for created email submission.

     

       59
       59
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7.5> RFC 8621, Section 7.5 *)

     

       60
       60
       +
       type email_submission_created_info = {

     

       61
       61
       +
         email_sub_created_id : id;

     

       62
       62
       +
         email_sub_created_thread_id : id;

     

       63
       63
       +
         email_sub_created_send_at : utc_date;

     

       64
       64
       +
       }

     

       65
       65
       +
       

     

       66
       66
       +
       (** Server-set/computed info for updated email submission.

     

       67
       67
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7.5> RFC 8621, Section 7.5 *)

     

       68
       68
       +
       type email_submission_updated_info = email_submission (* Contains only changed server-set props *)

     

       69
       69
       +
       

     

       70
       70
       +
       (** FilterCondition for EmailSubmission/query.

     

       71
       71
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7.3> RFC 8621, Section 7.3 *)

     

       72
       72
       +
       type email_submission_filter_condition = {

     

       73
       73
       +
         filter_identity_ids : id list option;

     

       74
       74
       +
         filter_email_ids : id list option;

     

       75
       75
       +
         filter_thread_ids : id list option;

     

       76
       76
       +
         filter_undo_status : [ `Pending | `Final | `Canceled ] option;

     

       77
       77
       +
         filter_before : utc_date option;

     

       78
       78
       +
         filter_after : utc_date option;

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       (** EmailSubmission/get: Args type (specialized from ['record Get_args.t]). *)

     

       82
       82
       +
       module Email_submission_get_args : sig

     

       83
       83
       +
         type t = email_submission Get_args.t

     

       84
       84
       +
       end

     

       85
       85
       +
       

     

       86
       86
       +
       (** EmailSubmission/get: Response type (specialized from ['record Get_response.t]). *)

     

       87
       87
       +
       module Email_submission_get_response : sig

     

       88
       88
       +
         type t = email_submission Get_response.t

     

       89
       89
       +
       end

     

       90
       90
       +
       

     

       91
       91
       +
       (** EmailSubmission/changes: Args type (specialized from [Changes_args.t]). *)

     

       92
       92
       +
       module Email_submission_changes_args : sig

     

       93
       93
       +
         type t = Changes_args.t

     

       94
       94
       +
       end

     

       95
       95
       +
       

     

       96
       96
       +
       (** EmailSubmission/changes: Response type (specialized from [Changes_response.t]). *)

     

       97
       97
       +
       module Email_submission_changes_response : sig

     

       98
       98
       +
         type t = Changes_response.t

     

       99
       99
       +
       end

     

       100
       100
       +
       

     

       101
       101
       +
       (** EmailSubmission/query: Args type (specialized from [Query_args.t]). *)

     

       102
       102
       +
       module Email_submission_query_args : sig

     

       103
       103
       +
         type t = Query_args.t

     

       104
       104
       +
       end

     

       105
       105
       +
       

     

       106
       106
       +
       (** EmailSubmission/query: Response type (specialized from [Query_response.t]). *)

     

       107
       107
       +
       module Email_submission_query_response : sig

     

       108
       108
       +
         type t = Query_response.t

     

       109
       109
       +
       end

     

       110
       110
       +
       

     

       111
       111
       +
       (** EmailSubmission/queryChanges: Args type (specialized from [Query_changes_args.t]). *)

     

       112
       112
       +
       module Email_submission_query_changes_args : sig

     

       113
       113
       +
         type t = Query_changes_args.t

     

       114
       114
       +
       end

     

       115
       115
       +
       

     

       116
       116
       +
       (** EmailSubmission/queryChanges: Response type (specialized from [Query_changes_response.t]). *)

     

       117
       117
       +
       module Email_submission_query_changes_response : sig

     

       118
       118
       +
         type t = Query_changes_response.t

     

       119
       119
       +
       end

     

       120
       120
       +
       

     

       121
       121
       +
       (** EmailSubmission/set: Args type (specialized from [('c, 'u) set_args]).

     

       122
       122
       +
           Includes onSuccess arguments.

     

       123
       123
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-7.5> RFC 8621, Section 7.5 *)

     

       124
       124
       +
       type email_submission_set_args = {

     

       125
       125
       +
         set_account_id : id;

     

       126
       126
       +
         set_if_in_state : string option;

     

       127
       127
       +
         set_create : email_submission_create id_map option;

     

       128
       128
       +
         set_update : email_submission_update id_map option;

     

       129
       129
       +
         set_destroy : id list option;

     

       130
       130
       +
         set_on_success_destroy_email : id list option;

     

       131
       131
       +
       }

     

       132
       132
       +
       

     

       133
       133
       +
       (** EmailSubmission/set: Response type (specialized from [('c, 'u) Set_response.t]). *)

     

       134
       134
       +
       module Email_submission_set_response : sig

     

       135
       135
       +
         type t = (email_submission_created_info, email_submission_updated_info) Set_response.t

     

       136
       136
       +
       end

+131

jmap-email/jmap_thread.mli

···

       1
       1
       +
       (** JMAP Thread.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3> RFC 8621, Section 3 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap.Types

     

       5
       5
       +
       open Jmap.Methods

     

       6
       6
       +
       

     

       7
       7
       +
       (** Thread object.

     

       8
       8
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3> RFC 8621, Section 3 *)

     

       9
       9
       +
       module Thread : sig

     

       10
       10
       +
         type t

     

       11
       11
       +
       

     

       12
       12
       +
         (** Get the thread ID (server-set, immutable) *)

     

       13
       13
       +
         val id : t -> id

     

       14
       14
       +
         

     

       15
       15
       +
         (** Get the IDs of emails in the thread (server-set) *)

     

       16
       16
       +
         val email_ids : t -> id list

     

       17
       17
       +
         

     

       18
       18
       +
         (** Create a new Thread object *)

     

       19
       19
       +
         val v : id:id -> email_ids:id list -> t

     

       20
       20
       +
       end

     

       21
       21
       +
       

     

       22
       22
       +
       (** Thread properties that can be requested in Thread/get.

     

       23
       23
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3.1> RFC 8621, Section 3.1 *)

     

       24
       24
       +
       type property =

     

       25
       25
       +
         | Id        (** The Thread id *)

     

       26
       26
       +
         | EmailIds  (** The list of email IDs in the Thread *)

     

       27
       27
       +
       

     

       28
       28
       +
       (** Convert a property variant to its string representation *)

     

       29
       29
       +
       val property_to_string : property -> string

     

       30
       30
       +
       

     

       31
       31
       +
       (** Parse a string into a property variant *)

     

       32
       32
       +
       val string_to_property : string -> property

     

       33
       33
       +
       

     

       34
       34
       +
       (** Get a list of all standard Thread properties *)

     

       35
       35
       +
       val all_properties : property list

     

       36
       36
       +
       

     

       37
       37
       +
       (** {1 Thread Methods} *)

     

       38
       38
       +
       

     

       39
       39
       +
       (** Arguments for Thread/get - extends standard get arguments.

     

       40
       40
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3.1> RFC 8621, Section 3.1 *)

     

       41
       41
       +
       module Get_args : sig

     

       42
       42
       +
         type t

     

       43
       43
       +
       

     

       44
       44
       +
         val account_id : t -> id

     

       45
       45
       +
         val ids : t -> id list option

     

       46
       46
       +
         val properties : t -> string list option

     

       47
       47
       +
       

     

       48
       48
       +
         val v :

     

       49
       49
       +
           account_id:id ->

     

       50
       50
       +
           ?ids:id list ->

     

       51
       51
       +
           ?properties:string list ->

     

       52
       52
       +
           unit -> t

     

       53
       53
       +
       end

     

       54
       54
       +
       

     

       55
       55
       +
       (** Response for Thread/get - extends standard get response.

     

       56
       56
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3.1> RFC 8621, Section 3.1 *)

     

       57
       57
       +
       module Get_response : sig

     

       58
       58
       +
         type t

     

       59
       59
       +
       

     

       60
       60
       +
         val account_id : t -> id

     

       61
       61
       +
         val state : t -> string

     

       62
       62
       +
         val list : t -> Thread.t list

     

       63
       63
       +
         val not_found : t -> id list

     

       64
       64
       +
       

     

       65
       65
       +
         val v :

     

       66
       66
       +
           account_id:id ->

     

       67
       67
       +
           state:string ->

     

       68
       68
       +
           list:Thread.t list ->

     

       69
       69
       +
           not_found:id list ->

     

       70
       70
       +
           unit -> t

     

       71
       71
       +
       end

     

       72
       72
       +
       

     

       73
       73
       +
       (** Arguments for Thread/changes - extends standard changes arguments.

     

       74
       74
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3.2> RFC 8621, Section 3.2 *)

     

       75
       75
       +
       module Changes_args : sig

     

       76
       76
       +
         type t

     

       77
       77
       +
       

     

       78
       78
       +
         val account_id : t -> id

     

       79
       79
       +
         val since_state : t -> string

     

       80
       80
       +
         val max_changes : t -> uint option

     

       81
       81
       +
       

     

       82
       82
       +
         val v :

     

       83
       83
       +
           account_id:id ->

     

       84
       84
       +
           since_state:string ->

     

       85
       85
       +
           ?max_changes:uint ->

     

       86
       86
       +
           unit -> t

     

       87
       87
       +
       end

     

       88
       88
       +
       

     

       89
       89
       +
       (** Response for Thread/changes - extends standard changes response.

     

       90
       90
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-3.2> RFC 8621, Section 3.2 *)

     

       91
       91
       +
       module Changes_response : sig

     

       92
       92
       +
         type t

     

       93
       93
       +
       

     

       94
       94
       +
         val account_id : t -> id

     

       95
       95
       +
         val old_state : t -> string

     

       96
       96
       +
         val new_state : t -> string

     

       97
       97
       +
         val has_more_changes : t -> bool

     

       98
       98
       +
         val created : t -> id list

     

       99
       99
       +
         val updated : t -> id list

     

       100
       100
       +
         val destroyed : t -> id list

     

       101
       101
       +
       

     

       102
       102
       +
         val v :

     

       103
       103
       +
           account_id:id ->

     

       104
       104
       +
           old_state:string ->

     

       105
       105
       +
           new_state:string ->

     

       106
       106
       +
           has_more_changes:bool ->

     

       107
       107
       +
           created:id list ->

     

       108
       108
       +
           updated:id list ->

     

       109
       109
       +
           destroyed:id list ->

     

       110
       110
       +
           unit -> t

     

       111
       111
       +
       end

     

       112
       112
       +
       

     

       113
       113
       +
       (** {1 Helper Functions} *)

     

       114
       114
       +
       

     

       115
       115
       +
       (** Create a filter to find threads with specific email ID *)

     

       116
       116
       +
       val filter_has_email : id -> Filter.t

     

       117
       117
       +
       

     

       118
       118
       +
       (** Create a filter to find threads with emails from a specific sender *)

     

       119
       119
       +
       val filter_from : string -> Filter.t

     

       120
       120
       +
       

     

       121
       121
       +
       (** Create a filter to find threads with emails to a specific recipient *)

     

       122
       122
       +
       val filter_to : string -> Filter.t

     

       123
       123
       +
       

     

       124
       124
       +
       (** Create a filter to find threads with specific subject *)

     

       125
       125
       +
       val filter_subject : string -> Filter.t

     

       126
       126
       +
       

     

       127
       127
       +
       (** Create a filter to find threads with emails received before a date *)

     

       128
       128
       +
       val filter_before : date -> Filter.t

     

       129
       129
       +
       

     

       130
       130
       +
       (** Create a filter to find threads with emails received after a date *)

     

       131
       131
       +
       val filter_after : date -> Filter.t

+102

jmap-email/jmap_vacation.mli

···

       1
       1
       +
       (** JMAP Vacation Response.

     

       2
       2
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-8> RFC 8621, Section 8 *)

     

       3
       3
       +
       

     

       4
       4
       +
       open Jmap.Types

     

       5
       5
       +
       open Jmap.Methods

     

       6
       6
       +
       open Jmap.Error

     

       7
       7
       +
       

     

       8
       8
       +
       (** VacationResponse object.

     

       9
       9
       +
           Note: id is always "singleton".

     

       10
       10
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-8> RFC 8621, Section 8 *)

     

       11
       11
       +
       module Vacation_response : sig

     

       12
       12
       +
         type t

     

       13
       13
       +
         

     

       14
       14
       +
         (** Id of the vacation response (immutable, server-set, MUST be "singleton") *)

     

       15
       15
       +
         val id : t -> id

     

       16
       16
       +
         val is_enabled : t -> bool

     

       17
       17
       +
         val from_date : t -> utc_date option

     

       18
       18
       +
         val to_date : t -> utc_date option

     

       19
       19
       +
         val subject : t -> string option

     

       20
       20
       +
         val text_body : t -> string option

     

       21
       21
       +
         val html_body : t -> string option

     

       22
       22
       +
         

     

       23
       23
       +
         val v :

     

       24
       24
       +
           id:id ->

     

       25
       25
       +
           is_enabled:bool ->

     

       26
       26
       +
           ?from_date:utc_date ->

     

       27
       27
       +
           ?to_date:utc_date ->

     

       28
       28
       +
           ?subject:string ->

     

       29
       29
       +
           ?text_body:string ->

     

       30
       30
       +
           ?html_body:string ->

     

       31
       31
       +
           unit ->

     

       32
       32
       +
           t

     

       33
       33
       +
       end

     

       34
       34
       +
       

     

       35
       35
       +
       (** VacationResponse object for update.

     

       36
       36
       +
           Patch object, specific structure not enforced here.

     

       37
       37
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-8.2> RFC 8621, Section 8.2 *)

     

       38
       38
       +
       type vacation_response_update = patch_object

     

       39
       39
       +
       

     

       40
       40
       +
       (** VacationResponse/get: Args type (specialized from ['record get_args]). *)

     

       41
       41
       +
       module Vacation_response_get_args : sig

     

       42
       42
       +
         type t = Vacation_response.t Get_args.t

     

       43
       43
       +
         

     

       44
       44
       +
         val v :

     

       45
       45
       +
           account_id:id ->

     

       46
       46
       +
           ?ids:id list ->

     

       47
       47
       +
           ?properties:string list ->

     

       48
       48
       +
           unit ->

     

       49
       49
       +
           t

     

       50
       50
       +
       end

     

       51
       51
       +
       

     

       52
       52
       +
       (** VacationResponse/get: Response type (specialized from ['record get_response]). *)

     

       53
       53
       +
       module Vacation_response_get_response : sig 

     

       54
       54
       +
         type t = Vacation_response.t Get_response.t

     

       55
       55
       +
         

     

       56
       56
       +
         val v :

     

       57
       57
       +
           account_id:id ->

     

       58
       58
       +
           state:string ->

     

       59
       59
       +
           list:Vacation_response.t list ->

     

       60
       60
       +
           not_found:id list ->

     

       61
       61
       +
           unit ->

     

       62
       62
       +
           t

     

       63
       63
       +
       end

     

       64
       64
       +
       

     

       65
       65
       +
       (** VacationResponse/set: Args type.

     

       66
       66
       +
           Only allows update, id must be "singleton".

     

       67
       67
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-8.2> RFC 8621, Section 8.2 *)

     

       68
       68
       +
       module Vacation_response_set_args : sig

     

       69
       69
       +
         type t

     

       70
       70
       +
         

     

       71
       71
       +
         val account_id : t -> id

     

       72
       72
       +
         val if_in_state : t -> string option

     

       73
       73
       +
         val update : t -> vacation_response_update id_map option

     

       74
       74
       +
         

     

       75
       75
       +
         val v :

     

       76
       76
       +
           account_id:id ->

     

       77
       77
       +
           ?if_in_state:string ->

     

       78
       78
       +
           ?update:vacation_response_update id_map ->

     

       79
       79
       +
           unit ->

     

       80
       80
       +
           t

     

       81
       81
       +
       end

     

       82
       82
       +
       

     

       83
       83
       +
       (** VacationResponse/set: Response type.

     

       84
       84
       +
           @see <https://www.rfc-editor.org/rfc/rfc8621.html#section-8.2> RFC 8621, Section 8.2 *)

     

       85
       85
       +
       module Vacation_response_set_response : sig

     

       86
       86
       +
         type t

     

       87
       87
       +
         

     

       88
       88
       +
         val account_id : t -> id

     

       89
       89
       +
         val old_state : t -> string option

     

       90
       90
       +
         val new_state : t -> string

     

       91
       91
       +
         val updated : t -> Vacation_response.t option id_map option

     

       92
       92
       +
         val not_updated : t -> Set_error.t id_map option

     

       93
       93
       +
         

     

       94
       94
       +
         val v :

     

       95
       95
       +
           account_id:id ->

     

       96
       96
       +
           ?old_state:string ->

     

       97
       97
       +
           new_state:string ->

     

       98
       98
       +
           ?updated:Vacation_response.t option id_map ->

     

       99
       99
       +
           ?not_updated:Set_error.t id_map ->

     

       100
       100
       +
           unit ->

     

       101
       101
       +
           t

     

       102
       102
       +
       end

+35

jmap-email.opam

···

       1
       1
       +
       opam-version: "2.0"

     

       2
       2
       +
       name: "jmap-email"

     

       3
       3
       +
       version: "~dev"

     

       4
       4
       +
       synopsis: "JMAP Email extensions library (RFC 8621)"

     

       5
       5
       +
       description: """

     

       6
       6
       +
       OCaml implementation of the JMAP Mail extensions protocol as defined in RFC 8621.

     

       7
       7
       +
       Provides type definitions and structures for working with email in JMAP.

     

       8
       8
       +
       """

     

       9
       9
       +
       maintainer: ["user@example.com"]

     

       10
       10
       +
       authors: ["Example User"]

     

       11
       11
       +
       license: "MIT"

     

       12
       12
       +
       homepage: "https://github.com/example/jmap"

     

       13
       13
       +
       bug-reports: "https://github.com/example/jmap/issues"

     

       14
       14
       +
       depends: [

     

       15
       15
       +
         "ocaml" {>= "4.08.0"}

     

       16
       16
       +
         "dune" {>= "3.0"}

     

       17
       17
       +
         "jmap"

     

       18
       18
       +
         "yojson"

     

       19
       19
       +
         "uri"

     

       20
       20
       +
         "odoc" {with-doc}

     

       21
       21
       +
       ]

     

       22
       22
       +
       build: [

     

       23
       23
       +
         ["dune" "subst"] {dev}

     

       24
       24
       +
         [

     

       25
       25
       +
           "dune"

     

       26
       26
       +
           "build"

     

       27
       27
       +
           "-p"

     

       28
       28
       +
           name

     

       29
       29
       +
           "-j"

     

       30
       30
       +
           jobs

     

       31
       31
       +
           "@install"

     

       32
       32
       +
           "@runtest" {with-test}

     

       33
       33
       +
           "@doc" {with-doc}

     

       34
       34
       +
         ]

     

       35
       35
       +
       ]

+62

jmap-unix/README.md

···

       1
       1
       +
       # JMAP Unix Implementation

     

       2
       2
       +
       

     

       3
       3
       +
       This library provides Unix-specific implementation for the core JMAP protocol.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Overview

     

       6
       6
       +
       

     

       7
       7
       +
       Jmap_unix provides the implementation needed to make actual connections to JMAP servers

     

       8
       8
       +
       using OCaml's Unix module. It handles:

     

       9
       9
       +
       

     

       10
       10
       +
       - HTTP connections to JMAP endpoints

     

       11
       11
       +
       - Authentication

     

       12
       12
       +
       - Session discovery

     

       13
       13
       +
       - Request/response handling

     

       14
       14
       +
       - Blob upload/download

     

       15
       15
       +
       - High-level email operations (Jmap_unix.Email)

     

       16
       16
       +
       

     

       17
       17
       +
       ## Usage

     

       18
       18
       +
       

     

       19
       19
       +
       ```ocaml

     

       20
       20
       +
       open Jmap

     

       21
       21
       +
       open Jmap_unix

     

       22
       22
       +
       

     

       23
       23
       +
       (* Create a connection to a JMAP server *)

     

       24
       24
       +
       let credentials = Basic("username", "password") in

     

       25
       25
       +
       let (ctx, session) = Jmap_unix.connect ~host:"jmap.example.com" ~credentials in

     

       26
       26
       +
       

     

       27
       27
       +
       (* Use the connection for JMAP requests *)

     

       28
       28
       +
       let response = Jmap_unix.request ctx request in

     

       29
       29
       +
       

     

       30
       30
       +
       (* Close the connection when done *)

     

       31
       31
       +
       Jmap_unix.close ctx

     

       32
       32
       +
       ```

     

       33
       33
       +
       

     

       34
       34
       +
       ## Email Operations

     

       35
       35
       +
       

     

       36
       36
       +
       The Email module provides high-level operations for working with emails:

     

       37
       37
       +
       

     

       38
       38
       +
       ```ocaml

     

       39
       39
       +
       open Jmap

     

       40
       40
       +
       open Jmap.Unix

     

       41
       41
       +
       

     

       42
       42
       +
       (* Get an email *)

     

       43
       43
       +
       let email = Email.get_email ctx ~account_id ~email_id ()

     

       44
       44
       +
       

     

       45
       45
       +
       (* Search for unread emails *)

     

       46
       46
       +
       let filter = Jmap_email.Email_filter.unread ()

     

       47
       47
       +
       let (ids, emails) = Email.search_emails ctx ~account_id ~filter ()

     

       48
       48
       +
       

     

       49
       49
       +
       (* Mark emails as read *)

     

       50
       50
       +
       Email.mark_as_seen ctx ~account_id ~email_ids:["email1"; "email2"] ()

     

       51
       51
       +
       

     

       52
       52
       +
       (* Move emails to another mailbox *)

     

       53
       53
       +
       Email.move_emails ctx ~account_id ~email_ids ~mailbox_id ()

     

       54
       54
       +
       ```

     

       55
       55
       +
       

     

       56
       56
       +
       ## Dependencies

     

       57
       57
       +
       

     

       58
       58
       +
       - jmap (core library)

     

       59
       59
       +
       - jmap-email (email types and helpers)

     

       60
       60
       +
       - yojson

     

       61
       61
       +
       - uri

     

       62
       62
       +
       - unix

jmap-unix/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name jmap_unix)

     

       3
       3
       +
        (public_name jmap-unix)

     

       4
       4
       +
        (libraries jmap jmap-email yojson uri unix)

     

       5
       5
       +
        (modules_without_implementation jmap_unix)

     

       6
       6
       +
        (modules jmap_unix))

+359

jmap-unix/jmap_unix.mli

···

       1
       1
       +
       (** Unix-specific JMAP client implementation interface.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides functions to interact with a JMAP server using

     

       4
       4
       +
           Unix sockets for network communication.

     

       5
       5
       +
           

     

       6
       6
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-4> RFC 8620, Section 4

     

       7
       7
       +
       *)

     

       8
       8
       +
       

     

       9
       9
       +
       (** Configuration options for a JMAP client context *)

     

       10
       10
       +
       type client_config = {

     

       11
       11
       +
         connect_timeout : float option;        (** Connection timeout in seconds *)

     

       12
       12
       +
         request_timeout : float option;        (** Request timeout in seconds *)

     

       13
       13
       +
         max_concurrent_requests : int option;  (** Maximum concurrent requests *)

     

       14
       14
       +
         max_request_size : int option;         (** Maximum request size in bytes *)

     

       15
       15
       +
         user_agent : string option;            (** User-Agent header value *)

     

       16
       16
       +
         authentication_header : string option; (** Custom Authentication header name *)

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       (** Authentication method options *)

     

       20
       20
       +
       type auth_method = 

     

       21
       21
       +
         | Basic of string * string                  (** Basic auth with username and password *)

     

       22
       22
       +
         | Bearer of string                          (** Bearer token auth *)

     

       23
       23
       +
         | Custom of (string * string)               (** Custom header name and value *)

     

       24
       24
       +
         | Session_cookie of (string * string)       (** Session cookie name and value *)

     

       25
       25
       +
         | No_auth                                   (** No authentication *)

     

       26
       26
       +
       

     

       27
       27
       +
       (** Represents an active JMAP connection context. Opaque type. *)

     

       28
       28
       +
       type context

     

       29
       29
       +
       

     

       30
       30
       +
       (** Represents an active EventSource connection. Opaque type. *)

     

       31
       31
       +
       type event_source_connection

     

       32
       32
       +
       

     

       33
       33
       +
       (** A request builder for constructing and sending JMAP requests *)

     

       34
       34
       +
       type request_builder

     

       35
       35
       +
       

     

       36
       36
       +
       (** Create default configuration options *)

     

       37
       37
       +
       val default_config : unit -> client_config

     

       38
       38
       +
       

     

       39
       39
       +
       (** Create a client context with the specified configuration

     

       40
       40
       +
           @return The context object used for JMAP API calls

     

       41
       41
       +
       *)

     

       42
       42
       +
       val create_client : 

     

       43
       43
       +
         ?config:client_config -> 

     

       44
       44
       +
         unit -> 

     

       45
       45
       +
         context

     

       46
       46
       +
       

     

       47
       47
       +
       (** Connect to a JMAP server and retrieve the session.

     

       48
       48
       +
           This handles discovery (if needed) and authentication.

     

       49
       49
       +
           @param ctx The client context.

     

       50
       50
       +
           @param ?session_url Optional direct URL to the Session resource.

     

       51
       51
       +
           @param ?username Optional username (e.g., email address) for discovery.

     

       52
       52
       +
           @param ?auth_method Authentication method to use (default Basic).

     

       53
       53
       +
           @param credentials Authentication credentials.

     

       54
       54
       +
           @return A result with either (context, session) or an error.

     

       55
       55
       +
       *)

     

       56
       56
       +
       val connect : 

     

       57
       57
       +
         context ->

     

       58
       58
       +
         ?session_url:Uri.t ->

     

       59
       59
       +
         ?username:string ->

     

       60
       60
       +
         host:string -> 

     

       61
       61
       +
         ?port:int -> 

     

       62
       62
       +
         ?auth_method:auth_method ->

     

       63
       63
       +
         unit -> 

     

       64
       64
       +
         (context * Jmap.Session.Session.t) Jmap.Error.result

     

       65
       65
       +
       

     

       66
       66
       +
       (** Create a request builder for constructing a JMAP request.

     

       67
       67
       +
           @param ctx The client context.

     

       68
       68
       +
           @return A request builder object.

     

       69
       69
       +
       *)

     

       70
       70
       +
       val build : context -> request_builder

     

       71
       71
       +
       

     

       72
       72
       +
       (** Set the using capabilities for a request.

     

       73
       73
       +
           @param builder The request builder.

     

       74
       74
       +
           @param capabilities List of capability URIs to use.

     

       75
       75
       +
           @return The updated request builder.

     

       76
       76
       +
       *)

     

       77
       77
       +
       val using : request_builder -> string list -> request_builder

     

       78
       78
       +
       

     

       79
       79
       +
       (** Add a method call to a request builder.

     

       80
       80
       +
           @param builder The request builder.

     

       81
       81
       +
           @param name Method name (e.g., "Email/get").

     

       82
       82
       +
           @param args Method arguments.

     

       83
       83
       +
           @param id Method call ID.

     

       84
       84
       +
           @return The updated request builder.

     

       85
       85
       +
       *)

     

       86
       86
       +
       val add_method_call : 

     

       87
       87
       +
         request_builder -> 

     

       88
       88
       +
         string -> 

     

       89
       89
       +
         Yojson.Safe.t -> 

     

       90
       90
       +
         string -> 

     

       91
       91
       +
         request_builder

     

       92
       92
       +
       

     

       93
       93
       +
       (** Create a reference to a previous method call result.

     

       94
       94
       +
           @param result_of Method call ID to reference.

     

       95
       95
       +
           @param name Path in the response.

     

       96
       96
       +
           @return A ResultReference to use in another method call.

     

       97
       97
       +
       *)

     

       98
       98
       +
       val create_reference : string -> string -> Jmap.Wire.Result_reference.t

     

       99
       99
       +
       

     

       100
       100
       +
       (** Execute a request and return the response.

     

       101
       101
       +
           @param builder The request builder to execute.

     

       102
       102
       +
           @return The JMAP response from the server.

     

       103
       103
       +
       *)

     

       104
       104
       +
       val execute : request_builder -> Jmap.Wire.Response.t Jmap.Error.result 

     

       105
       105
       +
       

     

       106
       106
       +
       (** Perform a JMAP API request.

     

       107
       107
       +
           @param ctx The connection context.

     

       108
       108
       +
           @param request The JMAP request object.

     

       109
       109
       +
           @return The JMAP response from the server.

     

       110
       110
       +
       *)

     

       111
       111
       +
       val request : context -> Jmap.Wire.Request.t -> Jmap.Wire.Response.t Jmap.Error.result

     

       112
       112
       +
       

     

       113
       113
       +
       (** Upload binary data.

     

       114
       114
       +
           @param ctx The connection context.

     

       115
       115
       +
           @param account_id The target account ID.

     

       116
       116
       +
           @param content_type The MIME type of the data.

     

       117
       117
       +
           @param data_stream A stream providing the binary data chunks.

     

       118
       118
       +
           @return A result with either an upload response or an error.

     

       119
       119
       +
       *)

     

       120
       120
       +
       val upload : 

     

       121
       121
       +
         context -> 

     

       122
       122
       +
         account_id:Jmap.Types.id -> 

     

       123
       123
       +
         content_type:string -> 

     

       124
       124
       +
         data_stream:string Seq.t -> 

     

       125
       125
       +
         Jmap.Binary.Upload_response.t Jmap.Error.result

     

       126
       126
       +
       

     

       127
       127
       +
       (** Download binary data.

     

       128
       128
       +
           @param ctx The connection context.

     

       129
       129
       +
           @param account_id The account ID.

     

       130
       130
       +
           @param blob_id The blob ID to download.

     

       131
       131
       +
           @param ?content_type The desired Content-Type for the download response.

     

       132
       132
       +
           @param ?name The desired filename for the download response.

     

       133
       133
       +
           @return A result with either a stream of data chunks or an error.

     

       134
       134
       +
       *)

     

       135
       135
       +
       val download : 

     

       136
       136
       +
         context -> 

     

       137
       137
       +
         account_id:Jmap.Types.id -> 

     

       138
       138
       +
         blob_id:Jmap.Types.id -> 

     

       139
       139
       +
         ?content_type:string -> 

     

       140
       140
       +
         ?name:string -> 

     

       141
       141
       +
         (string Seq.t) Jmap.Error.result

     

       142
       142
       +
       

     

       143
       143
       +
       (** Copy blobs between accounts.

     

       144
       144
       +
           @param ctx The connection context.

     

       145
       145
       +
           @param from_account_id Source account ID.

     

       146
       146
       +
           @param account_id Destination account ID.

     

       147
       147
       +
           @param blob_ids List of blob IDs to copy.

     

       148
       148
       +
           @return A result with either the copy response or an error.

     

       149
       149
       +
       *)

     

       150
       150
       +
       val copy_blobs :

     

       151
       151
       +
         context ->

     

       152
       152
       +
         from_account_id:Jmap.Types.id ->

     

       153
       153
       +
         account_id:Jmap.Types.id ->

     

       154
       154
       +
         blob_ids:Jmap.Types.id list ->

     

       155
       155
       +
         Jmap.Binary.Blob_copy_response.t Jmap.Error.result

     

       156
       156
       +
       

     

       157
       157
       +
       (** Connect to the EventSource for push notifications.

     

       158
       158
       +
           @param ctx The connection context.

     

       159
       159
       +
           @param ?types List of types to subscribe to (default "*").

     

       160
       160
       +
           @param ?close_after Request server to close after first state event.

     

       161
       161
       +
           @param ?ping Request ping interval in seconds (default 0).

     

       162
       162
       +
           @return A result with either a tuple of connection handle and event stream, or an error.

     

       163
       163
       +
           @see <https://www.rfc-editor.org/rfc/rfc8620.html#section-7.3> RFC 8620, Section 7.3 *)

     

       164
       164
       +
       val connect_event_source : 

     

       165
       165
       +
         context -> 

     

       166
       166
       +
         ?types:string list -> 

     

       167
       167
       +
         ?close_after:[`State | `No] -> 

     

       168
       168
       +
         ?ping:Jmap.Types.uint ->

     

       169
       169
       +
         (event_source_connection * 

     

       170
       170
       +
          ([`State of Jmap.Push.State_change.t | `Ping of Jmap.Push.Event_source_ping_data.t ] Seq.t)) Jmap.Error.result

     

       171
       171
       +
       

     

       172
       172
       +
       (** Create a websocket connection for JMAP over WebSocket.

     

       173
       173
       +
           @param ctx The connection context.

     

       174
       174
       +
           @return A result with either a websocket connection or an error.

     

       175
       175
       +
           @see <https://www.rfc-editor.org/rfc/rfc8887.html> RFC 8887 *)

     

       176
       176
       +
       val connect_websocket :

     

       177
       177
       +
         context ->

     

       178
       178
       +
         event_source_connection Jmap.Error.result

     

       179
       179
       +
       

     

       180
       180
       +
       (** Send a message over a websocket connection.

     

       181
       181
       +
           @param conn The websocket connection.

     

       182
       182
       +
           @param request The JMAP request to send.

     

       183
       183
       +
           @return A result with either the response or an error.

     

       184
       184
       +
       *)

     

       185
       185
       +
       val websocket_send :

     

       186
       186
       +
         event_source_connection ->

     

       187
       187
       +
         Jmap.Wire.Request.t ->

     

       188
       188
       +
         Jmap.Wire.Response.t Jmap.Error.result

     

       189
       189
       +
       

     

       190
       190
       +
       (** Close an EventSource or WebSocket connection.

     

       191
       191
       +
           @param conn The connection handle.

     

       192
       192
       +
           @return A result with either unit or an error.

     

       193
       193
       +
       *)

     

       194
       194
       +
       val close_connection : event_source_connection -> unit Jmap.Error.result

     

       195
       195
       +
       

     

       196
       196
       +
       (** Close the JMAP connection context. 

     

       197
       197
       +
           @return A result with either unit or an error.

     

       198
       198
       +
       *)

     

       199
       199
       +
       val close : context -> unit Jmap.Error.result

     

       200
       200
       +
       

     

       201
       201
       +
       (** {2 Helper Methods for Common Tasks} *)

     

       202
       202
       +
       

     

       203
       203
       +
       (** Helper to get a single object by ID.

     

       204
       204
       +
           @param ctx The context.

     

       205
       205
       +
           @param method_name The get method (e.g., "Email/get").

     

       206
       206
       +
           @param account_id The account ID.

     

       207
       207
       +
           @param object_id The ID of the object to get.

     

       208
       208
       +
           @param ?properties Optional list of properties to fetch.

     

       209
       209
       +
           @return A result with either the object as JSON or an error.

     

       210
       210
       +
       *)

     

       211
       211
       +
       val get_object :

     

       212
       212
       +
         context ->

     

       213
       213
       +
         method_name:string ->

     

       214
       214
       +
         account_id:Jmap.Types.id ->

     

       215
       215
       +
         object_id:Jmap.Types.id ->

     

       216
       216
       +
         ?properties:string list ->

     

       217
       217
       +
         Yojson.Safe.t Jmap.Error.result

     

       218
       218
       +
       

     

       219
       219
       +
       (** Helper to set up the connection with minimal options.

     

       220
       220
       +
           @param host The JMAP server hostname.

     

       221
       221
       +
           @param username Username for basic auth.

     

       222
       222
       +
           @param password Password for basic auth.

     

       223
       223
       +
           @return A result with either (context, session) or an error.

     

       224
       224
       +
       *)

     

       225
       225
       +
       val quick_connect :

     

       226
       226
       +
         host:string ->

     

       227
       227
       +
         username:string ->

     

       228
       228
       +
         password:string ->

     

       229
       229
       +
         (context * Jmap.Session.Session.t) Jmap.Error.result

     

       230
       230
       +
       

     

       231
       231
       +
       (** Perform a Core/echo request to test connectivity.

     

       232
       232
       +
           @param ctx The JMAP connection context.

     

       233
       233
       +
           @param ?data Optional data to echo back.

     

       234
       234
       +
           @return A result with either the response or an error.

     

       235
       235
       +
       *)

     

       236
       236
       +
       val echo : 

     

       237
       237
       +
         context -> 

     

       238
       238
       +
         ?data:Yojson.Safe.t -> 

     

       239
       239
       +
         unit -> 

     

       240
       240
       +
         Yojson.Safe.t Jmap.Error.result

     

       241
       241
       +
       

     

       242
       242
       +
       (** {2 Email Operations} *)

     

       243
       243
       +
       

     

       244
       244
       +
       (** High-level email operations that map to JMAP email methods *)

     

       245
       245
       +
       module Email : sig

     

       246
       246
       +
         open Jmap_email.Types

     

       247
       247
       +
         

     

       248
       248
       +
         (** Get an email by ID 

     

       249
       249
       +
             @param ctx The JMAP client context

     

       250
       250
       +
             @param account_id The account ID

     

       251
       251
       +
             @param email_id The email ID to fetch

     

       252
       252
       +
             @param ?properties Optional list of properties to fetch

     

       253
       253
       +
             @return The email object or an error

     

       254
       254
       +
         *)

     

       255
       255
       +
         val get_email : 

     

       256
       256
       +
           context -> 

     

       257
       257
       +
           account_id:Jmap.Types.id -> 

     

       258
       258
       +
           email_id:Jmap.Types.id -> 

     

       259
       259
       +
           ?properties:string list -> 

     

       260
       260
       +
           unit -> 

     

       261
       261
       +
           Email.t Jmap.Error.result

     

       262
       262
       +
         

     

       263
       263
       +
         (** Search for emails using a filter

     

       264
       264
       +
             @param ctx The JMAP client context

     

       265
       265
       +
             @param account_id The account ID

     

       266
       266
       +
             @param filter The search filter

     

       267
       267
       +
             @param ?sort Optional sort criteria (default received date newest first)

     

       268
       268
       +
             @param ?limit Optional maximum number of results

     

       269
       269
       +
             @param ?properties Optional properties to fetch for the matching emails

     

       270
       270
       +
             @return The list of matching email IDs and optionally the email objects

     

       271
       271
       +
         *)

     

       272
       272
       +
         val search_emails :

     

       273
       273
       +
           context ->

     

       274
       274
       +
           account_id:Jmap.Types.id ->

     

       275
       275
       +
           filter:Jmap.Methods.Filter.t ->

     

       276
       276
       +
           ?sort:Jmap.Methods.Comparator.t list ->

     

       277
       277
       +
           ?limit:Jmap.Types.uint ->

     

       278
       278
       +
           ?position:int ->

     

       279
       279
       +
           ?properties:string list ->

     

       280
       280
       +
           unit ->

     

       281
       281
       +
           (Jmap.Types.id list * Email.t list option) Jmap.Error.result

     

       282
       282
       +
           

     

       283
       283
       +
         (** Mark multiple emails with a keyword

     

       284
       284
       +
             @param ctx The JMAP client context

     

       285
       285
       +
             @param account_id The account ID

     

       286
       286
       +
             @param email_ids List of email IDs to update

     

       287
       287
       +
             @param keyword The keyword to add

     

       288
       288
       +
             @return The result of the operation

     

       289
       289
       +
         *)

     

       290
       290
       +
         val mark_emails :

     

       291
       291
       +
           context ->

     

       292
       292
       +
           account_id:Jmap.Types.id ->

     

       293
       293
       +
           email_ids:Jmap.Types.id list ->

     

       294
       294
       +
           keyword:Keywords.keyword ->

     

       295
       295
       +
           unit ->

     

       296
       296
       +
           unit Jmap.Error.result

     

       297
       297
       +
           

     

       298
       298
       +
         (** Mark emails as seen/read

     

       299
       299
       +
             @param ctx The JMAP client context

     

       300
       300
       +
             @param account_id The account ID

     

       301
       301
       +
             @param email_ids List of email IDs to mark

     

       302
       302
       +
             @return The result of the operation

     

       303
       303
       +
         *)

     

       304
       304
       +
         val mark_as_seen :

     

       305
       305
       +
           context ->

     

       306
       306
       +
           account_id:Jmap.Types.id ->

     

       307
       307
       +
           email_ids:Jmap.Types.id list ->

     

       308
       308
       +
           unit ->

     

       309
       309
       +
           unit Jmap.Error.result

     

       310
       310
       +
           

     

       311
       311
       +
         (** Mark emails as unseen/unread

     

       312
       312
       +
             @param ctx The JMAP client context

     

       313
       313
       +
             @param account_id The account ID

     

       314
       314
       +
             @param email_ids List of email IDs to mark

     

       315
       315
       +
             @return The result of the operation

     

       316
       316
       +
         *)

     

       317
       317
       +
         val mark_as_unseen :

     

       318
       318
       +
           context ->

     

       319
       319
       +
           account_id:Jmap.Types.id ->

     

       320
       320
       +
           email_ids:Jmap.Types.id list ->

     

       321
       321
       +
           unit ->

     

       322
       322
       +
           unit Jmap.Error.result

     

       323
       323
       +
         

     

       324
       324
       +
         (** Move emails to a different mailbox

     

       325
       325
       +
             @param ctx The JMAP client context

     

       326
       326
       +
             @param account_id The account ID

     

       327
       327
       +
             @param email_ids List of email IDs to move

     

       328
       328
       +
             @param mailbox_id Destination mailbox ID

     

       329
       329
       +
             @param ?remove_from_mailboxes Optional list of source mailbox IDs to remove from

     

       330
       330
       +
             @return The result of the operation

     

       331
       331
       +
         *)

     

       332
       332
       +
         val move_emails :

     

       333
       333
       +
           context ->

     

       334
       334
       +
           account_id:Jmap.Types.id ->

     

       335
       335
       +
           email_ids:Jmap.Types.id list ->

     

       336
       336
       +
           mailbox_id:Jmap.Types.id ->

     

       337
       337
       +
           ?remove_from_mailboxes:Jmap.Types.id list ->

     

       338
       338
       +
           unit ->

     

       339
       339
       +
           unit Jmap.Error.result

     

       340
       340
       +
         

     

       341
       341
       +
         (** Import an RFC822 message

     

       342
       342
       +
             @param ctx The JMAP client context

     

       343
       343
       +
             @param account_id The account ID

     

       344
       344
       +
             @param rfc822 Raw message content

     

       345
       345
       +
             @param mailbox_ids Mailboxes to add the message to

     

       346
       346
       +
             @param ?keywords Optional keywords to set

     

       347
       347
       +
             @param ?received_at Optional received timestamp

     

       348
       348
       +
             @return The ID of the imported email

     

       349
       349
       +
         *)

     

       350
       350
       +
         val import_email :

     

       351
       351
       +
           context ->

     

       352
       352
       +
           account_id:Jmap.Types.id ->

     

       353
       353
       +
           rfc822:string ->

     

       354
       354
       +
           mailbox_ids:Jmap.Types.id list ->

     

       355
       355
       +
           ?keywords:Keywords.t ->

     

       356
       356
       +
           ?received_at:Jmap.Types.date ->

     

       357
       357
       +
           unit ->

     

       358
       358
       +
           Jmap.Types.id Jmap.Error.result

     

       359
       359
       +
       end

+21

jmap-unix.opam

···

       1
       1
       +
       opam-version: "2.0"

     

       2
       2
       +
       name: "jmap-unix"

     

       3
       3
       +
       version: "~dev"

     

       4
       4
       +
       synopsis: "JMAP Unix implementation"

     

       5
       5
       +
       description: "Unix-specific implementation of the JMAP protocol (RFC8620)"

     

       6
       6
       +
       maintainer: ["maintainer@example.com"]

     

       7
       7
       +
       authors: ["JMAP OCaml Team"]

     

       8
       8
       +
       license: "MIT"

     

       9
       9
       +
       homepage: "https://github.com/example/jmap-ocaml"

     

       10
       10
       +
       bug-reports: "https://github.com/example/jmap-ocaml/issues"

     

       11
       11
       +
       depends: [

     

       12
       12
       +
         "ocaml" {>= "4.08.0"}

     

       13
       13
       +
         "dune" {>= "2.0.0"}

     

       14
       14
       +
         "jmap"

     

       15
       15
       +
         "yojson" {>= "1.7.0"}

     

       16
       16
       +
         "uri" {>= "4.0.0"}

     

       17
       17
       +
         "unix"

     

       18
       18
       +
       ]

     

       19
       19
       +
       build: [

     

       20
       20
       +
         ["dune" "build" "-p" name "-j" jobs]

     

       21
       21
       +
       ]

-35

jmap.opam

···

       1
       1
       -
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       -
       opam-version: "2.0"

     

       3
       3
       -
       synopsis: "JMAP protocol"

     

       4
       4
       -
       description: "This is all still a work in progress"

     

       5
       5
       -
       maintainer: ["anil@recoil.org"]

     

       6
       6
       -
       authors: ["Anil Madhavapeddy"]

     

       7
       7
       -
       license: "ISC"

     

       8
       8
       -
       homepage: "https://github.com/avsm/jmap"

     

       9
       9
       -
       bug-reports: "https://github.com/avsm/jmap/issues"

     

       10
       10
       -
       depends: [

     

       11
       11
       -
         "dune" {>= "3.17"}

     

       12
       12
       -
         "ocaml" {>= "5.2.0"}

     

       13
       13
       -
         "ptime"

     

       14
       14
       -
         "cohttp"

     

       15
       15
       -
         "cohttp-lwt-unix"

     

       16
       16
       -
         "ezjsonm"

     

       17
       17
       -
         "uri"

     

       18
       18
       -
         "lwt"

     

       19
       19
       -
         "odoc" {with-doc}

     

       20
       20
       -
       ]

     

       21
       21
       -
       build: [

     

       22
       22
       -
         ["dune" "subst"] {dev}

     

       23
       23
       -
         [

     

       24
       24
       -
           "dune"

     

       25
       25
       -
           "build"

     

       26
       26
       -
           "-p"

     

       27
       27
       -
           name

     

       28
       28
       -
           "-j"

     

       29
       29
       -
           jobs

     

       30
       30
       -
           "@install"

     

       31
       31
       -
           "@runtest" {with-test}

     

       32
       32
       -
           "@doc" {with-doc}

     

       33
       33
       -
         ]

     

       34
       34
       -
       ]

     

       35
       35
       -
       dev-repo: "git+https://github.com/avsm/jmap.git"

-11

lib/dune

···

       1
       1
       -
       (library

     

       2
       2
       -
         (name jmap)

     

       3
       3
       -
         (public_name jmap)

     

       4
       4
       -
         (modules jmap)

     

       5
       5
       -
         (libraries str ezjsonm ptime cohttp cohttp-lwt-unix uri lwt))

     

       6
       6
       -
       

     

       7
       7
       -
       (library

     

       8
       8
       -
         (name jmap_mail)

     

       9
       9
       -
         (public_name jmap.mail)

     

       10
       10
       -
         (modules jmap_mail)

     

       11
       11
       -
         (libraries jmap))

-567

lib/jmap.ml

···

       1
       1
       -
       (**

     

       2
       2
       -
        * JMAP protocol implementation based on RFC8620

     

       3
       3
       -
        * https://datatracker.ietf.org/doc/html/rfc8620

     

       4
       4
       -
        *)

     

       5
       5
       -
       

     

       6
       6
       -
       module Types = struct

     

       7
       7
       -
         (** Id string as per Section 1.2 *)

     

       8
       8
       -
         type id = string

     

       9
       9
       -
       

     

       10
       10
       -
         (** Int bounded within the range -2^53+1 to 2^53-1 as per Section 1.3 *)

     

       11
       11
       -
         type int_t = int

     

       12
       12
       -
       

     

       13
       13
       -
         (** UnsignedInt bounded within the range 0 to 2^53-1 as per Section 1.3 *)

     

       14
       14
       -
         type unsigned_int = int

     

       15
       15
       -
       

     

       16
       16
       -
         (** Date string in RFC3339 format as per Section 1.4 *)

     

       17
       17
       -
         type date = string

     

       18
       18
       -
       

     

       19
       19
       -
         (** UTCDate is a Date with 'Z' time zone as per Section 1.4 *)

     

       20
       20
       -
         type utc_date = string

     

       21
       21
       -
       

     

       22
       22
       -
         (** Error object as per Section 3.6.2 *)

     

       23
       23
       -
         type error = {

     

       24
       24
       -
           type_: string;

     

       25
       25
       -
           description: string option;

     

       26
       26
       -
         }

     

       27
       27
       -
       

     

       28
       28
       -
         (** Set error object as per Section 5.3 *)

     

       29
       29
       -
         type set_error = {

     

       30
       30
       -
           type_: string;

     

       31
       31
       -
           description: string option;

     

       32
       32
       -
           properties: string list option;

     

       33
       33
       -
           (* Additional properties for specific error types *)

     

       34
       34
       -
           existing_id: id option; (* For alreadyExists error *)

     

       35
       35
       -
         }

     

       36
       36
       -
       

     

       37
       37
       -
         (** Invocation object as per Section 3.2 *)

     

       38
       38
       -
         type 'a invocation = {

     

       39
       39
       -
           name: string;

     

       40
       40
       -
           arguments: 'a;

     

       41
       41
       -
           method_call_id: string;

     

       42
       42
       -
         }

     

       43
       43
       -
       

     

       44
       44
       -
         (** ResultReference object as per Section 3.7 *)

     

       45
       45
       -
         type result_reference = {

     

       46
       46
       -
           result_of: string;

     

       47
       47
       -
           name: string;

     

       48
       48
       -
           path: string;

     

       49
       49
       -
         }

     

       50
       50
       -
       

     

       51
       51
       -
         (** FilterOperator, FilterCondition and Filter as per Section 5.5 *)

     

       52
       52
       -
         type filter_operator = {

     

       53
       53
       -
           operator: string; (* "AND", "OR", "NOT" *)

     

       54
       54
       -
           conditions: filter list;

     

       55
       55
       -
         }

     

       56
       56
       -
         and filter_condition = (string * Ezjsonm.value) list

     

       57
       57
       -
         and filter = 

     

       58
       58
       -
           | Operator of filter_operator

     

       59
       59
       -
           | Condition of filter_condition

     

       60
       60
       -
       

     

       61
       61
       -
         (** Comparator object for sorting as per Section 5.5 *)

     

       62
       62
       -
         type comparator = {

     

       63
       63
       -
           property: string;

     

       64
       64
       -
           is_ascending: bool option; (* Optional, defaults to true *)

     

       65
       65
       -
           collation: string option;  (* Optional, server-dependent default *)

     

       66
       66
       -
         }

     

       67
       67
       -
       

     

       68
       68
       -
         (** PatchObject as per Section 5.3 *)

     

       69
       69
       -
         type patch_object = (string * Ezjsonm.value) list

     

       70
       70
       -
       

     

       71
       71
       -
         (** AddedItem structure as per Section 5.6 *)

     

       72
       72
       -
         type added_item = {

     

       73
       73
       -
           id: id;

     

       74
       74
       -
           index: unsigned_int;

     

       75
       75
       -
         }

     

       76
       76
       -
       

     

       77
       77
       -
         (** Account object as per Section 1.6.2 *)

     

       78
       78
       -
         type account = {

     

       79
       79
       -
           name: string;

     

       80
       80
       -
           is_personal: bool;

     

       81
       81
       -
           is_read_only: bool;

     

       82
       82
       -
           account_capabilities: (string * Ezjsonm.value) list;

     

       83
       83
       -
         }

     

       84
       84
       -
       

     

       85
       85
       -
         (** Core capability object as per Section 2 *)

     

       86
       86
       -
         type core_capability = {

     

       87
       87
       -
           max_size_upload: unsigned_int;

     

       88
       88
       -
           max_concurrent_upload: unsigned_int;

     

       89
       89
       -
           max_size_request: unsigned_int;

     

       90
       90
       -
           max_concurrent_requests: unsigned_int;

     

       91
       91
       -
           max_calls_in_request: unsigned_int;

     

       92
       92
       -
           max_objects_in_get: unsigned_int;

     

       93
       93
       -
           max_objects_in_set: unsigned_int;

     

       94
       94
       -
           collation_algorithms: string list;

     

       95
       95
       -
         }

     

       96
       96
       -
       

     

       97
       97
       -
         (** PushSubscription keys object as per Section 7.2 *)

     

       98
       98
       -
         type push_keys = {

     

       99
       99
       -
           p256dh: string;

     

       100
       100
       -
           auth: string;

     

       101
       101
       -
         }

     

       102
       102
       -
       

     

       103
       103
       -
         (** Session object as per Section 2 *)

     

       104
       104
       -
         type session = {

     

       105
       105
       -
           capabilities: (string * Ezjsonm.value) list;

     

       106
       106
       -
           accounts: (id * account) list;

     

       107
       107
       -
           primary_accounts: (string * id) list;

     

       108
       108
       -
           username: string;

     

       109
       109
       -
           api_url: string;

     

       110
       110
       -
           download_url: string;

     

       111
       111
       -
           upload_url: string;

     

       112
       112
       -
           event_source_url: string option;

     

       113
       113
       -
           state: string;

     

       114
       114
       -
         }

     

       115
       115
       -
       

     

       116
       116
       -
         (** TypeState for state changes as per Section 7.1 *)

     

       117
       117
       -
         type type_state = (string * string) list

     

       118
       118
       -
       

     

       119
       119
       -
         (** StateChange object as per Section 7.1 *)

     

       120
       120
       -
         type state_change = {

     

       121
       121
       -
           changed: (id * type_state) list;

     

       122
       122
       -
         }

     

       123
       123
       -
       

     

       124
       124
       -
         (** PushVerification object as per Section 7.2.2 *)

     

       125
       125
       -
         type push_verification = {

     

       126
       126
       -
           push_subscription_id: id;

     

       127
       127
       -
           verification_code: string;

     

       128
       128
       -
         }

     

       129
       129
       -
       

     

       130
       130
       -
         (** PushSubscription object as per Section 7.2 *)

     

       131
       131
       -
         type push_subscription = {

     

       132
       132
       -
           id: id;

     

       133
       133
       -
           device_client_id: string;

     

       134
       134
       -
           url: string;

     

       135
       135
       -
           keys: push_keys option;

     

       136
       136
       -
           verification_code: string option;

     

       137
       137
       -
           expires: utc_date option;

     

       138
       138
       -
           types: string list option;

     

       139
       139
       -
         }

     

       140
       140
       -
       

     

       141
       141
       -
         (** Request object as per Section 3.3 *)

     

       142
       142
       -
         type request = {

     

       143
       143
       -
           using: string list;

     

       144
       144
       -
           method_calls: Ezjsonm.value invocation list;

     

       145
       145
       -
           created_ids: (id * id) list option;

     

       146
       146
       -
         }

     

       147
       147
       -
       

     

       148
       148
       -
         (** Response object as per Section 3.4 *)

     

       149
       149
       -
         type response = {

     

       150
       150
       -
           method_responses: Ezjsonm.value invocation list;

     

       151
       151
       -
           created_ids: (id * id) list option;

     

       152
       152
       -
           session_state: string;

     

       153
       153
       -
         }

     

       154
       154
       -
       

     

       155
       155
       -
         (** Standard method arguments and responses *)

     

       156
       156
       -
       

     

       157
       157
       -
         (** Arguments for Foo/get method as per Section 5.1 *)

     

       158
       158
       -
         type 'a get_arguments = {

     

       159
       159
       -
           account_id: id;

     

       160
       160
       -
           ids: id list option;

     

       161
       161
       -
           properties: string list option;

     

       162
       162
       -
         }

     

       163
       163
       -
       

     

       164
       164
       -
         (** Response for Foo/get method as per Section 5.1 *)

     

       165
       165
       -
         type 'a get_response = {

     

       166
       166
       -
           account_id: id;

     

       167
       167
       -
           state: string;

     

       168
       168
       -
           list: 'a list;

     

       169
       169
       -
           not_found: id list;

     

       170
       170
       -
         }

     

       171
       171
       -
       

     

       172
       172
       -
         (** Arguments for Foo/changes method as per Section 5.2 *)

     

       173
       173
       -
         type changes_arguments = {

     

       174
       174
       -
           account_id: id;

     

       175
       175
       -
           since_state: string;

     

       176
       176
       -
           max_changes: unsigned_int option;

     

       177
       177
       -
         }

     

       178
       178
       -
       

     

       179
       179
       -
         (** Response for Foo/changes method as per Section 5.2 *)

     

       180
       180
       -
         type changes_response = {

     

       181
       181
       -
           account_id: id;

     

       182
       182
       -
           old_state: string;

     

       183
       183
       -
           new_state: string;

     

       184
       184
       -
           has_more_changes: bool;

     

       185
       185
       -
           created: id list;

     

       186
       186
       -
           updated: id list;

     

       187
       187
       -
           destroyed: id list;

     

       188
       188
       -
         }

     

       189
       189
       -
       

     

       190
       190
       -
         (** Arguments for Foo/set method as per Section 5.3 *)

     

       191
       191
       -
         type 'a set_arguments = {

     

       192
       192
       -
           account_id: id;

     

       193
       193
       -
           if_in_state: string option;

     

       194
       194
       -
           create: (id * 'a) list option;

     

       195
       195
       -
           update: (id * patch_object) list option;

     

       196
       196
       -
           destroy: id list option;

     

       197
       197
       -
         }

     

       198
       198
       -
       

     

       199
       199
       -
         (** Response for Foo/set method as per Section 5.3 *)

     

       200
       200
       -
         type 'a set_response = {

     

       201
       201
       -
           account_id: id;

     

       202
       202
       -
           old_state: string option;

     

       203
       203
       -
           new_state: string;

     

       204
       204
       -
           created: (id * 'a) list option;

     

       205
       205
       -
           updated: (id * 'a option) list option;

     

       206
       206
       -
           destroyed: id list option;

     

       207
       207
       -
           not_created: (id * set_error) list option;

     

       208
       208
       -
           not_updated: (id * set_error) list option;

     

       209
       209
       -
           not_destroyed: (id * set_error) list option;

     

       210
       210
       -
         }

     

       211
       211
       -
       

     

       212
       212
       -
         (** Arguments for Foo/copy method as per Section 5.4 *)

     

       213
       213
       -
         type 'a copy_arguments = {

     

       214
       214
       -
           from_account_id: id;

     

       215
       215
       -
           if_from_in_state: string option;

     

       216
       216
       -
           account_id: id;

     

       217
       217
       -
           if_in_state: string option;

     

       218
       218
       -
           create: (id * 'a) list;

     

       219
       219
       -
           on_success_destroy_original: bool option;

     

       220
       220
       -
           destroy_from_if_in_state: string option;

     

       221
       221
       -
         }

     

       222
       222
       -
       

     

       223
       223
       -
         (** Response for Foo/copy method as per Section 5.4 *)

     

       224
       224
       -
         type 'a copy_response = {

     

       225
       225
       -
           from_account_id: id;

     

       226
       226
       -
           account_id: id;

     

       227
       227
       -
           old_state: string option;

     

       228
       228
       -
           new_state: string;

     

       229
       229
       -
           created: (id * 'a) list option;

     

       230
       230
       -
           not_created: (id * set_error) list option;

     

       231
       231
       -
         }

     

       232
       232
       -
       

     

       233
       233
       -
         (** Arguments for Foo/query method as per Section 5.5 *)

     

       234
       234
       -
         type query_arguments = {

     

       235
       235
       -
           account_id: id;

     

       236
       236
       -
           filter: filter option;

     

       237
       237
       -
           sort: comparator list option;

     

       238
       238
       -
           position: int_t option;

     

       239
       239
       -
           anchor: id option;

     

       240
       240
       -
           anchor_offset: int_t option;

     

       241
       241
       -
           limit: unsigned_int option;

     

       242
       242
       -
           calculate_total: bool option;

     

       243
       243
       -
         }

     

       244
       244
       -
       

     

       245
       245
       -
         (** Response for Foo/query method as per Section 5.5 *)

     

       246
       246
       -
         type query_response = {

     

       247
       247
       -
           account_id: id;

     

       248
       248
       -
           query_state: string;

     

       249
       249
       -
           can_calculate_changes: bool;

     

       250
       250
       -
           position: unsigned_int;

     

       251
       251
       -
           ids: id list;

     

       252
       252
       -
           total: unsigned_int option;

     

       253
       253
       -
           limit: unsigned_int option;

     

       254
       254
       -
         }

     

       255
       255
       -
       

     

       256
       256
       -
         (** Arguments for Foo/queryChanges method as per Section 5.6 *)

     

       257
       257
       -
         type query_changes_arguments = {

     

       258
       258
       -
           account_id: id;

     

       259
       259
       -
           filter: filter option;

     

       260
       260
       -
           sort: comparator list option;

     

       261
       261
       -
           since_query_state: string;

     

       262
       262
       -
           max_changes: unsigned_int option;

     

       263
       263
       -
           up_to_id: id option;

     

       264
       264
       -
           calculate_total: bool option;

     

       265
       265
       -
         }

     

       266
       266
       -
       

     

       267
       267
       -
         (** Response for Foo/queryChanges method as per Section 5.6 *)

     

       268
       268
       -
         type query_changes_response = {

     

       269
       269
       -
           account_id: id;

     

       270
       270
       -
           old_query_state: string;

     

       271
       271
       -
           new_query_state: string;

     

       272
       272
       -
           total: unsigned_int option;

     

       273
       273
       -
           removed: id list;

     

       274
       274
       -
           added: added_item list option;

     

       275
       275
       -
         }

     

       276
       276
       -
       

     

       277
       277
       -
         (** Arguments for Blob/copy method as per Section 6.3 *)

     

       278
       278
       -
         type blob_copy_arguments = {

     

       279
       279
       -
           from_account_id: id;

     

       280
       280
       -
           account_id: id;

     

       281
       281
       -
           blob_ids: id list;

     

       282
       282
       -
         }

     

       283
       283
       -
       

     

       284
       284
       -
         (** Response for Blob/copy method as per Section 6.3 *)

     

       285
       285
       -
         type blob_copy_response = {

     

       286
       286
       -
           from_account_id: id;

     

       287
       287
       -
           account_id: id;

     

       288
       288
       -
           copied: (id * id) list option;

     

       289
       289
       -
           not_copied: (id * set_error) list option;

     

       290
       290
       -
         }

     

       291
       291
       -
       

     

       292
       292
       -
         (** Upload response as per Section 6.1 *)

     

       293
       293
       -
         type upload_response = {

     

       294
       294
       -
           account_id: id;

     

       295
       295
       -
           blob_id: id;

     

       296
       296
       -
           type_: string;

     

       297
       297
       -
           size: unsigned_int;

     

       298
       298
       -
         }

     

       299
       299
       -
       

     

       300
       300
       -
         (** Problem details object as per RFC7807 and Section 3.6.1 *)

     

       301
       301
       -
         type problem_details = {

     

       302
       302
       -
           type_: string;

     

       303
       303
       -
           status: int option;

     

       304
       304
       -
           detail: string option;

     

       305
       305
       -
           limit: string option; (* For "limit" error *)

     

       306
       306
       -
         }

     

       307
       307
       -
       end

     

       308
       308
       -
       

     

       309
       309
       -
       module Api = struct

     

       310
       310
       -
         open Lwt.Syntax

     

       311
       311
       -
         open Types

     

       312
       312
       -
       

     

       313
       313
       -
         (** Error that may occur during API requests *)

     

       314
       314
       -
         type error =

     

       315
       315
       -
           | Connection_error of string

     

       316
       316
       -
           | HTTP_error of int * string

     

       317
       317
       -
           | Parse_error of string

     

       318
       318
       -
           | Authentication_error

     

       319
       319
       -
       

     

       320
       320
       -
         (** Result type for API operations *)

     

       321
       321
       -
         type 'a result = ('a, error) Stdlib.result

     

       322
       322
       -
       

     

       323
       323
       -
         (** Configuration for a JMAP API client *)

     

       324
       324
       -
         type config = {

     

       325
       325
       -
           api_uri: Uri.t;

     

       326
       326
       -
           username: string;

     

       327
       327
       -
           authentication_token: string;

     

       328
       328
       -
         }

     

       329
       329
       -
       

     

       330
       330
       -
         (** Convert Ezjsonm.value to string *)

     

       331
       331
       -
         let json_to_string json =

     

       332
       332
       -
           Ezjsonm.value_to_string ~minify:false json

     

       333
       333
       -
       

     

       334
       334
       -
         (** Parse response string as JSON value *)

     

       335
       335
       -
         let parse_json_string str =

     

       336
       336
       -
           try Ok (Ezjsonm.from_string str)

     

       337
       337
       -
           with e -> Error (Parse_error (Printexc.to_string e))

     

       338
       338
       -
       

     

       339
       339
       -
         (** Parse JSON response as a JMAP response object *)

     

       340
       340
       -
         let parse_response json =

     

       341
       341
       -
           try

     

       342
       342
       -
             let method_responses =

     

       343
       343
       -
               match Ezjsonm.find json ["methodResponses"] with

     

       344
       344
       -
               | `A items ->

     

       345
       345
       -
                   List.map (fun json ->

     

       346
       346
       -
                     match json with

     

       347
       347
       -
                     | `A [`String name; args; `String method_call_id] ->

     

       348
       348
       -
                         { name; arguments = args; method_call_id }

     

       349
       349
       -
                     | _ -> raise (Invalid_argument "Invalid invocation format in response")

     

       350
       350
       -
                   ) items

     

       351
       351
       -
               | _ -> raise (Invalid_argument "methodResponses is not an array")

     

       352
       352
       -
             in

     

       353
       353
       -
             let created_ids_opt =

     

       354
       354
       -
               try

     

       355
       355
       -
                 let obj = Ezjsonm.find json ["createdIds"] in

     

       356
       356
       -
                 match obj with

     

       357
       357
       -
                 | `O items -> Some (List.map (fun (k, v) ->

     

       358
       358
       -
                     match v with

     

       359
       359
       -
                     | `String id -> (k, id)

     

       360
       360
       -
                     | _ -> raise (Invalid_argument "createdIds value is not a string")

     

       361
       361
       -
                   ) items)

     

       362
       362
       -
                 | _ -> None

     

       363
       363
       -
               with Not_found -> None

     

       364
       364
       -
             in

     

       365
       365
       -
             let session_state =

     

       366
       366
       -
               match Ezjsonm.find json ["sessionState"] with

     

       367
       367
       -
               | `String s -> s

     

       368
       368
       -
               | _ -> raise (Invalid_argument "sessionState is not a string")

     

       369
       369
       -
             in

     

       370
       370
       -
             Ok { method_responses; created_ids = created_ids_opt; session_state }

     

       371
       371
       -
           with

     

       372
       372
       -
           | Not_found -> Error (Parse_error "Required field not found in response")

     

       373
       373
       -
           | Invalid_argument msg -> Error (Parse_error msg)

     

       374
       374
       -
           | e -> Error (Parse_error (Printexc.to_string e))

     

       375
       375
       -
       

     

       376
       376
       -
         (** Serialize a JMAP request object to JSON *)

     

       377
       377
       -
         let serialize_request req =

     

       378
       378
       -
           let method_calls_json =

     

       379
       379
       -
             `A (List.map (fun (inv : 'a invocation) ->

     

       380
       380
       -
               `A [`String inv.name; inv.arguments; `String inv.method_call_id]

     

       381
       381
       -
             ) req.method_calls)

     

       382
       382
       -
           in

     

       383
       383
       -
           let using_json = `A (List.map (fun s -> `String s) req.using) in

     

       384
       384
       -
           let json = `O [

     

       385
       385
       -
             ("using", using_json);

     

       386
       386
       -
             ("methodCalls", method_calls_json)

     

       387
       387
       -
           ] in

     

       388
       388
       -
           let json = match req.created_ids with

     

       389
       389
       -
             | Some ids ->

     

       390
       390
       -
                 let created_ids_json = `O (List.map (fun (k, v) -> (k, `String v)) ids) in

     

       391
       391
       -
                 Ezjsonm.update json ["createdIds"] (Some created_ids_json)

     

       392
       392
       -
             | None -> json

     

       393
       393
       -
           in

     

       394
       394
       -
           json_to_string json

     

       395
       395
       -
       

     

       396
       396
       -
         (** Make a raw HTTP request *)

     

       397
       397
       -
         let make_http_request ~headers ~body uri =

     

       398
       398
       -
           let open Cohttp in

     

       399
       399
       -
           let open Cohttp_lwt_unix in

     

       400
       400
       -
           let headers = Header.add_list (Header.init ()) headers in

     

       401
       401
       -
           Lwt.catch

     

       402
       402
       -
             (fun () ->

     

       403
       403
       -
               let* resp, body = Client.post ~headers ~body:(Cohttp_lwt.Body.of_string body) uri in

     

       404
       404
       -
               let* body_str = Cohttp_lwt.Body.to_string body in

     

       405
       405
       -
               let status = Response.status resp |> Code.code_of_status in

     

       406
       406
       -
               if status >= 200 && status < 300 then

     

       407
       407
       -
                 Lwt.return (Ok body_str)

     

       408
       408
       -
               else

     

       409
       409
       -
                 Lwt.return (Error (HTTP_error (status, body_str))))

     

       410
       410
       -
             (fun e -> Lwt.return (Error (Connection_error (Printexc.to_string e))))

     

       411
       411
       -
       

     

       412
       412
       -
         (** Make a raw JMAP API request 

     

       413
       413
       -
             

     

       414
       414
       -
             TODO:claude *)

     

       415
       415
       -
         let make_request config req =

     

       416
       416
       -
           let body = serialize_request req in

     

       417
       417
       -
           let headers = [

     

       418
       418
       -
             ("Content-Type", "application/json");

     

       419
       419
       -
             ("Content-Length", string_of_int (String.length body));

     

       420
       420
       -
             ("Authorization", "Basic " ^ Base64.encode_string (config.username ^ ":" ^ config.authentication_token))

     

       421
       421
       -
           ] in

     

       422
       422
       -
           let* result = make_http_request ~headers ~body config.api_uri in

     

       423
       423
       -
           match result with

     

       424
       424
       -
           | Ok response_body ->

     

       425
       425
       -
               (match parse_json_string response_body with

     

       426
       426
       -
                | Ok json -> Lwt.return (parse_response json)

     

       427
       427
       -
                | Error e -> Lwt.return (Error e))

     

       428
       428
       -
           | Error e -> Lwt.return (Error e)

     

       429
       429
       -
       

     

       430
       430
       -
         (** Parse a JSON object as a Session object *)

     

       431
       431
       -
         let parse_session_object json =

     

       432
       432
       -
           try

     

       433
       433
       -
             let capabilities =

     

       434
       434
       -
               match Ezjsonm.find json ["capabilities"] with

     

       435
       435
       -
               | `O items -> items

     

       436
       436
       -
               | _ -> raise (Invalid_argument "capabilities is not an object")

     

       437
       437
       -
             in

     

       438
       438
       -
             

     

       439
       439
       -
             let accounts =

     

       440
       440
       -
               match Ezjsonm.find json ["accounts"] with

     

       441
       441
       -
               | `O items -> List.map (fun (id, json) ->

     

       442
       442
       -
                   match json with

     

       443
       443
       -
                   | `O _ -> 

     

       444
       444
       -
                       let name = Ezjsonm.get_string (Ezjsonm.find json ["name"]) in

     

       445
       445
       -
                       let is_personal = Ezjsonm.get_bool (Ezjsonm.find json ["isPersonal"]) in

     

       446
       446
       -
                       let is_read_only = Ezjsonm.get_bool (Ezjsonm.find json ["isReadOnly"]) in

     

       447
       447
       -
                       let account_capabilities =

     

       448
       448
       -
                         match Ezjsonm.find json ["accountCapabilities"] with

     

       449
       449
       -
                         | `O items -> items

     

       450
       450
       -
                         | _ -> raise (Invalid_argument "accountCapabilities is not an object")

     

       451
       451
       -
                       in

     

       452
       452
       -
                       (id, { name; is_personal; is_read_only; account_capabilities })

     

       453
       453
       -
                   | _ -> raise (Invalid_argument "account value is not an object")

     

       454
       454
       -
                 ) items

     

       455
       455
       -
               | _ -> raise (Invalid_argument "accounts is not an object")

     

       456
       456
       -
             in

     

       457
       457
       -
             

     

       458
       458
       -
             let primary_accounts =

     

       459
       459
       -
               match Ezjsonm.find_opt json ["primaryAccounts"] with

     

       460
       460
       -
               | Some (`O items) -> List.map (fun (k, v) ->

     

       461
       461
       -
                   match v with

     

       462
       462
       -
                   | `String id -> (k, id)

     

       463
       463
       -
                   | _ -> raise (Invalid_argument "primaryAccounts value is not a string")

     

       464
       464
       -
                 ) items

     

       465
       465
       -
               | Some _ -> raise (Invalid_argument "primaryAccounts is not an object")

     

       466
       466
       -
               | None -> []

     

       467
       467
       -
             in

     

       468
       468
       -
             

     

       469
       469
       -
             let username = Ezjsonm.get_string (Ezjsonm.find json ["username"]) in

     

       470
       470
       -
             let api_url = Ezjsonm.get_string (Ezjsonm.find json ["apiUrl"]) in

     

       471
       471
       -
             let download_url = Ezjsonm.get_string (Ezjsonm.find json ["downloadUrl"]) in

     

       472
       472
       -
             let upload_url = Ezjsonm.get_string (Ezjsonm.find json ["uploadUrl"]) in

     

       473
       473
       -
             let event_source_url = 

     

       474
       474
       -
               try Some (Ezjsonm.get_string (Ezjsonm.find json ["eventSourceUrl"]))

     

       475
       475
       -
               with Not_found -> None

     

       476
       476
       -
             in

     

       477
       477
       -
             let state = Ezjsonm.get_string (Ezjsonm.find json ["state"]) in

     

       478
       478
       -
             

     

       479
       479
       -
             Ok { capabilities; accounts; primary_accounts; username; 

     

       480
       480
       -
                  api_url; download_url; upload_url; event_source_url; state }

     

       481
       481
       -
           with

     

       482
       482
       -
           | Not_found -> Error (Parse_error "Required field not found in session object")

     

       483
       483
       -
           | Invalid_argument msg -> Error (Parse_error msg)

     

       484
       484
       -
           | e -> Error (Parse_error (Printexc.to_string e))

     

       485
       485
       -
       

     

       486
       486
       -
         (** Fetch a Session object from a JMAP server

     

       487
       487
       -
             

     

       488
       488
       -
             TODO:claude *)

     

       489
       489
       -
         let get_session uri ?username ?authentication_token () =

     

       490
       490
       -
           let headers = 

     

       491
       491
       -
             match (username, authentication_token) with

     

       492
       492
       -
             | (Some u, Some t) -> [

     

       493
       493
       -
                 ("Content-Type", "application/json");

     

       494
       494
       -
                 ("Authorization", "Basic " ^ Base64.encode_string (u ^ ":" ^ t))

     

       495
       495
       -
               ]

     

       496
       496
       -
             | _ -> [("Content-Type", "application/json")]

     

       497
       497
       -
           in

     

       498
       498
       -
           

     

       499
       499
       -
           let* result = make_http_request ~headers ~body:"" uri in

     

       500
       500
       -
           match result with

     

       501
       501
       -
           | Ok response_body ->

     

       502
       502
       -
               (match parse_json_string response_body with

     

       503
       503
       -
                | Ok json -> Lwt.return (parse_session_object json)

     

       504
       504
       -
                | Error e -> Lwt.return (Error e))

     

       505
       505
       -
           | Error e -> Lwt.return (Error e)

     

       506
       506
       -
       

     

       507
       507
       -
         (** Upload a binary blob to the server

     

       508
       508
       -
             

     

       509
       509
       -
             TODO:claude *)

     

       510
       510
       -
         let upload_blob config ~account_id ~content_type data =

     

       511
       511
       -
           let upload_url_template = config.api_uri |> Uri.to_string in

     

       512
       512
       -
           (* Replace {accountId} with the actual account ID *)

     

       513
       513
       -
           let upload_url = Str.global_replace (Str.regexp "{accountId}") account_id upload_url_template in

     

       514
       514
       -
           let upload_uri = Uri.of_string upload_url in

     

       515
       515
       -
           

     

       516
       516
       -
           let headers = [

     

       517
       517
       -
             ("Content-Type", content_type);

     

       518
       518
       -
             ("Content-Length", string_of_int (String.length data));

     

       519
       519
       -
             ("Authorization", "Basic " ^ Base64.encode_string (config.username ^ ":" ^ config.authentication_token))

     

       520
       520
       -
           ] in

     

       521
       521
       -
           

     

       522
       522
       -
           let* result = make_http_request ~headers ~body:data upload_uri in

     

       523
       523
       -
           match result with

     

       524
       524
       -
           | Ok response_body ->

     

       525
       525
       -
               (match parse_json_string response_body with

     

       526
       526
       -
                | Ok json ->

     

       527
       527
       -
                    (try

     

       528
       528
       -
                       let account_id = Ezjsonm.get_string (Ezjsonm.find json ["accountId"]) in

     

       529
       529
       -
                       let blob_id = Ezjsonm.get_string (Ezjsonm.find json ["blobId"]) in

     

       530
       530
       -
                       let type_ = Ezjsonm.get_string (Ezjsonm.find json ["type"]) in

     

       531
       531
       -
                       let size = Ezjsonm.get_int (Ezjsonm.find json ["size"]) in

     

       532
       532
       -
                       Lwt.return (Ok { account_id; blob_id; type_; size })

     

       533
       533
       -
                     with

     

       534
       534
       -
                     | Not_found -> Lwt.return (Error (Parse_error "Required field not found in upload response"))

     

       535
       535
       -
                     | e -> Lwt.return (Error (Parse_error (Printexc.to_string e))))

     

       536
       536
       -
                | Error e -> Lwt.return (Error e))

     

       537
       537
       -
           | Error e -> Lwt.return (Error e)

     

       538
       538
       -
       

     

       539
       539
       -
         (** Download a binary blob from the server

     

       540
       540
       -
             

     

       541
       541
       -
             TODO:claude *)

     

       542
       542
       -
         let download_blob config ~account_id ~blob_id ?type_ ?name () =

     

       543
       543
       -
           let download_url_template = config.api_uri |> Uri.to_string in

     

       544
       544
       -
           

     

       545
       545
       -
           (* Replace template variables with actual values *)

     

       546
       546
       -
           let url = Str.global_replace (Str.regexp "{accountId}") account_id download_url_template in

     

       547
       547
       -
           let url = Str.global_replace (Str.regexp "{blobId}") blob_id url in

     

       548
       548
       -
           

     

       549
       549
       -
           let url = match type_ with

     

       550
       550
       -
             | Some t -> Str.global_replace (Str.regexp "{type}") (Uri.pct_encode t) url

     

       551
       551
       -
             | None -> Str.global_replace (Str.regexp "{type}") "" url

     

       552
       552
       -
           in

     

       553
       553
       -
           

     

       554
       554
       -
           let url = match name with

     

       555
       555
       -
             | Some n -> Str.global_replace (Str.regexp "{name}") (Uri.pct_encode n) url

     

       556
       556
       -
             | None -> Str.global_replace (Str.regexp "{name}") "file" url

     

       557
       557
       -
           in

     

       558
       558
       -
           

     

       559
       559
       -
           let download_uri = Uri.of_string url in

     

       560
       560
       -
           

     

       561
       561
       -
           let headers = [

     

       562
       562
       -
             ("Authorization", "Basic " ^ Base64.encode_string (config.username ^ ":" ^ config.authentication_token))

     

       563
       563
       -
           ] in

     

       564
       564
       -
           

     

       565
       565
       -
           let* result = make_http_request ~headers ~body:"" download_uri in

     

       566
       566
       -
           Lwt.return result

     

       567
       567
       -
       end

-364

lib/jmap.mli

···

       1
       1
       -
       (**

     

       2
       2
       -
        * JMAP protocol implementation based on RFC8620

     

       3
       3
       -
        * https://datatracker.ietf.org/doc/html/rfc8620

     

       4
       4
       -
        *)

     

       5
       5
       -
       

     

       6
       6
       -
       (** {1 Types} *)

     

       7
       7
       -
       

     

       8
       8
       -
       module Types : sig

     

       9
       9
       -
         (** Id string as per Section 1.2 *)

     

       10
       10
       -
         type id = string

     

       11
       11
       -
       

     

       12
       12
       -
         (** Int bounded within the range -2^53+1 to 2^53-1 as per Section 1.3 *)

     

       13
       13
       -
         type int_t = int

     

       14
       14
       -
       

     

       15
       15
       -
         (** UnsignedInt bounded within the range 0 to 2^53-1 as per Section 1.3 *)

     

       16
       16
       -
         type unsigned_int = int

     

       17
       17
       -
       

     

       18
       18
       -
         (** Date string in RFC3339 format as per Section 1.4 *)

     

       19
       19
       -
         type date = string

     

       20
       20
       -
       

     

       21
       21
       -
         (** UTCDate is a Date with 'Z' time zone as per Section 1.4 *)

     

       22
       22
       -
         type utc_date = string

     

       23
       23
       -
       

     

       24
       24
       -
         (** Error object as per Section 3.6.2 *)

     

       25
       25
       -
         type error = {

     

       26
       26
       -
           type_: string;

     

       27
       27
       -
           description: string option;

     

       28
       28
       -
         }

     

       29
       29
       -
       

     

       30
       30
       -
         (** Set error object as per Section 5.3 *)

     

       31
       31
       -
         type set_error = {

     

       32
       32
       -
           type_: string;

     

       33
       33
       -
           description: string option;

     

       34
       34
       -
           properties: string list option;

     

       35
       35
       -
           (* Additional properties for specific error types *)

     

       36
       36
       -
           existing_id: id option; (* For alreadyExists error *)

     

       37
       37
       -
         }

     

       38
       38
       -
       

     

       39
       39
       -
         (** Invocation object as per Section 3.2 *)

     

       40
       40
       -
         type 'a invocation = {

     

       41
       41
       -
           name: string;

     

       42
       42
       -
           arguments: 'a;

     

       43
       43
       -
           method_call_id: string;

     

       44
       44
       -
         }

     

       45
       45
       -
       

     

       46
       46
       -
         (** ResultReference object as per Section 3.7 *)

     

       47
       47
       -
         type result_reference = {

     

       48
       48
       -
           result_of: string;

     

       49
       49
       -
           name: string;

     

       50
       50
       -
           path: string;

     

       51
       51
       -
         }

     

       52
       52
       -
       

     

       53
       53
       -
         (** FilterOperator, FilterCondition and Filter as per Section 5.5 *)

     

       54
       54
       -
         type filter_operator = {

     

       55
       55
       -
           operator: string; (* "AND", "OR", "NOT" *)

     

       56
       56
       -
           conditions: filter list;

     

       57
       57
       -
         }

     

       58
       58
       -
         and filter_condition = (string * Ezjsonm.value) list

     

       59
       59
       -
         and filter = 

     

       60
       60
       -
           | Operator of filter_operator

     

       61
       61
       -
           | Condition of filter_condition

     

       62
       62
       -
       

     

       63
       63
       -
         (** Comparator object for sorting as per Section 5.5 *)

     

       64
       64
       -
         type comparator = {

     

       65
       65
       -
           property: string;

     

       66
       66
       -
           is_ascending: bool option; (* Optional, defaults to true *)

     

       67
       67
       -
           collation: string option;  (* Optional, server-dependent default *)

     

       68
       68
       -
         }

     

       69
       69
       -
       

     

       70
       70
       -
         (** PatchObject as per Section 5.3 *)

     

       71
       71
       -
         type patch_object = (string * Ezjsonm.value) list

     

       72
       72
       -
       

     

       73
       73
       -
         (** AddedItem structure as per Section 5.6 *)

     

       74
       74
       -
         type added_item = {

     

       75
       75
       -
           id: id;

     

       76
       76
       -
           index: unsigned_int;

     

       77
       77
       -
         }

     

       78
       78
       -
       

     

       79
       79
       -
         (** Account object as per Section 1.6.2 *)

     

       80
       80
       -
         type account = {

     

       81
       81
       -
           name: string;

     

       82
       82
       -
           is_personal: bool;

     

       83
       83
       -
           is_read_only: bool;

     

       84
       84
       -
           account_capabilities: (string * Ezjsonm.value) list;

     

       85
       85
       -
         }

     

       86
       86
       -
       

     

       87
       87
       -
         (** Core capability object as per Section 2 *)

     

       88
       88
       -
         type core_capability = {

     

       89
       89
       -
           max_size_upload: unsigned_int;

     

       90
       90
       -
           max_concurrent_upload: unsigned_int;

     

       91
       91
       -
           max_size_request: unsigned_int;

     

       92
       92
       -
           max_concurrent_requests: unsigned_int;

     

       93
       93
       -
           max_calls_in_request: unsigned_int;

     

       94
       94
       -
           max_objects_in_get: unsigned_int;

     

       95
       95
       -
           max_objects_in_set: unsigned_int;

     

       96
       96
       -
           collation_algorithms: string list;

     

       97
       97
       -
         }

     

       98
       98
       -
       

     

       99
       99
       -
         (** PushSubscription keys object as per Section 7.2 *)

     

       100
       100
       -
         type push_keys = {

     

       101
       101
       -
           p256dh: string;

     

       102
       102
       -
           auth: string;

     

       103
       103
       -
         }

     

       104
       104
       -
       

     

       105
       105
       -
         (** Session object as per Section 2 *)

     

       106
       106
       -
         type session = {

     

       107
       107
       -
           capabilities: (string * Ezjsonm.value) list;

     

       108
       108
       -
           accounts: (id * account) list;

     

       109
       109
       -
           primary_accounts: (string * id) list;

     

       110
       110
       -
           username: string;

     

       111
       111
       -
           api_url: string;

     

       112
       112
       -
           download_url: string;

     

       113
       113
       -
           upload_url: string;

     

       114
       114
       -
           event_source_url: string option;

     

       115
       115
       -
           state: string;

     

       116
       116
       -
         }

     

       117
       117
       -
       

     

       118
       118
       -
         (** TypeState for state changes as per Section 7.1 *)

     

       119
       119
       -
         type type_state = (string * string) list

     

       120
       120
       -
       

     

       121
       121
       -
         (** StateChange object as per Section 7.1 *)

     

       122
       122
       -
         type state_change = {

     

       123
       123
       -
           changed: (id * type_state) list;

     

       124
       124
       -
         }

     

       125
       125
       -
       

     

       126
       126
       -
         (** PushVerification object as per Section 7.2.2 *)

     

       127
       127
       -
         type push_verification = {

     

       128
       128
       -
           push_subscription_id: id;

     

       129
       129
       -
           verification_code: string;

     

       130
       130
       -
         }

     

       131
       131
       -
       

     

       132
       132
       -
         (** PushSubscription object as per Section 7.2 *)

     

       133
       133
       -
         type push_subscription = {

     

       134
       134
       -
           id: id;

     

       135
       135
       -
           device_client_id: string;

     

       136
       136
       -
           url: string;

     

       137
       137
       -
           keys: push_keys option;

     

       138
       138
       -
           verification_code: string option;

     

       139
       139
       -
           expires: utc_date option;

     

       140
       140
       -
           types: string list option;

     

       141
       141
       -
         }

     

       142
       142
       -
       

     

       143
       143
       -
         (** Request object as per Section 3.3 *)

     

       144
       144
       -
         type request = {

     

       145
       145
       -
           using: string list;

     

       146
       146
       -
           method_calls: Ezjsonm.value invocation list;

     

       147
       147
       -
           created_ids: (id * id) list option;

     

       148
       148
       -
         }

     

       149
       149
       -
       

     

       150
       150
       -
         (** Response object as per Section 3.4 *)

     

       151
       151
       -
         type response = {

     

       152
       152
       -
           method_responses: Ezjsonm.value invocation list;

     

       153
       153
       -
           created_ids: (id * id) list option;

     

       154
       154
       -
           session_state: string;

     

       155
       155
       -
         }

     

       156
       156
       -
       

     

       157
       157
       -
         (** Standard method arguments and responses *)

     

       158
       158
       -
       

     

       159
       159
       -
         (** Arguments for Foo/get method as per Section 5.1 *)

     

       160
       160
       -
         type 'a get_arguments = {

     

       161
       161
       -
           account_id: id;

     

       162
       162
       -
           ids: id list option;

     

       163
       163
       -
           properties: string list option;

     

       164
       164
       -
         }

     

       165
       165
       -
       

     

       166
       166
       -
         (** Response for Foo/get method as per Section 5.1 *)

     

       167
       167
       -
         type 'a get_response = {

     

       168
       168
       -
           account_id: id;

     

       169
       169
       -
           state: string;

     

       170
       170
       -
           list: 'a list;

     

       171
       171
       -
           not_found: id list;

     

       172
       172
       -
         }

     

       173
       173
       -
       

     

       174
       174
       -
         (** Arguments for Foo/changes method as per Section 5.2 *)

     

       175
       175
       -
         type changes_arguments = {

     

       176
       176
       -
           account_id: id;

     

       177
       177
       -
           since_state: string;

     

       178
       178
       -
           max_changes: unsigned_int option;

     

       179
       179
       -
         }

     

       180
       180
       -
       

     

       181
       181
       -
         (** Response for Foo/changes method as per Section 5.2 *)

     

       182
       182
       -
         type changes_response = {

     

       183
       183
       -
           account_id: id;

     

       184
       184
       -
           old_state: string;

     

       185
       185
       -
           new_state: string;

     

       186
       186
       -
           has_more_changes: bool;

     

       187
       187
       -
           created: id list;

     

       188
       188
       -
           updated: id list;

     

       189
       189
       -
           destroyed: id list;

     

       190
       190
       -
         }

     

       191
       191
       -
       

     

       192
       192
       -
         (** Arguments for Foo/set method as per Section 5.3 *)

     

       193
       193
       -
         type 'a set_arguments = {

     

       194
       194
       -
           account_id: id;

     

       195
       195
       -
           if_in_state: string option;

     

       196
       196
       -
           create: (id * 'a) list option;

     

       197
       197
       -
           update: (id * patch_object) list option;

     

       198
       198
       -
           destroy: id list option;

     

       199
       199
       -
         }

     

       200
       200
       -
       

     

       201
       201
       -
         (** Response for Foo/set method as per Section 5.3 *)

     

       202
       202
       -
         type 'a set_response = {

     

       203
       203
       -
           account_id: id;

     

       204
       204
       -
           old_state: string option;

     

       205
       205
       -
           new_state: string;

     

       206
       206
       -
           created: (id * 'a) list option;

     

       207
       207
       -
           updated: (id * 'a option) list option;

     

       208
       208
       -
           destroyed: id list option;

     

       209
       209
       -
           not_created: (id * set_error) list option;

     

       210
       210
       -
           not_updated: (id * set_error) list option;

     

       211
       211
       -
           not_destroyed: (id * set_error) list option;

     

       212
       212
       -
         }

     

       213
       213
       -
       

     

       214
       214
       -
         (** Arguments for Foo/copy method as per Section 5.4 *)

     

       215
       215
       -
         type 'a copy_arguments = {

     

       216
       216
       -
           from_account_id: id;

     

       217
       217
       -
           if_from_in_state: string option;

     

       218
       218
       -
           account_id: id;

     

       219
       219
       -
           if_in_state: string option;

     

       220
       220
       -
           create: (id * 'a) list;

     

       221
       221
       -
           on_success_destroy_original: bool option;

     

       222
       222
       -
           destroy_from_if_in_state: string option;

     

       223
       223
       -
         }

     

       224
       224
       -
       

     

       225
       225
       -
         (** Response for Foo/copy method as per Section 5.4 *)

     

       226
       226
       -
         type 'a copy_response = {

     

       227
       227
       -
           from_account_id: id;

     

       228
       228
       -
           account_id: id;

     

       229
       229
       -
           old_state: string option;

     

       230
       230
       -
           new_state: string;

     

       231
       231
       -
           created: (id * 'a) list option;

     

       232
       232
       -
           not_created: (id * set_error) list option;

     

       233
       233
       -
         }

     

       234
       234
       -
       

     

       235
       235
       -
         (** Arguments for Foo/query method as per Section 5.5 *)

     

       236
       236
       -
         type query_arguments = {

     

       237
       237
       -
           account_id: id;

     

       238
       238
       -
           filter: filter option;

     

       239
       239
       -
           sort: comparator list option;

     

       240
       240
       -
           position: int_t option;

     

       241
       241
       -
           anchor: id option;

     

       242
       242
       -
           anchor_offset: int_t option;

     

       243
       243
       -
           limit: unsigned_int option;

     

       244
       244
       -
           calculate_total: bool option;

     

       245
       245
       -
         }

     

       246
       246
       -
       

     

       247
       247
       -
         (** Response for Foo/query method as per Section 5.5 *)

     

       248
       248
       -
         type query_response = {

     

       249
       249
       -
           account_id: id;

     

       250
       250
       -
           query_state: string;

     

       251
       251
       -
           can_calculate_changes: bool;

     

       252
       252
       -
           position: unsigned_int;

     

       253
       253
       -
           ids: id list;

     

       254
       254
       -
           total: unsigned_int option;

     

       255
       255
       -
           limit: unsigned_int option;

     

       256
       256
       -
         }

     

       257
       257
       -
       

     

       258
       258
       -
         (** Arguments for Foo/queryChanges method as per Section 5.6 *)

     

       259
       259
       -
         type query_changes_arguments = {

     

       260
       260
       -
           account_id: id;

     

       261
       261
       -
           filter: filter option;

     

       262
       262
       -
           sort: comparator list option;

     

       263
       263
       -
           since_query_state: string;

     

       264
       264
       -
           max_changes: unsigned_int option;

     

       265
       265
       -
           up_to_id: id option;

     

       266
       266
       -
           calculate_total: bool option;

     

       267
       267
       -
         }

     

       268
       268
       -
       

     

       269
       269
       -
         (** Response for Foo/queryChanges method as per Section 5.6 *)

     

       270
       270
       -
         type query_changes_response = {

     

       271
       271
       -
           account_id: id;

     

       272
       272
       -
           old_query_state: string;

     

       273
       273
       -
           new_query_state: string;

     

       274
       274
       -
           total: unsigned_int option;

     

       275
       275
       -
           removed: id list;

     

       276
       276
       -
           added: added_item list option;

     

       277
       277
       -
         }

     

       278
       278
       -
       

     

       279
       279
       -
         (** Arguments for Blob/copy method as per Section 6.3 *)

     

       280
       280
       -
         type blob_copy_arguments = {

     

       281
       281
       -
           from_account_id: id;

     

       282
       282
       -
           account_id: id;

     

       283
       283
       -
           blob_ids: id list;

     

       284
       284
       -
         }

     

       285
       285
       -
       

     

       286
       286
       -
         (** Response for Blob/copy method as per Section 6.3 *)

     

       287
       287
       -
         type blob_copy_response = {

     

       288
       288
       -
           from_account_id: id;

     

       289
       289
       -
           account_id: id;

     

       290
       290
       -
           copied: (id * id) list option;

     

       291
       291
       -
           not_copied: (id * set_error) list option;

     

       292
       292
       -
         }

     

       293
       293
       -
       

     

       294
       294
       -
         (** Upload response as per Section 6.1 *)

     

       295
       295
       -
         type upload_response = {

     

       296
       296
       -
           account_id: id;

     

       297
       297
       -
           blob_id: id;

     

       298
       298
       -
           type_: string;

     

       299
       299
       -
           size: unsigned_int;

     

       300
       300
       -
         }

     

       301
       301
       -
       

     

       302
       302
       -
         (** Problem details object as per RFC7807 and Section 3.6.1 *)

     

       303
       303
       -
         type problem_details = {

     

       304
       304
       -
           type_: string;

     

       305
       305
       -
           status: int option;

     

       306
       306
       -
           detail: string option;

     

       307
       307
       -
           limit: string option; (* For "limit" error *)

     

       308
       308
       -
         }

     

       309
       309
       -
       end

     

       310
       310
       -
       

     

       311
       311
       -
       (** {1 API Client} *)

     

       312
       312
       -
       

     

       313
       313
       -
       (** Module for making JMAP API requests over HTTP.

     

       314
       314
       -
           Provides functionality to interact with JMAP servers according to RFC8620. *)

     

       315
       315
       -
       module Api : sig

     

       316
       316
       -
         (** Error that may occur during API requests *)

     

       317
       317
       -
         type error =

     

       318
       318
       -
           | Connection_error of string

     

       319
       319
       -
           | HTTP_error of int * string

     

       320
       320
       -
           | Parse_error of string

     

       321
       321
       -
           | Authentication_error

     

       322
       322
       -
         

     

       323
       323
       -
         (** Result type for API operations *)

     

       324
       324
       -
         type 'a result = ('a, error) Stdlib.result

     

       325
       325
       -
         

     

       326
       326
       -
         (** Configuration for a JMAP API client *)

     

       327
       327
       -
         type config = {

     

       328
       328
       -
           api_uri: Uri.t;

     

       329
       329
       -
           username: string;

     

       330
       330
       -
           authentication_token: string;

     

       331
       331
       -
         }

     

       332
       332
       -
         

     

       333
       333
       -
         (** Make a raw JMAP API request *)

     

       334
       334
       -
         val make_request : 

     

       335
       335
       -
           config -> 

     

       336
       336
       -
           Types.request ->

     

       337
       337
       -
           Types.response result Lwt.t

     

       338
       338
       -
         

     

       339
       339
       -
         (** Fetch a Session object from a JMAP server *)

     

       340
       340
       -
         val get_session :

     

       341
       341
       -
           Uri.t ->

     

       342
       342
       -
           ?username:string ->

     

       343
       343
       -
           ?authentication_token:string ->

     

       344
       344
       -
           unit ->

     

       345
       345
       -
           Types.session result Lwt.t

     

       346
       346
       -
         

     

       347
       347
       -
         (** Upload a binary blob to the server *)

     

       348
       348
       -
         val upload_blob :

     

       349
       349
       -
           config ->

     

       350
       350
       -
           account_id:Types.id ->

     

       351
       351
       -
           content_type:string ->

     

       352
       352
       -
           string ->

     

       353
       353
       -
           Types.upload_response result Lwt.t

     

       354
       354
       -
         

     

       355
       355
       -
         (** Download a binary blob from the server *)

     

       356
       356
       -
         val download_blob :

     

       357
       357
       -
           config ->

     

       358
       358
       -
           account_id:Types.id ->

     

       359
       359
       -
           blob_id:Types.id ->

     

       360
       360
       -
           ?type_:string ->

     

       361
       361
       -
           ?name:string ->

     

       362
       362
       -
           unit ->

     

       363
       363
       -
           string result Lwt.t

     

       364
       364
       -
       end

lib/jmap_mail.ml

This is a binary file and will not be displayed.

lib/jmap_mail.mli

This is a binary file and will not be displayed.

+896

spec/draft-ietf-mailmaint-messageflag-mailboxattribute-02.txt

···

       1
       1
       +
       

     

       2
       2
       +
       

     

       3
       3
       +
       

     

       4
       4
       +
       

     

       5
       5
       +
       MailMaint                                              N.M. Jenkins, Ed.

     

       6
       6
       +
       Internet-Draft                                                  Fastmail

     

       7
       7
       +
       Intended status: Informational                            D. Eggert, Ed.

     

       8
       8
       +
       Expires: 21 August 2025                                        Apple Inc

     

       9
       9
       +
                                                               17 February 2025

     

       10
       10
       +
       

     

       11
       11
       +
       

     

       12
       12
       +
        Registration of further IMAP/JMAP keywords and mailbox attribute names

     

       13
       13
       +
                 draft-ietf-mailmaint-messageflag-mailboxattribute-02

     

       14
       14
       +
       

     

       15
       15
       +
       Abstract

     

       16
       16
       +
       

     

       17
       17
       +
          This document defines a number of keywords that have been in use by

     

       18
       18
       +
          Fastmail and Apple respectively for some time.  It defines their

     

       19
       19
       +
          intended use.  Additionally some mailbox names with special meaning

     

       20
       20
       +
          have been in use by Fastmail, and this document defines their

     

       21
       21
       +
          intended use.  This document registers all of these names with IANA

     

       22
       22
       +
          to avoid name collisions.

     

       23
       23
       +
       

     

       24
       24
       +
       Status of This Memo

     

       25
       25
       +
       

     

       26
       26
       +
          This Internet-Draft is submitted in full conformance with the

     

       27
       27
       +
          provisions of BCP 78 and BCP 79.

     

       28
       28
       +
       

     

       29
       29
       +
          Internet-Drafts are working documents of the Internet Engineering

     

       30
       30
       +
          Task Force (IETF).  Note that other groups may also distribute

     

       31
       31
       +
          working documents as Internet-Drafts.  The list of current Internet-

     

       32
       32
       +
          Drafts is at https://datatracker.ietf.org/drafts/current/.

     

       33
       33
       +
       

     

       34
       34
       +
          Internet-Drafts are draft documents valid for a maximum of six months

     

       35
       35
       +
          and may be updated, replaced, or obsoleted by other documents at any

     

       36
       36
       +
          time.  It is inappropriate to use Internet-Drafts as reference

     

       37
       37
       +
          material or to cite them other than as "work in progress."

     

       38
       38
       +
       

     

       39
       39
       +
          This Internet-Draft will expire on 21 August 2025.

     

       40
       40
       +
       

     

       41
       41
       +
       Copyright Notice

     

       42
       42
       +
       

     

       43
       43
       +
          Copyright (c) 2025 IETF Trust and the persons identified as the

     

       44
       44
       +
          document authors.  All rights reserved.

     

       45
       45
       +
       

     

       46
       46
       +
       

     

       47
       47
       +
       

     

       48
       48
       +
       

     

       49
       49
       +
       

     

       50
       50
       +
       

     

       51
       51
       +
       

     

       52
       52
       +
       

     

       53
       53
       +
       

     

       54
       54
       +
       

     

       55
       55
       +
       

     

       56
       56
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 1]

     

       57
       57
       +
       

     

       58
       58
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       59
       59
       +
       

     

       60
       60
       +
       

     

       61
       61
       +
          This document is subject to BCP 78 and the IETF Trust's Legal

     

       62
       62
       +
          Provisions Relating to IETF Documents (https://trustee.ietf.org/

     

       63
       63
       +
          license-info) in effect on the date of publication of this document.

     

       64
       64
       +
          Please review these documents carefully, as they describe your rights

     

       65
       65
       +
          and restrictions with respect to this document.  Code Components

     

       66
       66
       +
          extracted from this document must include Revised BSD License text as

     

       67
       67
       +
          described in Section 4.e of the Trust Legal Provisions and are

     

       68
       68
       +
          provided without warranty as described in the Revised BSD License.

     

       69
       69
       +
       

     

       70
       70
       +
       Table of Contents

     

       71
       71
       +
       

     

       72
       72
       +
          1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3

     

       73
       73
       +
          2.  Requirements Language . . . . . . . . . . . . . . . . . . . .   4

     

       74
       74
       +
          3.  Flag Colors . . . . . . . . . . . . . . . . . . . . . . . . .   4

     

       75
       75
       +
            3.1.  Definition of the MailFlagBit Message Keyword . . . . . .   4

     

       76
       76
       +
            3.2.  Implementation Notes  . . . . . . . . . . . . . . . . . .   5

     

       77
       77
       +
          4.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .   5

     

       78
       78
       +
            4.1.  IMAP/JMAP Keyword Registrations . . . . . . . . . . . . .   5

     

       79
       79
       +
              4.1.1.  $notify keyword registration  . . . . . . . . . . . .   5

     

       80
       80
       +
              4.1.2.  $muted keyword registration . . . . . . . . . . . . .   6

     

       81
       81
       +
              4.1.3.  $followed keyword registration  . . . . . . . . . . .   7

     

       82
       82
       +
              4.1.4.  $memo keyword registration  . . . . . . . . . . . . .   7

     

       83
       83
       +
              4.1.5.  $hasmemo keyword registration . . . . . . . . . . . .   8

     

       84
       84
       +
              4.1.6.  Attachment Detection  . . . . . . . . . . . . . . . .   8

     

       85
       85
       +
              4.1.7.  $autosent keyword registration  . . . . . . . . . . .   9

     

       86
       86
       +
              4.1.8.  $unsubscribed keyword registration  . . . . . . . . .  10

     

       87
       87
       +
              4.1.9.  $canunsubscribe keyword registration  . . . . . . . .  10

     

       88
       88
       +
              4.1.10. $imported keyword registration  . . . . . . . . . . .  11

     

       89
       89
       +
              4.1.11. $istrusted keyword registration . . . . . . . . . . .  11

     

       90
       90
       +
              4.1.12. $maskedemail keyword registration . . . . . . . . . .  12

     

       91
       91
       +
              4.1.13. $new keyword registration . . . . . . . . . . . . . .  12

     

       92
       92
       +
              4.1.14. $MailFlagBit0 keyword registration  . . . . . . . . .  13

     

       93
       93
       +
              4.1.15. $MailFlagBit1 keyword registration  . . . . . . . . .  13

     

       94
       94
       +
              4.1.16. $MailFlagBit2 keyword registration  . . . . . . . . .  13

     

       95
       95
       +
            4.2.  IMAP Mailbox Name Attributes Registrations  . . . . . . .  14

     

       96
       96
       +
              4.2.1.  Snoozed mailbox name attribute registration . . . . .  14

     

       97
       97
       +
              4.2.2.  Scheduled mailbox name attribute registration . . . .  14

     

       98
       98
       +
              4.2.3.  Memos mailbox name attribute registration . . . . . .  14

     

       99
       99
       +
          5.  Security Considerations . . . . . . . . . . . . . . . . . . .  15

     

       100
       100
       +
          6.  References  . . . . . . . . . . . . . . . . . . . . . . . . .  15

     

       101
       101
       +
            6.1.  Normative References  . . . . . . . . . . . . . . . . . .  15

     

       102
       102
       +
          Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . .  15

     

       103
       103
       +
       

     

       104
       104
       +
       

     

       105
       105
       +
       

     

       106
       106
       +
       

     

       107
       107
       +
       

     

       108
       108
       +
       

     

       109
       109
       +
       

     

       110
       110
       +
       

     

       111
       111
       +
       

     

       112
       112
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 2]

     

       113
       113
       +
       

     

       114
       114
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       115
       115
       +
       

     

       116
       116
       +
       

     

       117
       117
       +
       1.  Introduction

     

       118
       118
       +
       

     

       119
       119
       +
          The Internet Message Access Protocol (IMAP) specification [RFC9051]

     

       120
       120
       +
          defines the use of message keywords, and an "IMAP Keywords" registry

     

       121
       121
       +
          is created in [RFC5788].  Similarly [RFC8457] creates an "IMAP

     

       122
       122
       +
          Mailbox Name Attributes Registry".

     

       123
       123
       +
       

     

       124
       124
       +
          This document does the following:

     

       125
       125
       +
       

     

       126
       126
       +
          *  Defines 16 message keywords

     

       127
       127
       +
       

     

       128
       128
       +
             -  $notify

     

       129
       129
       +
       

     

       130
       130
       +
             -  $muted

     

       131
       131
       +
       

     

       132
       132
       +
             -  $followed

     

       133
       133
       +
       

     

       134
       134
       +
             -  $memo

     

       135
       135
       +
       

     

       136
       136
       +
             -  $hasmemo

     

       137
       137
       +
       

     

       138
       138
       +
             -  $hasattachment

     

       139
       139
       +
       

     

       140
       140
       +
             -  $hasnoattachment

     

       141
       141
       +
       

     

       142
       142
       +
             -  $autosent

     

       143
       143
       +
       

     

       144
       144
       +
             -  $unsubscribed

     

       145
       145
       +
       

     

       146
       146
       +
             -  $canunsubscribe

     

       147
       147
       +
       

     

       148
       148
       +
             -  $imported

     

       149
       149
       +
       

     

       150
       150
       +
             -  $istrusted

     

       151
       151
       +
       

     

       152
       152
       +
             -  $maskedemail

     

       153
       153
       +
       

     

       154
       154
       +
             -  $new

     

       155
       155
       +
       

     

       156
       156
       +
             -  $MailFlagBit0

     

       157
       157
       +
       

     

       158
       158
       +
             -  $MailFlagBit1

     

       159
       159
       +
       

     

       160
       160
       +
             -  $MailFlagBit2

     

       161
       161
       +
       

     

       162
       162
       +
          *  Defines 3 mailbox name attributes

     

       163
       163
       +
       

     

       164
       164
       +
             -  Snoozed

     

       165
       165
       +
       

     

       166
       166
       +
       

     

       167
       167
       +
       

     

       168
       168
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 3]

     

       169
       169
       +
       

     

       170
       170
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       171
       171
       +
       

     

       172
       172
       +
       

     

       173
       173
       +
             -  Scheduled

     

       174
       174
       +
       

     

       175
       175
       +
             -  Memos

     

       176
       176
       +
       

     

       177
       177
       +
          *  Registers these in the "IMAP Keywords" registry and "IMAP Mailbox

     

       178
       178
       +
             Name Attributes" registry respectively.

     

       179
       179
       +
       

     

       180
       180
       +
       2.  Requirements Language

     

       181
       181
       +
       

     

       182
       182
       +
          The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",

     

       183
       183
       +
          "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and

     

       184
       184
       +
          "OPTIONAL" in this document are to be interpreted as described in BCP

     

       185
       185
       +
          14 [RFC2119] [RFC8174] when, and only when, they appear in all

     

       186
       186
       +
          capitals, as shown here.

     

       187
       187
       +
       

     

       188
       188
       +
       3.  Flag Colors

     

       189
       189
       +
       

     

       190
       190
       +
          The Internet Message Access Protocol (IMAP) specification [RFC9051]

     

       191
       191
       +
          defines a \Flagged system flag to mark a message for urgent/special

     

       192
       192
       +
          attention.  The new keywords defined in Sections 4.1.14, 4.1.15, and

     

       193
       193
       +
          4.1.16 allow such a flagged message to have that flag be of one of 7

     

       194
       194
       +
          colors.

     

       195
       195
       +
       

     

       196
       196
       +
       3.1.  Definition of the MailFlagBit Message Keyword

     

       197
       197
       +
       

     

       198
       198
       +
          The 3 flag color keywords $MailFlagBit0, $MailFlagBit1, and

     

       199
       199
       +
          $MailFlagBit2 make up a bit pattern that define the color of the flag

     

       200
       200
       +
          as such:

     

       201
       201
       +
       

     

       202
       202
       +
                           +=======+=======+=======+========+

     

       203
       203
       +
                           | Bit 0 | Bit 1 | Bit 2 | Color  |

     

       204
       204
       +
                           +=======+=======+=======+========+

     

       205
       205
       +
                           | 0     | 0     | 0     | red    |

     

       206
       206
       +
                           +-------+-------+-------+--------+

     

       207
       207
       +
                           | 1     | 0     | 0     | orange |

     

       208
       208
       +
                           +-------+-------+-------+--------+

     

       209
       209
       +
                           | 0     | 1     | 0     | yellow |

     

       210
       210
       +
                           +-------+-------+-------+--------+

     

       211
       211
       +
                           | 1     | 1     | 1     | green  |

     

       212
       212
       +
                           +-------+-------+-------+--------+

     

       213
       213
       +
                           | 0     | 0     | 1     | blue   |

     

       214
       214
       +
                           +-------+-------+-------+--------+

     

       215
       215
       +
                           | 1     | 0     | 1     | purple |

     

       216
       216
       +
                           +-------+-------+-------+--------+

     

       217
       217
       +
                           | 0     | 1     | 1     | gray   |

     

       218
       218
       +
                           +-------+-------+-------+--------+

     

       219
       219
       +
       

     

       220
       220
       +
                                  Table 1: Flag Colors

     

       221
       221
       +
       

     

       222
       222
       +
       

     

       223
       223
       +
       

     

       224
       224
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 4]

     

       225
       225
       +
       

     

       226
       226
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       227
       227
       +
       

     

       228
       228
       +
       

     

       229
       229
       +
          These flags SHOULD be ignored if the \Flagged system flag is not set.

     

       230
       230
       +
          If the \Flagged system flag is set, the flagged status MAY be

     

       231
       231
       +
          displayed to the user in the color corresponding to the combination

     

       232
       232
       +
          of the 3 flag color keywords.

     

       233
       233
       +
       

     

       234
       234
       +
       3.2.  Implementation Notes

     

       235
       235
       +
       

     

       236
       236
       +
          A mail client that is aware of these flag color keywords SHOULD clear

     

       237
       237
       +
          all 3 flag color keywords when the user unflags the message, i.e.

     

       238
       238
       +
          when unsetting the \Flagged system flag, all 3 flag color keywords

     

       239
       239
       +
          SHOULD also be unset.

     

       240
       240
       +
       

     

       241
       241
       +
          A mail client SHOULD NOT set any of these flags unless the \Flagged

     

       242
       242
       +
          system flag is already set or is being set.

     

       243
       243
       +
       

     

       244
       244
       +
          Servers MAY unset these flag color keywords when a client unsets the

     

       245
       245
       +
          \Flagged system flag.

     

       246
       246
       +
       

     

       247
       247
       +
       4.  IANA Considerations

     

       248
       248
       +
       

     

       249
       249
       +
          3 IMAP/JMAP keywords are registered in the IMAP/JMAP keywords

     

       250
       250
       +
          registry, as established in RFC5788.

     

       251
       251
       +
       

     

       252
       252
       +
       4.1.  IMAP/JMAP Keyword Registrations

     

       253
       253
       +
       

     

       254
       254
       +
       4.1.1.  $notify keyword registration

     

       255
       255
       +
       

     

       256
       256
       +
          IMAP/JMAP keyword name:  $notify

     

       257
       257
       +
          Purpose:  Indicate to the client that a notification should be shown

     

       258
       258
       +
             for this message.

     

       259
       259
       +
          Private or Shared on a server:  SHARED

     

       260
       260
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       261
       261
       +
             keyword can cause automatic action.  On supporting clients, when a

     

       262
       262
       +
             new message is added to the mailstore with this keyword, the

     

       263
       263
       +
             client should show the user a notification.

     

       264
       264
       +
             Mail clients commonly show notifications for new mail, but often

     

       265
       265
       +
             the only option is to show a notification for every message that

     

       266
       266
       +
             arrives in the inbox.  This keyword allows the user to create

     

       267
       267
       +
             rules (or the server to automatically determine) specific messages

     

       268
       268
       +
             that should show a notification.

     

       269
       269
       +
             Notifications for these messages may be in addition to

     

       270
       270
       +
             notifications for messages matching other criteria, according to

     

       271
       271
       +
             user preference set on the client.

     

       272
       272
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       273
       273
       +
       

     

       274
       274
       +
       

     

       275
       275
       +
       

     

       276
       276
       +
       

     

       277
       277
       +
       

     

       278
       278
       +
       

     

       279
       279
       +
       

     

       280
       280
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 5]

     

       281
       281
       +
       

     

       282
       282
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       283
       283
       +
       

     

       284
       284
       +
       

     

       285
       285
       +
             server on delivery when a message meets criteria such that the

     

       286
       286
       +
             user should be shown a notification.  It may be cleared by a

     

       287
       287
       +
             client when the user opens, archives, or otherwise interacts with

     

       288
       288
       +
             the message.  Other clients connected to the same account may

     

       289
       289
       +
             choose to automatically close the notification if the flag is

     

       290
       290
       +
             cleared.

     

       291
       291
       +
          Related keywords:  None

     

       292
       292
       +
          Related IMAP capabilities:  None

     

       293
       293
       +
          Security considerations:  None

     

       294
       294
       +
          Published specification:  This document

     

       295
       295
       +
          Intended usage:  COMMON

     

       296
       296
       +
          Scope:  BOTH

     

       297
       297
       +
          Owner/Change controller:  IESG

     

       298
       298
       +
       

     

       299
       299
       +
       4.1.2.  $muted keyword registration

     

       300
       300
       +
       

     

       301
       301
       +
          IMAP/JMAP keyword name:  $muted

     

       302
       302
       +
          Purpose:  Indicate to the server that the user is not interested in

     

       303
       303
       +
             future replies to a particular thread.

     

       304
       304
       +
          Private or Shared on a server:  SHARED

     

       305
       305
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       306
       306
       +
             keyword can cause automatic action.  On supporting servers, when a

     

       307
       307
       +
             new message arrives that is in the same thread as a message with

     

       308
       308
       +
             this keyword the server may automatically process it in some way

     

       309
       309
       +
             to deprioritise it for the user, for example by moving it to the

     

       310
       310
       +
             archive or trash, or marking it read.  The exact action, whether

     

       311
       311
       +
             this is customisable by the user, and interaction with user rules

     

       312
       312
       +
             is vendor specific.

     

       313
       313
       +
             A message is defined to be in the same thread as another if the

     

       314
       314
       +
             server assigns them both the same thread id, as defined in

     

       315
       315
       +
             [RFC8474] Section 5.2 for IMAP or [RFC8621], Section 3 for JMAP.

     

       316
       316
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       317
       317
       +
             client when the user indicates they wish to mute or unmute a

     

       318
       318
       +
             thread.  When unmuting a thread, the client must remove the

     

       319
       319
       +
             keyword from every message in the thread that has it.

     

       320
       320
       +
          Related keywords:  Mutually exclusive with $followed.  If both are

     

       321
       321
       +
             specified on a thread, servers MUST behave as though only

     

       322
       322
       +
             $followed were set.

     

       323
       323
       +
          Related IMAP capabilities:  None

     

       324
       324
       +
          Security considerations:  Muting a thread can mean a user won't see a

     

       325
       325
       +
             reply.  If someone compromises a user's account, they may mute

     

       326
       326
       +
             threads where they don't want the user to see the reply, for

     

       327
       327
       +
             example when sending phishing to the user's contacts.  There are

     

       328
       328
       +
             many other ways an attacker with access to the user's mailbox can

     

       329
       329
       +
             also achieve this however, so this is not greatly increasing the

     

       330
       330
       +
             attack surface.

     

       331
       331
       +
          Published specification:  This document

     

       332
       332
       +
          Intended usage:  COMMON

     

       333
       333
       +
       

     

       334
       334
       +
       

     

       335
       335
       +
       

     

       336
       336
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 6]

     

       337
       337
       +
       

     

       338
       338
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       339
       339
       +
       

     

       340
       340
       +
       

     

       341
       341
       +
          Scope:  BOTH

     

       342
       342
       +
          Owner/Change controller:  IESG

     

       343
       343
       +
       

     

       344
       344
       +
       4.1.3.  $followed keyword registration

     

       345
       345
       +
       

     

       346
       346
       +
          IMAP/JMAP keyword name:  $followed

     

       347
       347
       +
          Purpose:  Indicate to the server that the user is particularly

     

       348
       348
       +
             interested in future replies to a particular thread.

     

       349
       349
       +
          Private or Shared on a server:  SHARED

     

       350
       350
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       351
       351
       +
             keyword can cause automatic action.  On supporting servers, when a

     

       352
       352
       +
             new message arrives that is in the same thread as a message with

     

       353
       353
       +
             this keyword the server may automatically process it in some way

     

       354
       354
       +
             to prioritise it for the user, for example by ignoring rules that

     

       355
       355
       +
             would make it skip the inbox, or automatically adding the $notify

     

       356
       356
       +
             keyword.  The exact action, whether this is customisable by the

     

       357
       357
       +
             user, and interaction with user rules is vendor specific.

     

       358
       358
       +
             A message is defined to be in the same thread as another if the

     

       359
       359
       +
             server assigns them both the same thread id, as defined in

     

       360
       360
       +
             [RFC8474] Section 5.2 for IMAP or [RFC8621], Section 3 for JMAP.

     

       361
       361
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       362
       362
       +
             client when the user indicates they wish to follow or unfollow a

     

       363
       363
       +
             thread.  When unfollowing a thread, the client must remove the

     

       364
       364
       +
             keyword from every message in the thread that has it.

     

       365
       365
       +
          Related keywords:  Mutually exclusive with $muted.  If both are

     

       366
       366
       +
             specified on a thread, servers MUST behave as though only

     

       367
       367
       +
             $followed were set.

     

       368
       368
       +
          Related IMAP capabilities:  None

     

       369
       369
       +
          Security considerations:  None

     

       370
       370
       +
          Published specification:  This document

     

       371
       371
       +
          Intended usage:  COMMON

     

       372
       372
       +
          Scope:  BOTH

     

       373
       373
       +
          Owner/Change controller:  IESG

     

       374
       374
       +
       

     

       375
       375
       +
       4.1.4.  $memo keyword registration

     

       376
       376
       +
       

     

       377
       377
       +
          IMAP/JMAP keyword name:  $memo

     

       378
       378
       +
          Purpose:  Indicate to the client that a message is a note-to-self

     

       379
       379
       +
             from the user regarding another message in the same thread.

     

       380
       380
       +
          Private or Shared on a server:  SHARED

     

       381
       381
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       382
       382
       +
             keyword is advisory.

     

       383
       383
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       384
       384
       +
             client when creating such a message.  The message should otherwise

     

       385
       385
       +
             be contructed like a reply to the message to which this memo is

     

       386
       386
       +
             attached (i.e. appropriate Subject and Reply-To headers set).  In

     

       387
       387
       +
             supporting clients, messages with this flag may be presented

     

       388
       388
       +
             differently to the user, attached to the message the memo is

     

       389
       389
       +
       

     

       390
       390
       +
       

     

       391
       391
       +
       

     

       392
       392
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 7]

     

       393
       393
       +
       

     

       394
       394
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       395
       395
       +
       

     

       396
       396
       +
       

     

       397
       397
       +
             commenting on, and may offer the user the ability to edit or

     

       398
       398
       +
             delete the memo.  (As messages are immutable, editing requires

     

       399
       399
       +
             replacing the message.)

     

       400
       400
       +
          Related keywords:  The $hasmemo keyword should be set/cleared at the

     

       401
       401
       +
             same time.

     

       402
       402
       +
          Related IMAP capabilities:  None

     

       403
       403
       +
          Security considerations:  None

     

       404
       404
       +
          Published specification:  This document

     

       405
       405
       +
          Intended usage:  COMMON

     

       406
       406
       +
          Scope:  BOTH

     

       407
       407
       +
          Owner/Change controller:  IESG

     

       408
       408
       +
       

     

       409
       409
       +
       4.1.5.  $hasmemo keyword registration

     

       410
       410
       +
       

     

       411
       411
       +
          IMAP/JMAP keyword name:  $hasmemo

     

       412
       412
       +
          Purpose:  Indicate to the client that a message has an associated

     

       413
       413
       +
             memo with the $memo keyword.

     

       414
       414
       +
          Private or Shared on a server:  SHARED

     

       415
       415
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       416
       416
       +
             keyword is advisory.

     

       417
       417
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       418
       418
       +
             client when creating a memo.  The memo gets the $memo keyword, the

     

       419
       419
       +
             message it is a note for gets the $hasmemo keyword.  This keyword

     

       420
       420
       +
             can help in searching for messages with memos, or deciding whether

     

       421
       421
       +
             to fetch the whole thread to look for memos when loading a

     

       422
       422
       +
             mailbox.

     

       423
       423
       +
          Related keywords:  A message with the $memo keyword should be

     

       424
       424
       +
             created/destroyed at the same time.

     

       425
       425
       +
          Related IMAP capabilities:  None

     

       426
       426
       +
          Security considerations:  None

     

       427
       427
       +
          Published specification:  This document

     

       428
       428
       +
          Intended usage:  COMMON

     

       429
       429
       +
          Scope:  BOTH

     

       430
       430
       +
          Owner/Change controller:  IESG

     

       431
       431
       +
       

     

       432
       432
       +
       4.1.6.  Attachment Detection

     

       433
       433
       +
       

     

       434
       434
       +
          The $hasattachment and $hasnoattachment are mutually exclusive.  A

     

       435
       435
       +
          message SHOULD NOT contain both keywords.

     

       436
       436
       +
       

     

       437
       437
       +
       4.1.6.1.  $hasattachment keyword registration

     

       438
       438
       +
       

     

       439
       439
       +
          IMAP/JMAP keyword name:  $hasattachment

     

       440
       440
       +
          Purpose:  Indicate to the client that a message has an attachment.

     

       441
       441
       +
          Private or Shared on a server:  SHARED

     

       442
       442
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       443
       443
       +
             keyword is advisory.

     

       444
       444
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       445
       445
       +
       

     

       446
       446
       +
       

     

       447
       447
       +
       

     

       448
       448
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 8]

     

       449
       449
       +
       

     

       450
       450
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       451
       451
       +
       

     

       452
       452
       +
       

     

       453
       453
       +
             server on messages it determines have an attachment.  This can

     

       454
       454
       +
             help mailbox clients indicate this to the user without having to

     

       455
       455
       +
             fetch the full message body structure.  Over JMAP, the

     

       456
       456
       +
             "hasAttachment" Email property should indicate the same value.

     

       457
       457
       +
          Related keywords:  $hasnoattachment

     

       458
       458
       +
          Related IMAP capabilities:  None

     

       459
       459
       +
          Security considerations:  None

     

       460
       460
       +
          Published specification:  This document

     

       461
       461
       +
          Intended usage:  COMMON

     

       462
       462
       +
          Scope:  BOTH

     

       463
       463
       +
          Owner/Change controller:  IESG

     

       464
       464
       +
       

     

       465
       465
       +
       4.1.6.2.  $hasnoattachment keyword registration

     

       466
       466
       +
       

     

       467
       467
       +
          IMAP/JMAP keyword name:  $hasnoattachment

     

       468
       468
       +
          Purpose:  Indicate to the client that a message does not have an

     

       469
       469
       +
             attachment.

     

       470
       470
       +
          Private or Shared on a server:  SHARED

     

       471
       471
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       472
       472
       +
             keyword is advisory.

     

       473
       473
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       474
       474
       +
             server on messages it determines does NOT have an attachment.

     

       475
       475
       +
             Over JMAP, the "hasNoAttachment" Email property should indicate

     

       476
       476
       +
             the same value.  This keyword is needed in addition to the

     

       477
       477
       +
             $hasattachment keyword, as a client cannot otherwise determine

     

       478
       478
       +
             whether the server has processed the message for the presence of

     

       479
       479
       +
             an attachment.  In other words, the absence of the $hasattachment

     

       480
       480
       +
             keyword for a message does not tell a client whether the message

     

       481
       481
       +
             actually contains an attachment, as the client has no information

     

       482
       482
       +
             on whether the server has processed the message.

     

       483
       483
       +
          Related keywords:  None

     

       484
       484
       +
          Related IMAP capabilities:  None

     

       485
       485
       +
          Security considerations:  None

     

       486
       486
       +
          Published specification:  This document

     

       487
       487
       +
          Intended usage:  COMMON

     

       488
       488
       +
          Scope:  BOTH

     

       489
       489
       +
          Owner/Change controller:  IESG

     

       490
       490
       +
       

     

       491
       491
       +
       4.1.7.  $autosent keyword registration

     

       492
       492
       +
       

     

       493
       493
       +
          IMAP/JMAP keyword name:  $autosent

     

       494
       494
       +
          Purpose:  Indicate to the client that a message was sent

     

       495
       495
       +
             automatically as a response due to a user rule or setting.

     

       496
       496
       +
          Private or Shared on a server:  SHARED

     

       497
       497
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       498
       498
       +
             keyword is advisory.

     

       499
       499
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       500
       500
       +
       

     

       501
       501
       +
       

     

       502
       502
       +
       

     

       503
       503
       +
       

     

       504
       504
       +
       Jenkins & Eggert         Expires 21 August 2025                 [Page 9]

     

       505
       505
       +
       

     

       506
       506
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       507
       507
       +
       

     

       508
       508
       +
       

     

       509
       509
       +
             server on the user's copy of their vacation response and other

     

       510
       510
       +
             automated messages sent on behalf of the user.  Clients may use

     

       511
       511
       +
             this to indicate to the user that this message was sent

     

       512
       512
       +
             automatically, as if they have forgotten the rule or vacation

     

       513
       513
       +
             response is set up they may be surprised to see it among their

     

       514
       514
       +
             sent items.

     

       515
       515
       +
          Related keywords:  None

     

       516
       516
       +
          Related IMAP capabilities:  None

     

       517
       517
       +
          Security considerations:  None

     

       518
       518
       +
          Published specification:  This document

     

       519
       519
       +
          Intended usage:  COMMON

     

       520
       520
       +
          Scope:  BOTH

     

       521
       521
       +
          Owner/Change controller:  IESG

     

       522
       522
       +
       

     

       523
       523
       +
       4.1.8.  $unsubscribed keyword registration

     

       524
       524
       +
       

     

       525
       525
       +
          IMAP/JMAP keyword name:  $unsubscribed

     

       526
       526
       +
          Purpose:  Indicate to the client that it has unsubscribed from the

     

       527
       527
       +
             thread this message is on.

     

       528
       528
       +
          Private or Shared on a server:  SHARED

     

       529
       529
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       530
       530
       +
             keyword is advisory.

     

       531
       531
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       532
       532
       +
             client on a message after attempting to unsubscribe from the

     

       533
       533
       +
             mailing list this message came from (e.g., after attempting

     

       534
       534
       +
             RFC8058 one-click List-Unsubscribe).  It allows clients to remind

     

       535
       535
       +
             the user that they have unsubscribed if they open the message

     

       536
       536
       +
             again.

     

       537
       537
       +
          Related keywords:  None

     

       538
       538
       +
          Related IMAP capabilities:  None

     

       539
       539
       +
          Security considerations:  None

     

       540
       540
       +
          Published specification:  This document

     

       541
       541
       +
          Intended usage:  COMMON

     

       542
       542
       +
          Scope:  BOTH

     

       543
       543
       +
          Owner/Change controller:  IESG

     

       544
       544
       +
       

     

       545
       545
       +
       4.1.9.  $canunsubscribe keyword registration

     

       546
       546
       +
       

     

       547
       547
       +
          IMAP/JMAP keyword name:  $canunsubscribe

     

       548
       548
       +
          Purpose:  Indicate to the client that this message has an

     

       549
       549
       +
             RFC8058-compliant List-Unsubscribe header.

     

       550
       550
       +
          Private or Shared on a server:  SHARED

     

       551
       551
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       552
       552
       +
             keyword is advisory.

     

       553
       553
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       554
       554
       +
       

     

       555
       555
       +
       

     

       556
       556
       +
       

     

       557
       557
       +
       

     

       558
       558
       +
       

     

       559
       559
       +
       

     

       560
       560
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 10]

     

       561
       561
       +
       

     

       562
       562
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       563
       563
       +
       

     

       564
       564
       +
       

     

       565
       565
       +
             server on messages with an RFC8058-compliant List-Unsubscribe

     

       566
       566
       +
             header.  It may only do so if the message passes vendor-specific

     

       567
       567
       +
             reputation checks.  It is intended to indicate to clients that

     

       568
       568
       +
             they may be able to do a one-click unsubscribe, without them

     

       569
       569
       +
             having to fetch the List-Unsubscribe header to determine themself.

     

       570
       570
       +
          Related keywords:  None

     

       571
       571
       +
          Related IMAP capabilities:  None

     

       572
       572
       +
          Security considerations:  None

     

       573
       573
       +
          Published specification:  This document

     

       574
       574
       +
          Intended usage:  COMMON

     

       575
       575
       +
          Scope:  BOTH

     

       576
       576
       +
          Owner/Change controller:  IESG

     

       577
       577
       +
       

     

       578
       578
       +
       4.1.10.  $imported keyword registration

     

       579
       579
       +
       

     

       580
       580
       +
          IMAP/JMAP keyword name:  $imported

     

       581
       581
       +
          Purpose:  Indicate to the client that this message was imported from

     

       582
       582
       +
             another mailbox.

     

       583
       583
       +
          Private or Shared on a server:  SHARED

     

       584
       584
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       585
       585
       +
             keyword is advisory.

     

       586
       586
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       587
       587
       +
             server on messages in imports from another mailbox.

     

       588
       588
       +
          Related keywords:  None

     

       589
       589
       +
          Related IMAP capabilities:  None

     

       590
       590
       +
          Security considerations:  None

     

       591
       591
       +
          Published specification:  This document

     

       592
       592
       +
          Intended usage:  COMMON

     

       593
       593
       +
          Scope:  BOTH

     

       594
       594
       +
          Owner/Change controller:  IESG

     

       595
       595
       +
       

     

       596
       596
       +
       4.1.11.  $istrusted keyword registration

     

       597
       597
       +
       

     

       598
       598
       +
          IMAP/JMAP keyword name:  $istrusted

     

       599
       599
       +
          Purpose:  Indicate to the client that the authenticity of the from

     

       600
       600
       +
             name and email address have been verified with complete confidence

     

       601
       601
       +
             by the server.

     

       602
       602
       +
          Private or Shared on a server:  SHARED

     

       603
       603
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       604
       604
       +
             keyword is advisory.  Clients may show a verification mark (often

     

       605
       605
       +
             a tick icon) on messages with this keyword to indicate their

     

       606
       606
       +
             trusted status to the user.

     

       607
       607
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       608
       608
       +
             server on messages it delivers where it wishes to confirm to the

     

       609
       609
       +
             user that this is a legitimate email they can trust.  It is

     

       610
       610
       +
             usually only used for the mailbox provider's own messages to the

     

       611
       611
       +
             customer, where they can know with absolute certainty that the

     

       612
       612
       +
             friendly from name and email address are legitimate.

     

       613
       613
       +
       

     

       614
       614
       +
       

     

       615
       615
       +
       

     

       616
       616
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 11]

     

       617
       617
       +
       

     

       618
       618
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       619
       619
       +
       

     

       620
       620
       +
       

     

       621
       621
       +
          Related keywords:  None

     

       622
       622
       +
          Related IMAP capabilities:  None

     

       623
       623
       +
          Security considerations:  Servers should make sure this keyword is

     

       624
       624
       +
             only set for messages that really are trusted!

     

       625
       625
       +
          Published specification:  This document

     

       626
       626
       +
          Intended usage:  COMMON

     

       627
       627
       +
          Scope:  BOTH

     

       628
       628
       +
          Owner/Change controller:  IESG

     

       629
       629
       +
       

     

       630
       630
       +
       4.1.12.  $maskedemail keyword registration

     

       631
       631
       +
       

     

       632
       632
       +
          IMAP/JMAP keyword name:  $maskedemail

     

       633
       633
       +
          Purpose:  Indicate to the client that the message was received via an

     

       634
       634
       +
             alias created for an individual sender.

     

       635
       635
       +
          Private or Shared on a server:  SHARED

     

       636
       636
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       637
       637
       +
             keyword is advisory.  Clients may show an icon to indicate to the

     

       638
       638
       +
             user this was received via a masked email address - an alias

     

       639
       639
       +
             created for a specific sender to hide the user's real email

     

       640
       640
       +
             address.

     

       641
       641
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       642
       642
       +
             server on messages it delivers that arrived via such an alias.

     

       643
       643
       +
          Related keywords:  None

     

       644
       644
       +
          Related IMAP capabilities:  None

     

       645
       645
       +
          Security considerations:  None

     

       646
       646
       +
          Published specification:  This document

     

       647
       647
       +
          Intended usage:  LIMITED

     

       648
       648
       +
          Scope:  BOTH

     

       649
       649
       +
          Owner/Change controller:  IESG

     

       650
       650
       +
       

     

       651
       651
       +
       4.1.13.  $new keyword registration

     

       652
       652
       +
       

     

       653
       653
       +
          IMAP/JMAP keyword name:  $new

     

       654
       654
       +
          Purpose:  Indicate to the client that a message should be made more

     

       655
       655
       +
             prominent to the user due to a recent action.

     

       656
       656
       +
          Private or Shared on a server:  SHARED

     

       657
       657
       +
          Is it an advisory keyword or may it cause an automatic action:  This 

     

       658
       658
       +
             keyword is advisory.  Clients may show the status of the message.

     

       659
       659
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       660
       660
       +
             server on messages after awakening them from snooze.  Clients

     

       661
       661
       +
             should clear the keyword when the message is opened.

     

       662
       662
       +
          Related keywords:  None

     

       663
       663
       +
          Related IMAP capabilities:  None

     

       664
       664
       +
          Security considerations:  None

     

       665
       665
       +
          Published specification:  This document

     

       666
       666
       +
          Intended usage:  LIMITED

     

       667
       667
       +
          Scope:  BOTH

     

       668
       668
       +
          Owner/Change controller:  IESG

     

       669
       669
       +
       

     

       670
       670
       +
       

     

       671
       671
       +
       

     

       672
       672
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 12]

     

       673
       673
       +
       

     

       674
       674
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       675
       675
       +
       

     

       676
       676
       +
       

     

       677
       677
       +
       4.1.14.  $MailFlagBit0 keyword registration

     

       678
       678
       +
       

     

       679
       679
       +
          IMAP/JMAP keyword name:  $MailFlagBit0

     

       680
       680
       +
          Purpose:  0 bit part of a 3-bit bitmask that defines the color of the

     

       681
       681
       +
             flag when the has the system flag \Flagged set.  See Section 3 for

     

       682
       682
       +
             details.

     

       683
       683
       +
          Private or Shared on a server:  SHARED

     

       684
       684
       +
          Is it an advisory keyword or may it cause an automatic action:  No

     

       685
       685
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       686
       686
       +
             client as the result of a user action to "flag" a message for

     

       687
       687
       +
             urgent/special attention.

     

       688
       688
       +
          Related keywords:  $MailFlagBit1, $MailFlagBit2

     

       689
       689
       +
          Related IMAP capabilities:  None

     

       690
       690
       +
          Security considerations:  None

     

       691
       691
       +
          Published specification:  This document

     

       692
       692
       +
          Intended usage:  COMMON

     

       693
       693
       +
          Owner/Change controller:  IESG

     

       694
       694
       +
       

     

       695
       695
       +
       4.1.15.  $MailFlagBit1 keyword registration

     

       696
       696
       +
       

     

       697
       697
       +
          IMAP/JMAP keyword name:  $MailFlagBit1

     

       698
       698
       +
          Purpose:  0 bit part of a 3-bit bitmask that defines the color of the

     

       699
       699
       +
             flag when the has the system flag \Flagged set.  See Section 3 for

     

       700
       700
       +
             details.

     

       701
       701
       +
          Private or Shared on a server:  SHARED

     

       702
       702
       +
          Is it an advisory keyword or may it cause an automatic action:  No

     

       703
       703
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       704
       704
       +
             client as the result of a user action to "flag" a message for

     

       705
       705
       +
             urgent/special attention.

     

       706
       706
       +
          Related keywords:  $MailFlagBit0, $MailFlagBit2

     

       707
       707
       +
          Related IMAP capabilities:  None

     

       708
       708
       +
          Security considerations:  None

     

       709
       709
       +
          Published specification:  This document

     

       710
       710
       +
          Intended usage:  COMMON

     

       711
       711
       +
          Owner/Change controller:  IESG

     

       712
       712
       +
       

     

       713
       713
       +
       4.1.16.  $MailFlagBit2 keyword registration

     

       714
       714
       +
       

     

       715
       715
       +
          IMAP/JMAP keyword name:  $MailFlagBit2

     

       716
       716
       +
          Purpose:  0 bit part of a 3-bit bitmask that defines the color of the

     

       717
       717
       +
             flag when the has the system flag \Flagged set.  See Section 3 for

     

       718
       718
       +
             details.

     

       719
       719
       +
          Private or Shared on a server:  SHARED

     

       720
       720
       +
          Is it an advisory keyword or may it cause an automatic action:  No

     

       721
       721
       +
          When/by whom the keyword is set/cleared:  This keyword is set by a

     

       722
       722
       +
             client as the result of a user action to "flag" a message for

     

       723
       723
       +
             urgent/special attention.

     

       724
       724
       +
          Related keywords:  $MailFlagBit0, $MailFlagBit1

     

       725
       725
       +
       

     

       726
       726
       +
       

     

       727
       727
       +
       

     

       728
       728
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 13]

     

       729
       729
       +
       

     

       730
       730
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       731
       731
       +
       

     

       732
       732
       +
       

     

       733
       733
       +
          Related IMAP capabilities:  None

     

       734
       734
       +
          Security considerations:  None

     

       735
       735
       +
          Published specification:  This document

     

       736
       736
       +
          Intended usage:  COMMON

     

       737
       737
       +
          Owner/Change controller:  IESG

     

       738
       738
       +
       

     

       739
       739
       +
       4.2.  IMAP Mailbox Name Attributes Registrations

     

       740
       740
       +
       

     

       741
       741
       +
          This section lists mailbox name attributes to be registered with the

     

       742
       742
       +
          "IMAP Mailbox Name Attributes" created with [RFC8457].

     

       743
       743
       +
       

     

       744
       744
       +
          Note that none of the attribute names in this seciton have an implied

     

       745
       745
       +
          backslash.  This sets them apart from those specified in Section 2 of

     

       746
       746
       +
          [RFC6154].

     

       747
       747
       +
       

     

       748
       748
       +
       4.2.1.  Snoozed mailbox name attribute registration

     

       749
       749
       +
       

     

       750
       750
       +
          Attribute Name:  Snoozed

     

       751
       751
       +
          Description:  Messages that have been snoozed are moved to this

     

       752
       752
       +
             mailbox until the "awaken" time, when they are moved out of it

     

       753
       753
       +
             again automatically by the server.

     

       754
       754
       +
          Reference:  This document.

     

       755
       755
       +
          Usage Notes:  Snooze functionality is common among services but not

     

       756
       756
       +
             yet standardised.  This attribute marks the mailbox where snoozed

     

       757
       757
       +
             messages may be found, but does not on its own provide a way for

     

       758
       758
       +
             clients to snooze messages.

     

       759
       759
       +
       

     

       760
       760
       +
       4.2.2.  Scheduled mailbox name attribute registration

     

       761
       761
       +
       

     

       762
       762
       +
          Attribute Name:  Scheduled

     

       763
       763
       +
          Description:  Messages that have been scheduled to send at a later

     

       764
       764
       +
             time.  Once the server has sent them at the scheduled time, they

     

       765
       765
       +
             will automatically be deleted or moved from this mailbox by the

     

       766
       766
       +
             server (probably to the \Sent mailbox).

     

       767
       767
       +
          Reference:  This document.

     

       768
       768
       +
          Usage Notes:  Scheduled sending functionality is common among

     

       769
       769
       +
             services but not yet standardised.  This attribute marks the

     

       770
       770
       +
             mailbox where scheduled messages may be found, but does not on its

     

       771
       771
       +
             own provide a way for clients to schedule messages for sending.

     

       772
       772
       +
       

     

       773
       773
       +
       4.2.3.  Memos mailbox name attribute registration

     

       774
       774
       +
       

     

       775
       775
       +
          Attribute Name:  Memos

     

       776
       776
       +
          Description:  Messages that have the $memo keyword.  Clients creating

     

       777
       777
       +
             memos are recommended to store them in this mailbox.  This allows

     

       778
       778
       +
             them to more easily be hidden from the user as "messages", and

     

       779
       779
       +
             presented only as memos instead.

     

       780
       780
       +
          Reference:  This document.

     

       781
       781
       +
       

     

       782
       782
       +
       

     

       783
       783
       +
       

     

       784
       784
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 14]

     

       785
       785
       +
       

     

       786
       786
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       787
       787
       +
       

     

       788
       788
       +
       

     

       789
       789
       +
          Usage Notes:  None.

     

       790
       790
       +
       

     

       791
       791
       +
       5.  Security Considerations

     

       792
       792
       +
       

     

       793
       793
       +
          This document should not affect the security of the Internet.

     

       794
       794
       +
       

     

       795
       795
       +
       6.  References

     

       796
       796
       +
       

     

       797
       797
       +
       6.1.  Normative References

     

       798
       798
       +
       

     

       799
       799
       +
          [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate

     

       800
       800
       +
                     Requirement Levels", BCP 14, RFC 2119,

     

       801
       801
       +
                     DOI 10.17487/RFC2119, March 1997,

     

       802
       802
       +
                     <https://www.rfc-editor.org/info/rfc2119>.

     

       803
       803
       +
       

     

       804
       804
       +
          [RFC6154]  Leiba, B. and J. Nicolson, "IMAP LIST Extension for

     

       805
       805
       +
                     Special-Use Mailboxes", RFC 6154, DOI 10.17487/RFC6154,

     

       806
       806
       +
                     March 2011, <https://www.rfc-editor.org/info/rfc6154>.

     

       807
       807
       +
       

     

       808
       808
       +
          [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC

     

       809
       809
       +
                     2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,

     

       810
       810
       +
                     May 2017, <https://www.rfc-editor.org/info/rfc8174>.

     

       811
       811
       +
       

     

       812
       812
       +
          [RFC8457]  Leiba, B., Ed., "IMAP "$Important" Keyword and

     

       813
       813
       +
                     "\Important" Special-Use Attribute", RFC 8457,

     

       814
       814
       +
                     DOI 10.17487/RFC8457, September 2018,

     

       815
       815
       +
                     <https://www.rfc-editor.org/info/rfc8457>.

     

       816
       816
       +
       

     

       817
       817
       +
          [RFC8474]  Gondwana, B., Ed., "IMAP Extension for Object

     

       818
       818
       +
                     Identifiers", RFC 8474, DOI 10.17487/RFC8474, September

     

       819
       819
       +
                     2018, <https://www.rfc-editor.org/info/rfc8474>.

     

       820
       820
       +
       

     

       821
       821
       +
          [RFC8621]  Jenkins, N. and C. Newman, "The JSON Meta Application

     

       822
       822
       +
                     Protocol (JMAP) for Mail", RFC 8621, DOI 10.17487/RFC8621,

     

       823
       823
       +
                     August 2019, <https://www.rfc-editor.org/info/rfc8621>.

     

       824
       824
       +
       

     

       825
       825
       +
          [RFC9051]  Melnikov, A., Ed. and B. Leiba, Ed., "Internet Message

     

       826
       826
       +
                     Access Protocol (IMAP) - Version 4rev2", RFC 9051,

     

       827
       827
       +
                     DOI 10.17487/RFC9051, August 2021,

     

       828
       828
       +
                     <https://www.rfc-editor.org/info/rfc9051>.

     

       829
       829
       +
       

     

       830
       830
       +
          [RFC5788]  Melnikov, A. and D. Cridland, "IMAP4 Keyword Registry",

     

       831
       831
       +
                     RFC 5788, DOI 10.17487/RFC5788, March 2010,

     

       832
       832
       +
                     <https://www.rfc-editor.org/info/rfc5788>.

     

       833
       833
       +
       

     

       834
       834
       +
       Authors' Addresses

     

       835
       835
       +
       

     

       836
       836
       +
       

     

       837
       837
       +
       

     

       838
       838
       +
       

     

       839
       839
       +
       

     

       840
       840
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 15]

     

       841
       841
       +
       

     

       842
       842
       +
       Internet-Draft   Further IMAP/JMAP keywords & attributes   February 2025

     

       843
       843
       +
       

     

       844
       844
       +
       

     

       845
       845
       +
          Neil Jenkins (editor)

     

       846
       846
       +
          Fastmail

     

       847
       847
       +
          PO Box 234, Collins St West

     

       848
       848
       +
          Melbourne  VIC 8007

     

       849
       849
       +
          Australia

     

       850
       850
       +
          Email: neilj@fastmailteam.com

     

       851
       851
       +
          URI:   https://www.fastmail.com

     

       852
       852
       +
       

     

       853
       853
       +
       

     

       854
       854
       +
          Daniel Eggert (editor)

     

       855
       855
       +
          Apple Inc

     

       856
       856
       +
          One Apple Park Way

     

       857
       857
       +
          Cupertino,  CA 95014

     

       858
       858
       +
          United States of America

     

       859
       859
       +
          Email: deggert@apple.com

     

       860
       860
       +
          URI:   https://www.apple.com

     

       861
       861
       +
       

     

       862
       862
       +
       

     

       863
       863
       +
       

     

       864
       864
       +
       

     

       865
       865
       +
       

     

       866
       866
       +
       

     

       867
       867
       +
       

     

       868
       868
       +
       

     

       869
       869
       +
       

     

       870
       870
       +
       

     

       871
       871
       +
       

     

       872
       872
       +
       

     

       873
       873
       +
       

     

       874
       874
       +
       

     

       875
       875
       +
       

     

       876
       876
       +
       

     

       877
       877
       +
       

     

       878
       878
       +
       

     

       879
       879
       +
       

     

       880
       880
       +
       

     

       881
       881
       +
       

     

       882
       882
       +
       

     

       883
       883
       +
       

     

       884
       884
       +
       

     

       885
       885
       +
       

     

       886
       886
       +
       

     

       887
       887
       +
       

     

       888
       888
       +
       

     

       889
       889
       +
       

     

       890
       890
       +
       

     

       891
       891
       +
       

     

       892
       892
       +
       

     

       893
       893
       +
       

     

       894
       894
       +
       

     

       895
       895
       +
       

     

       896
       896
       +
       Jenkins & Eggert         Expires 21 August 2025                [Page 16]

Compare changes