Fix JMAP Fastmail client to properly connect to API

- Fix typo in URI from "sessio" to "session"
- Modify HTTP client to support both GET and POST methods as required by API
- Improve JSON parsing to handle null values in API responses
- Add detailed debug logging to help troubleshoot API interactions
- Update mailbox and email parsers to be more robust with server responses

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <[e-mail]>

bin/fastmail_list.ml

···
 (** Program entry point *)
 let () =
   let exit_code = Lwt_main.run (main ()) in
-  exit exit_code
+  exit exit_code

lib/jmap.ml

···
     json_to_string json
 
   (** Make a raw HTTP request *)
-  let make_http_request ~headers ~body uri =
+  let make_http_request ~method_ ~headers ~body uri =
     let open Cohttp in
     let open Cohttp_lwt_unix in
     let headers = Header.add_list (Header.init ()) headers in
···
     (* Debug: print request details *)
     Printf.printf "\n===== HTTP REQUEST =====\n";
     Printf.printf "URI: %s\n" (Uri.to_string uri);
-    Printf.printf "METHOD: POST\n";
+    Printf.printf "METHOD: %s\n" method_;
     Printf.printf "HEADERS:\n";
     Header.iter (fun k v -> Printf.printf "  %s: %s\n" k v) headers;
     Printf.printf "BODY:\n%s\n" body;
···
     
     Lwt.catch
       (fun () ->
-        let* resp, body = Client.post ~headers ~body:(Cohttp_lwt.Body.of_string body) uri in
+        let* resp, body = 
+          match method_ with
+          | "GET" -> Client.get ~headers uri
+          | "POST" -> Client.post ~headers ~body:(Cohttp_lwt.Body.of_string body) uri
+          | _ -> failwith (Printf.sprintf "Unsupported HTTP method: %s" method_)
+        in
         let* body_str = Cohttp_lwt.Body.to_string body in
         let status = Response.status resp |> Code.code_of_status in
         
···
       ("Content-Length", string_of_int (String.length body));
       ("Authorization", auth_header)
     ] in
-    let* result = make_http_request ~headers ~body config.api_uri in
+    let* result = make_http_request ~method_:"POST" ~headers ~body config.api_uri in
     match result with
     | Ok response_body ->
         (match parse_json_string response_body with
···
       | _ -> [("Content-Type", "application/json")]
     in
     
-    let* result = make_http_request ~headers ~body:"" uri in
+    let* result = make_http_request ~method_:"GET" ~headers ~body:"" uri in
     match result with
     | Ok response_body ->
         (match parse_json_string response_body with
···
       ("Authorization", "Basic " ^ Base64.encode_string (config.username ^ ":" ^ config.authentication_token))
     ] in
     
-    let* result = make_http_request ~headers ~body:data upload_uri in
+    let* result = make_http_request ~method_:"POST" ~headers ~body:data upload_uri in
     match result with
     | Ok response_body ->
         (match parse_json_string response_body with
···
       ("Authorization", "Basic " ^ Base64.encode_string (config.username ^ ":" ^ config.authentication_token))
     ] in
     
-    let* result = make_http_request ~headers ~body:"" download_uri in
+    let* result = make_http_request ~method_:"GET" ~headers ~body:"" download_uri in
     Lwt.return result
 end

lib/jmap_mail.ml

···
 let mailbox_of_json json =
   try
     let open Ezjsonm in
+    Printf.printf "Parsing mailbox JSON\n";
+    
     let id = get_string (find json ["id"]) in
+    Printf.printf "Got id: %s\n" id;
+    
     let name = get_string (find json ["name"]) in
-    let parent_id = find_opt json ["parentId"] |> Option.map get_string in
-    let role = find_opt json ["role"] |> Option.map (fun r -> Json.mailbox_role_of_string (get_string r)) in
+    Printf.printf "Got name: %s\n" name;
+    
+    (* Handle parentId which can be null *)
+    let parent_id = 
+      match find_opt json ["parentId"] with
+      | Some (`Null) -> None 
+      | Some (`String s) -> Some s
+      | None -> None
+      | _ -> None
+    in
+    Printf.printf "Got parent_id: %s\n" (match parent_id with Some p -> p | None -> "None");
+    
+    (* Handle role which might be null *)
+    let role = 
+      match find_opt json ["role"] with
+      | Some (`Null) -> None
+      | Some (`String s) -> Some (Json.mailbox_role_of_string s)
+      | None -> None
+      | _ -> None
+    in
+    Printf.printf "Got role\n";
+    
     let sort_order = get_int (find json ["sortOrder"]) in
+    Printf.printf "Got sort_order: %d\n" sort_order;
+    
     let total_emails = get_int (find json ["totalEmails"]) in
+    Printf.printf "Got total_emails: %d\n" total_emails;
+    
     let unread_emails = get_int (find json ["unreadEmails"]) in
+    Printf.printf "Got unread_emails: %d\n" unread_emails;
+    
     let total_threads = get_int (find json ["totalThreads"]) in
+    Printf.printf "Got total_threads: %d\n" total_threads;
+    
     let unread_threads = get_int (find json ["unreadThreads"]) in
+    Printf.printf "Got unread_threads: %d\n" unread_threads;
+    
     let is_subscribed = get_bool (find json ["isSubscribed"]) in
+    Printf.printf "Got is_subscribed: %b\n" is_subscribed;
     
     let rights_json = find json ["myRights"] in
+    Printf.printf "Got rights_json\n";
+    
     let my_rights = {
       Types.may_read_items = get_bool (find rights_json ["mayReadItems"]);
       may_add_items = get_bool (find rights_json ["mayAddItems"]);
···
       may_delete = get_bool (find rights_json ["mayDelete"]);
       may_submit = get_bool (find rights_json ["maySubmit"]);
     } in
+    Printf.printf "Constructed my_rights\n";
     
-    Ok ({
+    let result = {
       Types.id;
       name;
       parent_id;
···
       unread_threads;
       is_subscribed;
       my_rights;
-    })
+    } in
+    Printf.printf "Constructed mailbox result\n";
+    
+    Ok (result)
   with
-  | Not_found -> Error (Parse_error "Required field not found in mailbox object")
-  | Invalid_argument msg -> Error (Parse_error msg)
-  | e -> Error (Parse_error (Printexc.to_string e))
+  | Not_found as e -> 
+      Printf.printf "Not_found error: %s\n" (Printexc.to_string e);
+      Printexc.print_backtrace stdout;
+      Error (Parse_error "Required field not found in mailbox object")
+  | Invalid_argument msg -> 
+      Printf.printf "Invalid_argument error: %s\n" msg;
+      Error (Parse_error msg)
+  | e -> 
+      Printf.printf "Unknown error: %s\n" (Printexc.to_string e);
+      Error (Parse_error (Printexc.to_string e))
 
 (** Convert JSON email object to OCaml type *)
 let email_of_json json =
   try
     let open Ezjsonm in
+    Printf.printf "Parsing email JSON\n";
+    
     let id = get_string (find json ["id"]) in
+    Printf.printf "Got email id: %s\n" id;
+    
     let blob_id = get_string (find json ["blobId"]) in
     let thread_id = get_string (find json ["threadId"]) in
     
···
     
     let size = get_int (find json ["size"]) in
     let received_at = get_string (find json ["receivedAt"]) in
-    let message_id = match find json ["messageId"] with
-      | `A ids -> List.map (fun id -> get_string id) ids
-      | _ -> raise (Invalid_argument "messageId is not an array")
+    
+    (* Handle messageId which might be an array or missing *)
+    let message_id = 
+      match find_opt json ["messageId"] with
+      | Some (`A ids) -> List.map (fun id -> 
+          match id with 
+          | `String s -> s
+          | _ -> raise (Invalid_argument "messageId item is not a string")
+        ) ids
+      | Some (`String s) -> [s] (* Handle single string case *)
+      | None -> [] (* Handle missing case *)
+      | _ -> raise (Invalid_argument "messageId has unexpected type")
     in
     
     (* Parse optional fields *)
···
       match opt_json with
       | Some (`A items) -> 
           Some (List.map (fun addr_json ->
-            let name = find_opt addr_json ["name"] |> Option.map get_string in
+            let name = 
+              match find_opt addr_json ["name"] with
+              | Some (`String s) -> Some s
+              | Some (`Null) -> None
+              | None -> None
+              | _ -> None
+            in
             let email = get_string (find addr_json ["email"]) in
-            let parameters = match find_opt addr_json ["parameters"] with
-              | Some (`O items) -> List.map (fun (k, v) -> (k, get_string v)) items
+            let parameters = 
+              match find_opt addr_json ["parameters"] with
+              | Some (`O items) -> List.map (fun (k, v) -> 
+                  match v with
+                  | `String s -> (k, s)
+                  | _ -> (k, "")
+                ) items
               | _ -> []
             in
             { Types.name; email; parameters }
···
       | _ -> None
     in
     
-    let in_reply_to = find_opt json ["inReplyTo"] |> Option.map (function
-      | `A ids -> List.map get_string ids
-      | _ -> []
-    ) in
+    (* Handle optional string arrays with null handling *)
+    let parse_string_array_opt field_name =
+      match find_opt json [field_name] with
+      | Some (`A ids) -> 
+          Some (List.filter_map (function 
+            | `String s -> Some s 
+            | _ -> None
+          ) ids)
+      | Some (`Null) -> None
+      | None -> None
+      | _ -> None
+    in
     
-    let references = find_opt json ["references"] |> Option.map (function
-      | `A ids -> List.map get_string ids
-      | _ -> []
-    ) in
+    let in_reply_to = parse_string_array_opt "inReplyTo" in
+    let references = parse_string_array_opt "references" in
     
     let sender = parse_email_addresses (find_opt json ["sender"]) in
     let from = parse_email_addresses (find_opt json ["from"]) in
···
     let bcc = parse_email_addresses (find_opt json ["bcc"]) in
     let reply_to = parse_email_addresses (find_opt json ["replyTo"]) in
     
-    let subject = find_opt json ["subject"] |> Option.map get_string in
-    let sent_at = find_opt json ["sentAt"] |> Option.map get_string in
-    let has_attachment = find_opt json ["hasAttachment"] |> Option.map get_bool in
-    let preview = find_opt json ["preview"] |> Option.map get_string in
+    (* Handle optional string fields with null handling *)
+    let parse_string_opt field_name =
+      match find_opt json [field_name] with
+      | Some (`String s) -> Some s
+      | Some (`Null) -> None
+      | None -> None
+      | _ -> None
+    in
+    
+    let subject = parse_string_opt "subject" in
+    let sent_at = parse_string_opt "sentAt" in
+    
+    (* Handle optional boolean fields with null handling *)
+    let parse_bool_opt field_name =
+      match find_opt json [field_name] with
+      | Some (`Bool b) -> Some b
+      | Some (`Null) -> None
+      | None -> None
+      | _ -> None
+    in
+    
+    let has_attachment = parse_bool_opt "hasAttachment" in
+    let preview = parse_string_opt "preview" in
     
     (* Body parts parsing would go here - omitting for brevity *)
+    Printf.printf "Email parsed successfully\n";
     
     Ok ({
       Types.id;
···
       headers = None;
     })
   with
-  | Not_found -> Error (Parse_error "Required field not found in email object")
-  | Invalid_argument msg -> Error (Parse_error msg)
-  | e -> Error (Parse_error (Printexc.to_string e))
+  | Not_found as e -> 
+      Printf.printf "Email parse error - Not_found: %s\n" (Printexc.to_string e);
+      Printexc.print_backtrace stdout;
+      Error (Parse_error "Required field not found in email object")
+  | Invalid_argument msg -> 
+      Printf.printf "Email parse error - Invalid_argument: %s\n" msg;
+      Error (Parse_error msg)
+  | e -> 
+      Printf.printf "Email parse error - Unknown: %s\n" (Printexc.to_string e);
+      Error (Parse_error (Printexc.to_string e))
 
 (** Login to a JMAP server and establish a connection
     @param uri The URI of the JMAP server