diff --git a/broker/CMakeLists.txt b/broker/CMakeLists.txt
index 56cdad7..bcecaf4 100644
--- a/broker/CMakeLists.txt
+++ b/broker/CMakeLists.txt
@@ -1,47 +1,45 @@
 # SPDX-FileCopyrightText: 2023 g10 code GmbH
 # SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 # SPDX-License-Identifier: BSD-2-Clause
 
 add_executable(gpgol-broker)
 target_sources(gpgol-broker PRIVATE
     # Controllers
     controllers/abstractcontroller.cpp
     controllers/abstractcontroller.h
     controllers/registrationcontroller.cpp
     controllers/registrationcontroller.h
     controllers/staticcontroller.h
     controllers/staticcontroller.cpp
     controllers/emailcontroller.cpp
     controllers/emailcontroller.h
 
     # State
     model/serverstate.cpp
     model/serverstate.h
 
-    # websocket sever
-    websocketserver.cpp
-    websocketserver.h
-    websocketrequest.cpp
-    websocketrequest.h
+    # web sever
+    webserver.cpp
+    webserver.h
 
     main.cpp
 )
 
 qt_add_resources(gpgol-broker
     PREFIX
         "/"
     FILES
         assets/certificate.crt
         assets/private.key
 
         assets/document-decrypt-16.png
         assets/document-decrypt-32.png
         assets/document-decrypt-64.png
         assets/document-decrypt-80.png
 
         assets/script.js
 
         web/index.html
 )
 
 target_link_libraries(gpgol-broker PRIVATE Qt6::HttpServer Qt6::Core)
diff --git a/broker/assets/script.js b/broker/assets/script.js
index a1ece3c..a4cddf4 100644
--- a/broker/assets/script.js
+++ b/broker/assets/script.js
@@ -1,278 +1,278 @@
 // SPDX-FileCopyrightText: 2023 g10 code GmbH
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 function downloadViaRest(callback) {
   const context = {
     isRest: true
   };
 
   Office.context.mailbox.getCallbackTokenAsync(context, (tokenResults) => {
     if (tokenResults.status === Office.AsyncResultStatus.Failed) {
       console.error('Failed to get rest api auth token');
       return;
     }
 
     const request = 
     '<?xml version="1.0" encoding="utf-8"?>' +
     '<soap:Envelope xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"' +
     '               xmlns:xsd="https://www.w3.org/2001/XMLSchema"' +
     '               xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"' +
     '               xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types">' +
     '  <soap:Header>' +
     '    <RequestServerVersion Version="Exchange2013" xmlns="http://schemas.microsoft.com/exchange/services/2006/types" soap:mustUnderstand="0" />' +
     '  </soap:Header>' +
     '  <soap:Body>' +
     '    <GetItem xmlns="http://schemas.microsoft.com/exchange/services/2006/messages">' +
     '      <ItemShape>' +
     '        <t:BaseShape>IdOnly</t:BaseShape>' +
     '        <t:IncludeMimeContent>true</t:IncludeMimeContent>' +
     '      </ItemShape>' +
     '      <ItemIds><t:ItemId Id="' + Office.context.mailbox.item.itemId + '"/></ItemIds>' +
     '    </GetItem>' +
     '  </soap:Body>' +
     '</soap:Envelope>';
 
     Office.context.mailbox.makeEwsRequestAsync(request, (asyncResult) => {
       const parser = new DOMParser();
       xmlDoc = parser.parseFromString(asyncResult.value, "text/xml");
 
       const mimeContent = xmlDoc.getElementsByTagName('t:MimeContent')[0].innerHTML;
       callback(atob(mimeContent));
     });
   });
 }
 
 async function view(content) {
   const response = await fetch('https://localhost:5656/view', {
     method: 'POST',
     body: content,
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 async function info(content) {
   const response = await fetch('https://localhost:5656/info', {
     method: 'POST',
     body: content,
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 async function newEmail(content) {
   const response = await fetch('https://localhost:5656/new', {
     method: 'POST',
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 async function reply(content) {
   const response = await fetch('https://localhost:5656/reply', {
     method: 'POST',
     body: content,
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 async function forward(content) {
   const response = await fetch('https://localhost:5656/forward', {
     method: 'POST',
     body: content,
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 async function openDraft(id) {
   const response = await fetch(`https://localhost:5656/draft/${id}`, {
     method: 'POST',
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 async function deleteDraft(id) {
   const response = await fetch(`https://localhost:5656/draft/${id}`, {
     method: 'DELETE',
     headers: {
       'X-EMAIL': Office.context.mailbox.userProfile.emailAddress,
       'X-NAME': Office.context.mailbox.userProfile.displayName,
     },
   });
   const json = await response.json();
   return json;
 }
 
 function showError(errorMessage) {
     const errorElement = document.getElementById('error');
     errorElement.innerHTML = errorMessage;
     errorElement.classList.remove('d-none');
 }
 
 function hideError() {
     const errorElement = document.getElementById('error');
     errorElement.classList.add('d-none');
 }
 
 Office.onReady().
   then(()=> {
     downloadViaRest(async (content) => {
       const status = await info(content)
       const statusText = document.getElementById('status-text');
       if (status.encrypted || status.signed) {
         const decryptButton = document.getElementById('decrypt-button');
         decryptButton.classList.remove('d-none');
         if (status.encrypted) {
           decryptButton.innerText = "Decrypt";
           statusText.innerText = status.signed ? "This mail is encrypted and signed." : "This mail is encrypted.";
         } else if (status.signed) {
           decryptButton.innerText = "Show signature";
           statusText.innerText = "This mail is signed";
         }
         decryptButton.addEventListener('click', (event) => {
           view(content);
         });
       }
 
       document.getElementById('reply-button').addEventListener('click', (event) => {
         reply(content);
       });
 
       document.getElementById('forward-button').addEventListener('click', (event) => {
         forward(content);
       });
 
       document.getElementById('new-button').addEventListener('click', (event) => {
         newEmail();
       });
 
       if (status.drafts.length === 0) {
         document.getElementById('no-draft').classList.remove('d-none');
       } else {
         const draftsContainer = document.getElementById('drafts');
         status.drafts.forEach(draft => {
           const draftElementContainer = document.createElement('li');
           const draftElement = document.createElement('button');
           draftElement.classList.add('btn', 'w-100', 'd-flex', 'flex-row', 'align-items-center');
           draftElement.addEventListener('click', (event) => {
             openDraft(draft.id);
           });
           const date = new Date(draft.last_modification * 1000);
           let todaysDate = new Date();
           let lastModification = '';
           if ((new Date(date)).setHours(0, 0, 0, 0) == todaysDate.setHours(0, 0, 0, 0)) {
             lastModification = date.toLocaleTimeString([], {
               hour: 'numeric',
               minute: 'numeric',
             });
           } else {
             lastModification = date.toLocaleDateString();
           }
 
           const content = document.createTextNode('Last Modified: ' + lastModification);
           draftElement.appendChild(content);
 
           const deleteDraftButton = document.createElement('button');
           deleteDraftButton.classList.add('btn', 'btn-danger', 'ms-auto', 'py-1');
           deleteDraftButton.addEventListener('click', (event) => {
             deleteDraft(draft.id);
             draftElement.remove();
           });
           const deleteDraftButtonContent = document.createTextNode('X');
           deleteDraftButton.appendChild(deleteDraftButtonContent);
           draftElement.appendChild(deleteDraftButton);
 
           draftElementContainer.appendChild(draftElement);
           draftsContainer.appendChild(draftElementContainer);
         });
       }
 
       function webSocketConnect() {
         // Create WebSocket connection.
-        const socket = new WebSocket("wss://localhost:5657");
+        const socket = new WebSocket("wss://localhost:5656");
 
         // Connection opened
         socket.addEventListener("open", (event) => {
           hideError();
           socket.send(JSON.stringify({
             command: "register",
             arguments: {
               emails: [Office.context.mailbox.userProfile.emailAddress],
               type: 'webclient',
             },
           }));
         });
 
         socket.addEventListener("close", (event) => {
           showError('Native client was disconnected');
           setTimeout(function() {
             webSocketConnect();
           }, 1000);
         });
 
         socket.addEventListener("error", (event) => {
           showError('Native client received an error');
           setTimeout(function() {
             webSocketConnect();
           }, 1000);
         });
 
         // Listen for messages
         socket.addEventListener("message", ({ data }) => {
           const message = JSON.parse(data);
           console.log("Message from server ", message);
           switch (message.type) {
           case 'ews':
             Office.context.mailbox.makeEwsRequestAsync(message.payload, (asyncResult) => {
               console.log('Email sent')
               // let the client known that the email was sent
               socket.send(JSON.stringify({
                 command: 'email-sent',
                 arguments: {
                   id: message.id,
                   email: Office.context.mailbox.userProfile.emailAddress,
                 }
               }));
             });
             break;
           case 'disconnection':
-            showError('Native client was disconnected');
+            showError('Native client was disconnected (disconnection)');
             break;
           case 'connection':
             hideError();
             break;
           }
         });
       }
 
       webSocketConnect();
     });
   });
diff --git a/broker/controllers/emailcontroller.cpp b/broker/controllers/emailcontroller.cpp
index b277bbb..6e7db8b 100644
--- a/broker/controllers/emailcontroller.cpp
+++ b/broker/controllers/emailcontroller.cpp
@@ -1,164 +1,162 @@
 // SPDX-FileCopyrightText: 2023 g10 code GmbH
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "emailcontroller.h"
 
 #include <QJsonObject>
 #include <QHttpServerRequest>
 #include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QtConcurrent/QtConcurrent>
 #include <QPromise>
 #include <QEventLoop>
 #include <QUuid>
 
-#include "websocketrequest.h"
+#include "webserver.h"
 
 using namespace Qt::Literals::StringLiterals;
 
 QHttpServerResponse EmailController::abstractEmailAction(const QHttpServerRequest &request, const QString &action, QHttpServerRequest::Method method)
 {
 
     const auto server = checkAuthentification(request);
     if (!server) {
         return forbidden();
     }
 
     QNetworkRequest viewEmailRequest(QUrl(u"http://127.0.0.1:"_s + QString::number(server->port) + u'/' + action));
     viewEmailRequest.setHeader(QNetworkRequest::ContentTypeHeader, u"application/json"_s);
     auto email = AbstractController::findHeader(request.headers(), "X-EMAIL");
     auto displayName = AbstractController::findHeader(request.headers(), "X-NAME");
     auto token = QUuid::createUuid().toString(QUuid::WithoutBraces).toUtf8();
     viewEmailRequest.setRawHeader("X-EMAIL", email);
     viewEmailRequest.setRawHeader("X-TOKEN", token);
     viewEmailRequest.setRawHeader("X-NAME", displayName);
 
     auto &serverState = ServerState::instance();
     serverState.composerRequest[token] = QString::fromUtf8(email);
 
 
     auto &state = ServerState::instance();
     QNetworkReply *reply;
     if (method == QHttpServerRequest::Method::Post) {
         const auto body = request.body();
         reply = state.qnam.post(viewEmailRequest, body);
     } else {
         reply = state.qnam.deleteResource(viewEmailRequest);
     }
 
     QObject::connect(reply, &QNetworkReply::finished, reply, [reply]() {
         if (reply->error() != QNetworkReply::NoError) {
             qWarning() << reply->error() << reply->errorString();
         } else {
             qWarning() << "sent request to view message to server";
         }
     });
 
     return QHttpServerResponse(QJsonObject {
         {"status"_L1, "ok"_L1},
     });
 }
 
 QHttpServerResponse EmailController::viewEmailAction(const QHttpServerRequest &request)
 {
     if (request.method() != QHttpServerRequest::Method::Post) {
         return badRequest(u"Endpoint only supports POST request"_s);
     }
 
     return abstractEmailAction(request, u"view"_s);
 }
 
 QHttpServerResponse EmailController::newEmailAction(const QHttpServerRequest &request)
 {
     if (request.method() != QHttpServerRequest::Method::Post) {
         return badRequest(u"Endpoint only supports POST request"_s);
     }
 
     return abstractEmailAction(request, u"new"_s);
 }
 
 QHttpServerResponse EmailController::draftAction(QString, const QHttpServerRequest &request)
 {
     if (request.method() != QHttpServerRequest::Method::Post && request.method() != QHttpServerRequest::Method::Delete) {
         return badRequest(u"Endpoint only supports POST request"_s);
     }
 
     return abstractEmailAction(request, request.url().path(), request.method());
 }
 
 QHttpServerResponse EmailController::replyEmailAction(const QHttpServerRequest &request)
 {
     if (request.method() != QHttpServerRequest::Method::Post) {
         return badRequest(u"Endpoint only supports POST request"_s);
     }
 
     return abstractEmailAction(request, u"reply"_s);
 }
 
 QHttpServerResponse EmailController::forwardEmailAction(const QHttpServerRequest &request)
 {
     if (request.method() != QHttpServerRequest::Method::Post) {
         return badRequest(u"Endpoint only supports POST request"_s);
     }
 
     return abstractEmailAction(request, u"forward"_s);
 }
 
 QHttpServerResponse checkStatus(int port, const QByteArray &body)
 {
     QNetworkRequest infoEmailRequest(QUrl(u"http://127.0.0.1:"_s + QString::number(port) + u"/info"_s));
     infoEmailRequest.setHeader(QNetworkRequest::ContentTypeHeader, u"application/json"_s);
 
     auto &state = ServerState::instance();
     QEventLoop eventLoop;
     auto reply = state.qnam.post(infoEmailRequest, body);
     QObject::connect(reply, &QNetworkReply::finished, &eventLoop, &QEventLoop::quit);
     eventLoop.exec();
 
     QJsonParseError error;
     const auto resultBody = QJsonDocument::fromJson(reply->readAll(), &error);
     if (resultBody.isNull()) {
         return QHttpServerResponse(QHttpServerResponse::StatusCode::BadRequest);
     }
 
     if (!resultBody.isObject()) {
         return QHttpServerResponse(QHttpServerResponse::StatusCode::BadRequest);
     }
 
     return QHttpServerResponse{resultBody.object()};
 }
 
 QHttpServerResponse EmailController::infoEmailAction(const QHttpServerRequest &request)
 {
     if (request.method() != QHttpServerRequest::Method::Post) {
         return badRequest(u"Endpoint only supports POST request"_s);
     }
 
     const auto server = checkAuthentification(request);
     if (!server) {
         return forbidden();
     }
 
     return checkStatus(server->port, request.body());
 }
 
 QHttpServerResponse EmailController::socketWebAction(const QHttpServerRequest &request)
 {
     const auto email = QString::fromUtf8(findHeader(request.headers(), "X-EMAIL"));
     const auto token = findHeader(request.headers(), "X-TOKEN");
     const auto &serverState = ServerState::instance();
 
     qDebug() << serverState.composerRequest << email << token;
     if (serverState.composerRequest[token] != email) {
         return forbidden();
     }
 
-    WebsocketRequest websocketRequest(email);
-    websocketRequest.setPayload(request.body());
-    websocketRequest.send();
+    WebServer::self().sendMessageToWebClient(email, request.body());
 
     return QHttpServerResponse(QJsonObject{
         { "status"_L1, "OK"_L1 },
     });
 }
diff --git a/broker/main.cpp b/broker/main.cpp
index 13b220a..a1b7bcb 100644
--- a/broker/main.cpp
+++ b/broker/main.cpp
@@ -1,90 +1,30 @@
 // SPDX-FileCopyrightText: 2023 g10 code GmbH
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <QCoreApplication>
-#include <QHttpServer>
-#include <QHttpServerResponse>
 #include <QFile>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QSslCertificate>
 #include <QSslKey>
 
-#include "controllers/registrationcontroller.h"
-#include "controllers/staticcontroller.h"
-#include "controllers/emailcontroller.h"
-#include "websocketserver.h"
-#include "websocketrequest.h"
+#include "webserver.h"
 
 using namespace Qt::Literals::StringLiterals;
 
 int main(int argc, char *argv[])
 {
     QCoreApplication app(argc, argv);
-    QHttpServer server;
 
-    QNetworkAccessManager qnam;
+    auto &webServer = WebServer::self();
 
-    // Static assets controller
-    server.route(u"/"_s, &StaticController::homeAction);
-    server.route(u"/assets/"_s, &StaticController::assetsAction);
-
-    // Registration controller
-    server.route(u"/register"_s, &RegistrationController::registerAction);
-
-    // Email controller
-    server.route(u"/view"_s, &EmailController::viewEmailAction);
-    server.route(u"/info"_s, &EmailController::infoEmailAction);
-    server.route(u"/reply"_s, &EmailController::replyEmailAction);
-    server.route(u"/forward"_s, &EmailController::forwardEmailAction);
-    server.route(u"/new"_s, &EmailController::newEmailAction);
-    server.route(u"/socket-web"_s, &EmailController::socketWebAction);
-
-    server.route(u"/draft/<arg>"_s, &EmailController::draftAction);
-
-    server.afterRequest([](QHttpServerResponse &&resp) {
-        resp.setHeader("Access-Control-Allow-Origin", "*");
-        return std::move(resp);
-    });
-
-    const auto sslCertificateChain =
-            QSslCertificate::fromPath(QStringLiteral(":/assets/certificate.crt"));
-    if (sslCertificateChain.empty()) {
-        qWarning() << QCoreApplication::translate("QHttpServerExample",
-                                                  "Couldn't retrieve SSL certificate from file.");
-        return -1;
-    }
-    QFile privateKeyFile(QStringLiteral(":/assets/private.key"));
-    if (!privateKeyFile.open(QIODevice::ReadOnly)) {
-        qWarning() << QCoreApplication::translate("QHttpServerExample",
-                                                  "Couldn't open file for reading: %1")
-                      .arg(privateKeyFile.errorString());
-        return -1;
-    }
-    const QSslKey sslKey(&privateKeyFile, QSsl::Rsa);
-
-    server.sslSetup(sslCertificateChain.front(), sslKey);
-    privateKeyFile.close();
-
-    const auto sslPort = server.listen(QHostAddress::Any);
-    if (!sslPort) {
-        qWarning() << QCoreApplication::translate("QHttpServerExample",
-                                                  "Server failed to listen on a port.");
-        return -1;
-    }
-
-    const auto port = server.listen(QHostAddress::Any, 5656);
-    if (!port) {
+    if (!webServer.run()) {
         qWarning() << "Server failed to listen on a port.";
         return 1;
     }
-    qWarning() << u"Running on https://127.0.0.1:%1/ (Press CTRL+C to quit)"_s.arg(port);
-
-    WebsocketServer websocketServer(sslCertificateChain.front(), sslKey, 5657);
-    WebsocketRequestBackend::instance().setServer(&websocketServer);
 
     return app.exec();
 }
diff --git a/broker/manifest.xml b/broker/manifest.xml
index f646ada..e83b503 100644
--- a/broker/manifest.xml
+++ b/broker/manifest.xml
@@ -1,112 +1,112 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <OfficeApp xmlns="http://schemas.microsoft.com/office/appforoffice/1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:bt="http://schemas.microsoft.com/office/officeappbasictypes/1.0" xmlns:mailappor="http://schemas.microsoft.com/office/mailappversionoverrides/1.0" xsi:type="MailApp">
   <Id>95b7e9a9-1ce6-49c2-adf8-48aa704f156d</Id>
   <Version>1.0.0.0</Version>
   <ProviderName>g10code</ProviderName>
   <DefaultLocale>de-DE</DefaultLocale>
   <DisplayName DefaultValue="GnuPG"/>
   <Description DefaultValue="GunPG addin poc."/>
   <IconUrl DefaultValue="https://localhost:5656/assets/document-decrypt-64.png"/>
   <HighResolutionIconUrl DefaultValue="https://localhost:5656/assets/document-decrypt-80.png"/>
   <SupportUrl DefaultValue="https://www.gnupg.org/documentation/manuals/gnupg/"/>
   <AppDomains>
     <AppDomain>https://www.gnupg.org</AppDomain>
   </AppDomains>
   <Hosts>
     <Host Name="Mailbox"/>
   </Hosts>
   <Requirements>
     <Sets>
       <Set Name="Mailbox" MinVersion="1.1"/>
     </Sets>
   </Requirements>
   <FormSettings>
     <Form xsi:type="ItemRead">
       <DesktopSettings>
         <SourceLocation DefaultValue="https://localhost:5656/index.html"/>
         <RequestedHeight>250</RequestedHeight>
       </DesktopSettings>
     </Form>
   </FormSettings>
   <Permissions>ReadWriteMailbox</Permissions>
   <Rule xsi:type="RuleCollection" Mode="Or">
     <Rule xsi:type="ItemIs" ItemType="Message" FormType="Read"/>
     <Rule xsi:type="ItemIs" ItemType="Appointment" FormType="Read"/>
   </Rule>
   <DisableEntityHighlighting>false</DisableEntityHighlighting>
   <VersionOverrides xmlns="http://schemas.microsoft.com/office/mailappversionoverrides" xsi:type="VersionOverridesV1_0">
   <VersionOverrides xmlns="http://schemas.microsoft.com/office/mailappversionoverrides/1.1" xsi:type="VersionOverridesV1_1">
     <Requirements>
       <bt:Sets DefaultMinVersion="1.12">
         <bt:Set Name="Mailbox"/>
       </bt:Sets>
     </Requirements>
     <Hosts>
       <Host xsi:type="MailHost">
         <Runtimes>
           <!-- HTML file including reference to or inline JavaScript event handlers.
                This is used by Outlook on the web and Outlook on the new Mac UI. -->
           <Runtime resid="EventsRuntime.Url">
             <!-- JavaScript file containing event handlers. This is used by Outlook on Windows. -->
             <Override type="javascript" resid="JSRuntime.Url"/>
           </Runtime>
         </Runtimes>
         <DesktopFormFactor>
           <FunctionFile resid="Commands.Url"/>
           <ExtensionPoint xsi:type="MessageReadCommandSurface">
             <OfficeTab id="TabDefault">
               <Group id="Gnupg.TabSecure.group">
                 <Label resid="SecureStatusLabel"/>
                 <Control xsi:type="Button" id="Gnupg.BtnSecure">
                   <Label resid="SecureInfo"/>
                   <Supertip>
                     <Title resid="DecryptTitle" />
                     <Description resid="DecryptTipDescription" />
                   </Supertip>
                   <Icon>
                     <bt:Image size="16" resid="SecureIcon.16x16"/>
                     <bt:Image size="32" resid="SecureIcon.32x32"/>
                     <bt:Image size="80" resid="SecureIcon.80x80"/>
                   </Icon>
                   <Action xsi:type="ShowTaskpane">
                     <SourceLocation resid="Commands.Url" />
                   </Action>
                 </Control>
               </Group>
             </OfficeTab>
           </ExtensionPoint>
         </DesktopFormFactor>
       </Host>
     </Hosts>
     <Resources>
       <bt:Images>
         <bt:Image id="SecureIcon.16x16" DefaultValue="https://localhost:5656/assets/document-decrypt-16.png"/>
         <bt:Image id="SecureIcon.32x32" DefaultValue="https://localhost:5656/assets/document-decrypt-32.png"/>
         <bt:Image id="SecureIcon.80x80" DefaultValue="https://localhost:5656/assets/document-decrypt-80.png"/>
 
         <bt:Image id="blue-icon-16" DefaultValue="https://localhost:8443/Assets/Images/blue-16.png"/>
         <bt:Image id="blue-icon-32" DefaultValue="https://localhost:8443/Assets/Images/blue-32.png"/>
         <bt:Image id="blue-icon-80" DefaultValue="https://localhost:8443/Assets/Images/blue-80.png"/>
       </bt:Images>
       <bt:Urls>
-        <bt:Url id="Commands.Url" DefaultValue="https://localhost:5656/"/>
-        <bt:Url id="EventsRuntime.Url" DefaultValue="https://localhost:5656/"/>
+        <bt:Url id="Commands.Url" DefaultValue="https://localhost:5656/home"/>
+        <bt:Url id="EventsRuntime.Url" DefaultValue="https://localhost:5656/home"/>
         <bt:Url id="JSRuntime.Url" DefaultValue="https://localhost:5656/assets/script.js" />
       </bt:Urls>
       <bt:ShortStrings>
         <bt:String id="SecureStatusLabel" DefaultValue="Secure Info"/>
         <bt:String id="DecryptTitle" DefaultValue="Decrypt"/>
         <bt:String id="SecureInfo" DefaultValue="Secure information"/>
 
         <bt:String id="funcReadButtonLabel" DefaultValue="Get subject"/>
         <bt:String id="funcReadSuperTipTitle" DefaultValue="Gets the subject of the message or appointment"/>
       </bt:ShortStrings>
       <bt:LongStrings>
         <bt:String id="DecryptTipDescription" DefaultValue="Decrypt an email with GnuPG."/>
 
         <bt:String id="funcReadSuperTipDescription" DefaultValue="Gets the subject of the message or appointment and displays it in the info bar. This is an example of a function button."/>
       </bt:LongStrings>
     </Resources>
   </VersionOverrides>
   </VersionOverrides>
 </OfficeApp>
diff --git a/broker/websocketserver.cpp b/broker/webserver.cpp
similarity index 57%
rename from broker/websocketserver.cpp
rename to broker/webserver.cpp
index ee65b74..56b946e 100644
--- a/broker/websocketserver.cpp
+++ b/broker/webserver.cpp
@@ -1,248 +1,316 @@
 // SPDX-FileCopyrightText: 2023 g10 code GmbH
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "websocketserver.h"
-#include "QWebSocketServer"
-#include "QWebSocket"
+#include "webserver.h"
+
 #include <QDebug>
 #include <QFile>
-#include <QSslCertificate>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QJsonDocument>
+#include <QHttpServer>
+#include <QHttpServerResponse>
+#include <QSslCertificate>
 #include <QSslKey>
-#include <qjsondocument.h>
+#include <QWebSocketServer>
+#include <QWebSocket>
+
+#include "controllers/registrationcontroller.h"
+#include "controllers/staticcontroller.h"
+#include "controllers/emailcontroller.h"
 
 using namespace Qt::Literals::StringLiterals;
 
-WebsocketServer::WebsocketServer(const QSslCertificate &certificate,
-                                 const QSslKey &sslKey,
-                                 quint16 port,
-                                 QObject *parent)
-    : QObject(parent)
-    , m_pWebSocketServer(nullptr)
+WebServer WebServer::s_instance = WebServer();
+
+WebServer &WebServer::self()
 {
-    m_pWebSocketServer = new QWebSocketServer(QStringLiteral("SSL Echo Server"),
-                                              QWebSocketServer::SecureMode,
-                                              this);
-    QSslConfiguration sslConfiguration;
-    sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
-    sslConfiguration.setLocalCertificate(certificate);
-    sslConfiguration.setPrivateKey(sslKey);
-    m_pWebSocketServer->setSslConfiguration(sslConfiguration);
-
-    if (m_pWebSocketServer->listen(QHostAddress::Any, port))
-    {
-        qDebug() << "SSL Echo Server listening on port" << port;
-        connect(m_pWebSocketServer, &QWebSocketServer::newConnection,
-                this, &WebsocketServer::onNewConnection);
-        connect(m_pWebSocketServer, &QWebSocketServer::sslErrors,
-                this, &WebsocketServer::onSslErrors);
-    }
+    return s_instance;
 }
 
-WebsocketServer::~WebsocketServer()
+WebServer::WebServer()
+    : QObject(nullptr)
+    , m_httpServer(new QHttpServer(this))
+    , m_webSocketServer(new QWebSocketServer(u"GPGOL"_s, QWebSocketServer::SslMode::SecureMode, this))
 {
-    m_pWebSocketServer->close();
-    qDeleteAll(m_clients.begin(), m_clients.end());
 }
 
-void WebsocketServer::onNewConnection()
+WebServer::~WebServer() = default;
+
+bool WebServer::run()
 {
-    QWebSocket *pSocket = m_pWebSocketServer->nextPendingConnection();
+    QFile privateKeyFile(QStringLiteral(":/assets/private.key"));
+    if (!privateKeyFile.open(QIODevice::ReadOnly)) {
+        qWarning() << u"Couldn't open file for reading: %1"_s.arg(privateKeyFile.errorString());
+        return false;
+    }
+    const QSslKey sslKey(&privateKeyFile, QSsl::Rsa);
+    privateKeyFile.close();
+
+    const auto sslCertificateChain =
+            QSslCertificate::fromPath(QStringLiteral(":/assets/certificate.crt"));
+    if (sslCertificateChain.isEmpty()) {
+        qWarning() << u"Couldn't retrieve SSL certificate from file."_s;
+        return false;
+    }
+
+    m_httpServer->route(u"/"_s, [](const QHttpServerRequest &request) ->auto {
+        // Upgrade http connection to websocket
+        auto findHeader = [](QList<QPair<QByteArray, QByteArray>> headers, const QByteArray &key) -> QByteArray
+        {
+            const auto it = std::find_if(std::cbegin(headers), std::cend(headers), [&key](auto header) {
+                return header.first == key;
+            });
+
+            if (it == std::cend(headers)) {
+                return {};
+            }
+
+            return it->second;
+        };
+
+        QByteArray webSocketKey = findHeader(request.headers(), "Sec-WebSocket-Key") + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+        QCryptographicHash hash(QCryptographicHash::Algorithm::Sha1);
+        hash.addData(webSocketKey);
+
+        auto response = QHttpServerResponse("", QHttpServerResponder::StatusCode::SwitchingProtocols);
+        response.addHeader("Upgrade", "websocket");
+        response.addHeader("Connection", "Upgrade");
+        response.addHeader("Sec-WebSocket-Accept", hash.result().toBase64());
+        return response;
+    });
+
+    // Static assets controller
+    m_httpServer->route(u"/home"_s, &StaticController::homeAction);
+    m_httpServer->route(u"/assets/"_s, &StaticController::assetsAction);
+
+    // Registration controller
+    m_httpServer->route(u"/register"_s, &RegistrationController::registerAction);
+
+    // Email controller
+    m_httpServer->route(u"/view"_s, &EmailController::viewEmailAction);
+    m_httpServer->route(u"/info"_s, &EmailController::infoEmailAction);
+    m_httpServer->route(u"/reply"_s, &EmailController::replyEmailAction);
+    m_httpServer->route(u"/forward"_s, &EmailController::forwardEmailAction);
+    m_httpServer->route(u"/new"_s, &EmailController::newEmailAction);
+    m_httpServer->route(u"/socket-web"_s, &EmailController::socketWebAction);
+
+    m_httpServer->route(u"/draft/<arg>"_s, &EmailController::draftAction);
+
+    m_httpServer->afterRequest([](QHttpServerResponse &&resp) {
+        resp.setHeader("Access-Control-Allow-Origin", "*");
+        return std::move(resp);
+    });
+
+    m_httpServer->sslSetup(sslCertificateChain.front(), sslKey);
+
+    const auto port = m_httpServer->listen(QHostAddress::Any, WebServer::Port);
+    if (!port) {
+        qWarning() << "Server failed to listen on a port.";
+        return false;
+    }
+    qWarning() << u"Running on https://127.0.0.1:%1/ (Press CTRL+C to quit)"_s.arg(port);
+
+    connect(m_webSocketServer, &QWebSocketServer::newConnection, this, &WebServer::onNewConnection);
+
+    return true;
+}
+
+void WebServer::onNewConnection()
+{
+    auto pSocket = m_webSocketServer->nextPendingConnection();
+    if (!pSocket) {
+        return;
+    }
 
     qDebug() << "Client connected:" << pSocket->peerName() << pSocket->origin();
 
-    connect(pSocket, &QWebSocket::textMessageReceived, this, &WebsocketServer::processTextMessage);
+    connect(pSocket, &QWebSocket::textMessageReceived, this, &WebServer::processTextMessage);
     connect(pSocket, &QWebSocket::binaryMessageReceived,
-            this, &WebsocketServer::processBinaryMessage);
-    connect(pSocket, &QWebSocket::disconnected, this, &WebsocketServer::socketDisconnected);
+            this, &WebServer::processBinaryMessage);
+    connect(pSocket, &QWebSocket::disconnected, this, &WebServer::socketDisconnected);
 
     m_clients << pSocket;
 }
 
-void WebsocketServer::processTextMessage(QString message)
+void WebServer::processTextMessage(QString message)
 {
     auto webClient = qobject_cast<QWebSocket *>(sender());
     if (webClient) {
         QJsonParseError error;
         const auto doc = QJsonDocument::fromJson(message.toUtf8(), &error);
         if (error.error != QJsonParseError::NoError) {
             qWarning() << "Error parsing json" << error.errorString();
             return;
         }
 
         if (!doc.isObject()) {
             qWarning() << "Invalid json received";
             return;
         }
 
         const auto object = doc.object();
         if (!object.contains("command"_L1) || !object["command"_L1].isString()
                 || !object.contains("arguments"_L1) || !object["arguments"_L1].isObject()) {
             qWarning() << "Invalid json received: no command or arguments set" ;
             return;
         }
 
-        static QHash<QString, WebsocketServer::Command> commandMapping {
-            { "register"_L1, WebsocketServer::Command::Register },
-            { "email-sent"_L1, WebsocketServer::Command::EmailSent },
+        static QHash<QString, WebServer::Command> commandMapping {
+            { "register"_L1, WebServer::Command::Register },
+            { "email-sent"_L1, WebServer::Command::EmailSent },
         };
 
         const auto command = commandMapping[doc["command"_L1].toString()];
 
         processCommand(command, object["arguments"_L1].toObject(), webClient);
     }
 }
 
-void WebsocketServer::processCommand(Command command, const QJsonObject &arguments, QWebSocket *socket)
+void WebServer::processCommand(Command command, const QJsonObject &arguments, QWebSocket *socket)
 {
     switch (command) {
     case Command::Register: {
         const auto type = arguments["type"_L1].toString();
         qDebug() << "Register" << arguments;
         if (type.isEmpty()) {
             qWarning() << "empty client type given when registering";
             return;
         }
 
         const auto emails = arguments["emails"_L1].toArray();
         if (type == "webclient"_L1) {
             if (emails.isEmpty()) {
                 qWarning() << "empty email given";
             }
             for (const auto &email : emails) {
                 m_webClientsMappingToEmail[email.toString()] = socket;
                 qWarning() << "email" << email.toString() << "mapped to a web client";
 
                 const auto nativeClient = m_nativeClientsMappingToEmail[email.toString()];
                 if (nativeClient) {
                     QJsonDocument doc(QJsonObject{
                         { "type"_L1, "connection"_L1 },
                         { "payload"_L1, QJsonObject{
                             { "client_type"_L1, "web_client"_L1 }
                         }}
                     });
                     nativeClient->sendTextMessage(QString::fromUtf8(doc.toJson()));
                 }
             }
         } else {
             if (emails.isEmpty()) {
                 qWarning() << "empty email given";
             }
             for (const auto &email : emails) {
                 m_nativeClientsMappingToEmail[email.toString()] = socket;
                 qWarning() << "email" << email.toString() << "mapped to a native client";
 
                 const auto webClient = m_webClientsMappingToEmail[email.toString()];
                 if (webClient) {
                     QJsonDocument doc(QJsonObject{
                         { "type"_L1, "connection"_L1 },
                         { "payload"_L1, QJsonObject{
                             { "client_type"_L1, "native_client"_L1 }
                         }}
                     });
                     webClient->sendTextMessage(QString::fromUtf8(doc.toJson()));
                 }
             }
         }
         return;
     }
     case Command::EmailSent: {
         const auto email = arguments["email"_L1].toString();
         const auto socket = m_nativeClientsMappingToEmail[email];
         if (!socket) {
             return;
         }
         QJsonDocument doc(QJsonObject{
             { "type"_L1, "email-sent"_L1 },
             { "arguments"_L1, arguments },
         });
         socket->sendTextMessage(QString::fromUtf8(doc.toJson()));
         return;
     }
     case Command::Undefined:
         qWarning() << "Invalid json received: invalid command" ;
         return;
     }
 }
 
-bool WebsocketServer::sendMessageToWebClient(const QString &email, const QString &payload)
+bool WebServer::sendMessageToWebClient(const QString &email, const QByteArray &payload)
 {
     auto socket = m_webClientsMappingToEmail[email];
     if (!socket) {
         return false;
     }
 
-    socket->sendTextMessage(payload);
+    socket->sendTextMessage(QString::fromUtf8(payload));
     return true;
 }
 
-void WebsocketServer::processBinaryMessage(QByteArray message)
+void WebServer::processBinaryMessage(QByteArray message)
 {
     qWarning() << "got binary message" << message;
     QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
     if (pClient) {
         pClient->sendBinaryMessage(message);
     }
 }
 
-void WebsocketServer::socketDisconnected()
+void WebServer::socketDisconnected()
 {
     QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
     if (pClient) {
         qDebug() << "Client disconnected" << pClient;
         // Web client was disconnected
         {
             const auto it = std::find_if(m_webClientsMappingToEmail.cbegin(), m_webClientsMappingToEmail.cend(), [pClient](QWebSocket *webSocket) {
                 return pClient == webSocket;
             });
 
             if (it != m_webClientsMappingToEmail.cend()) {
                 const auto email = it.key();
                 const auto nativeClient = m_nativeClientsMappingToEmail[email];
                 qDebug() << "webclient with email disconnected" << email << nativeClient;
                 if (nativeClient) {
                     QJsonDocument doc(QJsonObject{
                         { "type"_L1, "disconnection"_L1 },
                     });
                     nativeClient->sendTextMessage(QString::fromUtf8(doc.toJson()));
                 }
 
                 m_webClientsMappingToEmail.removeIf([pClient](auto socket) {
                     return pClient == socket.value();
                 });
             }
         }
 
         // Native client was disconnected
         const auto emails = m_nativeClientsMappingToEmail.keys();
         for (const auto &email : emails) {
             const auto webSocket = m_nativeClientsMappingToEmail[email];
             if (webSocket != pClient) {
                 qDebug() << "webSocket not equal" << email << webSocket << pClient;
                 continue;
             }
 
             qDebug() << "native client for" << email << "was disconnected.";
 
             QJsonDocument doc(QJsonObject{
                 { "type"_L1, "disconnection"_L1 },
             });
-            sendMessageToWebClient(email, QString::fromUtf8(doc.toJson()));
+            sendMessageToWebClient(email, doc.toJson());
         }
 
         m_nativeClientsMappingToEmail.removeIf([pClient](auto socket) {
             return pClient == socket.value();
         });
 
         m_clients.removeAll(pClient);
-        pClient->deleteLater();
     }
 }
-
-void WebsocketServer::onSslErrors(const QList<QSslError> &)
-{
-    qDebug() << "Ssl errors occurred";
-}
diff --git a/broker/websocketserver.h b/broker/webserver.h
similarity index 65%
rename from broker/websocketserver.h
rename to broker/webserver.h
index 5cf40e9..dc17e60 100644
--- a/broker/websocketserver.h
+++ b/broker/webserver.h
@@ -1,53 +1,66 @@
 // SPDX-FileCopyrightText: 2023 g10 code GmbH
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
 #include <QObject>
 #include <QList>
 #include <QByteArray>
 #include <QSslError>
 
 QT_FORWARD_DECLARE_CLASS(QWebSocketServer)
 QT_FORWARD_DECLARE_CLASS(QWebSocket)
 
 class WebsocketRequestBackend;
+class QHttpServer;
 
-class WebsocketServer : public QObject
+class WebServer : public QObject
 {
     Q_OBJECT
 public:
-    explicit WebsocketServer(const QSslCertificate &certificate,
-                             const QSslKey &key,
-                             quint16 port,
-                             QObject *parent = nullptr);
-    ~WebsocketServer() override;
+    /// Get singleton instance of WebServer
+    static WebServer &self();
+
+    /// WebServer destructor.
+    ~WebServer() override;
+
+    /// Start web server.
+    bool run();
+
+    /// is a valid WebServer instance
+    bool isValid() const;
+
+    bool sendMessageToWebClient(const QString &email, const QByteArray &payload);
+    bool sendMessageToNativeClient(const QString &email, const QByteArray &payload);
 
 private Q_SLOTS:
     void onNewConnection();
     void processTextMessage(QString message);
     void processBinaryMessage(QByteArray message);
     void socketDisconnected();
-    void onSslErrors(const QList<QSslError> &errors);
 
 private:
-    bool sendMessageToWebClient(const QString &email, const QString &payload);
-    bool sendMessageToNativeClient(const QString &email, const QString &payload);
+    WebServer();
 
     enum class Command {
         Undefined, ///< Undefined command.
         Register, ///< Registration of a client (native or web).
         EmailSent, ///< Confirmation that an email was sent.
     };
 
+    enum SpecialValues {
+        Port = 5656,
+    };
+
     void processCommand(Command command, const QJsonObject &arguments, QWebSocket *socket);
 
-    QWebSocketServer *m_pWebSocketServer;
+    QHttpServer * const m_httpServer;
+    QWebSocketServer * const m_webSocketServer;
     QList<QWebSocket *> m_clients;
     QHash<QString, QWebSocket *> m_webClientsMappingToEmail;
     QHash<QString, QWebSocket *> m_nativeClientsMappingToEmail;
 
-    friend WebsocketRequestBackend;
+    static WebServer s_instance;
 };
 
diff --git a/broker/websocketrequest.cpp b/broker/websocketrequest.cpp
deleted file mode 100644
index 03d9e78..0000000
--- a/broker/websocketrequest.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: 2023 g10 code GmbH
-// SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "websocketrequest.h"
-#include "websocketserver.h"
-#include <QGlobalStatic>
-
-WebsocketRequestBackend::WebsocketRequestBackend()
-{
-}
-
-WebsocketRequestBackend &WebsocketRequestBackend::instance()
-{
-    static WebsocketRequestBackend backend;
-    return backend;
-}
-
-void WebsocketRequestBackend::setServer(WebsocketServer *server)
-{
-    m_server = server;
-}
-
-void WebsocketRequestBackend::send(const QString &email, const QByteArray &payload)
-{
-    m_server->sendMessageToWebClient(email, QString::fromUtf8(payload));
-}
-
-WebsocketRequest::WebsocketRequest(const QString &email)
-    : m_email(email)
-{}
-
-void WebsocketRequest::setPayload(const QByteArray &payload)
-{
-    m_payload = payload;
-}
-
-void WebsocketRequest::send()
-{
-    WebsocketRequestBackend::instance().send(m_email, m_payload);
-}
diff --git a/broker/websocketrequest.h b/broker/websocketrequest.h
deleted file mode 100644
index bbe2969..0000000
--- a/broker/websocketrequest.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: 2023 g10 code GmbH
-// SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "websocketserver.h"
-#include <QString>
-
-class WebsocketRequest;
-class WebsocketServer;
-
-class WebsocketRequestBackend
-{
-public:
-    static WebsocketRequestBackend &instance();
-
-    void setServer(WebsocketServer *server);
-private:
-    WebsocketRequestBackend();
-
-    void send(const QString &email, const QByteArray &payload);
-
-    WebsocketServer *m_server = nullptr;
-
-    friend WebsocketRequest;
-    friend WebsocketServer;
-};
-
-class WebsocketRequest
-{
-public:
-    WebsocketRequest(const QString &mail);
-    void setPayload(const QByteArray &payland);
-
-    void send();
-
-private:
-    const QString m_email;
-    QByteArray m_payload;
-};
diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt
index d7152c6..f5994f8 100644
--- a/server/CMakeLists.txt
+++ b/server/CMakeLists.txt
@@ -1,278 +1,292 @@
 # SPDX-FileCopyrightText: 2023 g10 code GmbH
 # SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 # SPDX-License-Identifier: BSD-2-Clause
 
 add_library(gpgol-server-static)
 
 target_sources(gpgol-server-static PUBLIC
     websocketclient.cpp
     websocketclient.h
     webserver.h
     webserver.cpp
 
     # Identity
     identity/addressvalidationjob.cpp
     identity/addressvalidationjob.h
     identity/identitycombo.cpp
     identity/identitycombo.h
     identity/identitymanager.cpp
     identity/identitymanager.h
     identity/identitydialog.cpp
     identity/identitydialog.h
     identity/identityaddvcarddialog.cpp
     identity/identityaddvcarddialog.h
 
     # HTTP Controller
     controllers/emailcontroller.cpp
     controllers/emailcontroller.h
 
     # Draft
     draft/draft.cpp
     draft/draft.h
     draft/draftmanager.cpp
     draft/draftmanager.h
 
     # EWS integration
     ews/ewsattachment.cpp
     ews/ewsattachment.h
     ews/ewsattendee.cpp
     ews/ewsattendee.h
     ews/ewsclient_debug.cpp
     ews/ewsclient_debug.h
     ews/ewsid.cpp
     ews/ewsid.h
     ews/ewsitem.cpp
     ews/ewsitem.h
     ews/ewsitembase.cpp
     ews/ewsitembase.h
     ews/ewsitembase_p.h
     ews/ewsmailbox.cpp
     ews/ewsmailbox.h
     ews/ewsmailfactory.cpp
     ews/ewsmailfactory.h
     ews/ewsoccurrence.cpp
     ews/ewsoccurrence.h
     ews/ewspropertyfield.cpp
     ews/ewspropertyfield.h
     ews/ewsrecurrence.cpp
     ews/ewsrecurrence.h
     ews/ewsserverversion.cpp
     ews/ewsserverversion.h
     ews/ewstypes.cpp
     ews/ewstypes.h
     ews/ewsxml.cpp
     ews/ewsxml.h
 
     # Editor
     editor/composer.cpp
     editor/composer.h
     editor/composerviewbase.cpp
     editor/composerviewbase.h
     editor/composerwindow.cpp
     editor/composerwindow.h
     editor/composerwindowfactory.cpp
     editor/composerwindowfactory.h
     editor/cryptostateindicatorwidget.cpp
     editor/cryptostateindicatorwidget.h
     editor/encryptionstate.cpp
     editor/encryptionstate.h
     editor/kmcomposerglobalaction.cpp
     editor/kmcomposerglobalaction.h
     editor/nearexpirywarning.cpp
     editor/nearexpirywarning.h
     editor/mailtemplates.cpp
     editor/mailtemplates.h
     editor/recipient.cpp
     editor/recipient.h
     editor/recipientline.cpp
     editor/recipientline.h
     editor/recipientseditor.cpp
     editor/recipientseditor.h
     editor/util.h
     editor/util.cpp
     editor/richtextcomposerng.cpp
     editor/richtextcomposerng.h
     editor/richtextcomposersignatures.cpp
     editor/richtextcomposersignatures.h
     editor/nodehelper.cpp
     editor/nodehelper.h
     editor/signaturecontroller.cpp
     editor/signaturecontroller.h
     editor/spellcheckerconfigdialog.cpp
     editor/spellcheckerconfigdialog.h
 
     # Editor job
     editor/job/abstractencryptjob.h
     editor/job/autocryptheadersjob.h
     editor/job/contentjobbase.h
     editor/job/contentjobbase_p.h
     editor/job/dndfromarkjob.cpp
     editor/job/dndfromarkjob.h
     editor/job/encryptjob.h
     editor/job/inserttextfilejob.h
     editor/job/itipjob.h
     editor/job/jobbase.h
     editor/job/jobbase_p.h
     editor/job/maintextjob.h
     editor/job/multipartjob.h
     editor/job/protectedheadersjob.h
     editor/job/signencryptjob.h
     editor/job/signjob.h
     editor/job/singlepartjob.h
     editor/job/skeletonmessagejob.h
     editor/job/transparentjob.h
     editor/job/autocryptheadersjob.cpp
     editor/job/contentjobbase.cpp
     editor/job/encryptjob.cpp
     editor/job/inserttextfilejob.cpp
     editor/job/itipjob.cpp
     editor/job/jobbase.cpp
     editor/job/maintextjob.cpp
     editor/job/multipartjob.cpp
     editor/job/protectedheadersjob.cpp
     editor/job/saveasfilejob.cpp
     editor/job/saveasfilejob.h
     editor/job/signencryptjob.cpp
     editor/job/signjob.cpp
     editor/job/singlepartjob.cpp
     editor/job/skeletonmessagejob.cpp
     editor/job/transparentjob.cpp
 
     ## Editor Part
     editor/part/globalpart.h
     editor/part/infopart.h
     editor/part/itippart.h
     editor/part/messagepart.h
     editor/part/textpart.h
     editor/part/globalpart.cpp
     editor/part/infopart.cpp
     editor/part/itippart.cpp
     editor/part/messagepart.cpp
     editor/part/textpart.cpp
 
     ## Attachment
     editor/attachment/attachmentjob.cpp
     editor/attachment/attachmentjob.h
     editor/attachment/attachmentclipboardjob.cpp
     editor/attachment/attachmentclipboardjob.h
     editor/attachment/attachmentcompressjob.cpp
     editor/attachment/attachmentcompressjob.h
     editor/attachment/attachmentcontroller.cpp
     editor/attachment/attachmentcontroller.h
     editor/attachment/attachmentcontrollerbase.cpp
     editor/attachment/attachmentcontrollerbase.h
     editor/attachment/attachmentfromfolderjob.cpp
     editor/attachment/attachmentfromfolderjob.h
     editor/attachment/attachmentfrommimecontentjob.cpp
     editor/attachment/attachmentfrommimecontentjob.h
     editor/attachment/attachmentfromurlbasejob.cpp
     editor/attachment/attachmentfromurlbasejob.h
     editor/attachment/attachmentfromurljob.cpp
     editor/attachment/attachmentfromurljob.h
     editor/attachment/attachmentfromurlutils.cpp
     editor/attachment/attachmentfromurlutils.h
     editor/attachment/attachmentfrompublickeyjob.cpp
     editor/attachment/attachmentfrompublickeyjob.h
     editor/attachment/attachmentloadjob.cpp
     editor/attachment/attachmentloadjob.h
     editor/attachment/attachmentmodel.cpp
     editor/attachment/attachmentmodel.h
     editor/attachment/attachmentpart.cpp
     editor/attachment/attachmentpart.h
     editor/attachment/attachmentpropertiesdialog.cpp
     editor/attachment/attachmentpropertiesdialog.h
     editor/attachment/attachmentupdatejob.cpp
     editor/attachment/attachmentupdatejob.h
     editor/attachment/attachmentview.cpp
     editor/attachment/attachmentview.h
     editor/attachment/editorwatcher.cpp
     editor/attachment/editorwatcher.h
 )
 
+qt_add_resources(gpgol-server-static
+    PREFIX
+        "/"
+    FILES
+        assets/certificate.crt
+)
+
 
 ki18n_wrap_ui(gpgol-server-static
     editor/attachment/ui/attachmentpropertiesdialog.ui
     editor/attachment/ui/attachmentpropertiesdialog_readonly.ui
 )
 
 ecm_qt_declare_logging_category(gpgol-server-static_SRCS
     HEADER websocket_debug.h
     IDENTIFIER WEBSOCKET_LOG
     CATEGORY_NAME org.gpgol.server.websocket
     DESCRIPTION "Websocket connection in the server"
     EXPORT GPGOL
 )
 
 ecm_qt_declare_logging_category(gpgol-server-static_SRCS
     HEADER ewsresource_debug.h
     IDENTIFIER EWSRES_LOG
     CATEGORY_NAME org.gpgol.ews
     DESCRIPTION "Ews mail client"
     EXPORT GPGOL
 )
 
 ecm_qt_declare_logging_category(gpgol-server-static_SRCS
     HEADER ewscli_debug.h
     IDENTIFIER EWSCLI_LOG
     CATEGORY_NAME org.gpgol.ews.client
     DESCRIPTION "ews client (gpgol-server)"
     EXPORT GPGOL
 )
 
 ecm_qt_declare_logging_category(gpgol-server-static_SRCS
     HEADER editor_debug.h
     IDENTIFIER EDITOR_LOG
     CATEGORY_NAME org.gpgol.editor
     DESCRIPTION "mail composer"
     EXPORT GPGOL
 )
 
 set(WARN_TOOMANY_RECIPIENTS_DEFAULT true)
 set(ALLOW_SEMICOLON_AS_ADDRESS_SEPARATOR_DEFAULT true)
 
 configure_file(editor/settings/messagecomposer.kcfg.in ${CMAKE_CURRENT_BINARY_DIR}/messagecomposer.kcfg)
 
 kconfig_add_kcfg_files(gpgol-server-static_SRCS
     editor/settings/messagecomposersettings.kcfgc
 )
 
 install(FILES composerui.rc DESTINATION ${KDE_INSTALL_KXMLGUIDIR}/gpgol-server)
 
 target_sources(gpgol-server-static PUBLIC ${gpgol-server-static_SRCS})
 
 target_link_libraries(gpgol-server-static PUBLIC
     Qt6::HttpServer
     Qt6::Widgets
     Qt6::PrintSupport
 
     KF6::CalendarCore
     KF6::ConfigCore
     KF6::ConfigGui
     KF6::Contacts
     KF6::Completion
     KF6::CoreAddons
     KF6::ColorScheme
     KF6::Codecs
     KF6::GuiAddons
     KF6::SonnetUi
     KF6::WidgetsAddons
     KF6::XmlGui
     KF6::KIOFileWidgets
     KF6::Archive
     KF6::TextAutoCorrectionCore
 
     KPim6::MimeTreeParserWidgets
     KPim6::Libkleo
     KPim6::Libkdepim
     KPim6::LdapWidgets
     KPim6::PimTextEdit
     KPim6::IdentityManagementCore
     KPim6::IdentityManagementWidgets
 )
 
 add_executable(gpgol-server main.cpp)
 target_link_libraries(gpgol-server PRIVATE gpgol-server-static)
 
+qt_add_resources(gpgol-server
+    PREFIX
+        "/"
+    FILES
+        assets/certificate.crt
+)
+
 if (BUILD_TESTING)
     add_subdirectory(autotests)
 endif()
diff --git a/server/assets/certificate.crt b/server/assets/certificate.crt
new file mode 100644
index 0000000..67918e3
--- /dev/null
+++ b/server/assets/certificate.crt
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDezCCAmOgAwIBAgIUHLuHGdIuJmoYvCdmBhZV5Y8KLbMwDQYJKoZIhvcNAQEL
+BQAwTTELMAkGA1UEBhMCREUxDzANBgNVBAgMBkJlcmxpbjEPMA0GA1UEBwwGQmVy
+bGluMRwwGgYDVQQKDBNEZWZhdWx0IENvbXBhbnkgTHRkMB4XDTIzMTAyNDA3NDQz
+NloXDTI0MTAyMzA3NDQzNlowTTELMAkGA1UEBhMCREUxDzANBgNVBAgMBkJlcmxp
+bjEPMA0GA1UEBwwGQmVybGluMRwwGgYDVQQKDBNEZWZhdWx0IENvbXBhbnkgTHRk
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvs27B7raqGHrjLqGn+wf
+Zfbzh80Xl8109/s8KEl+3WtkuDvmJ11v22mvjowA0So6Rh4XhN1pD5K3tOpWwQo7
+oNPtjswBxNFyTU7791xH1P2uGjMvrzp18nJXvDGYvvtseMqiFAmdwcyO4p1CfZq/
+Zqn5/dWcFBMrQvHXOQzF2E3zoMNRXGfGKn8QcqWbgYr3HnIAVYqzdpTVCBzicsnf
++UrZcmv7MJu8F7nNG+fGSsZzaCrr3unFACcWDv/RF8qQalNO7XwrG/w2FLo2GpL7
+KkoK+u1hL9g7O/MHRBIiwllo8YfVNOg8IzQUbtkQ5EEE02yhJbZCQQXJJQwxqk1y
+2QIDAQABo1MwUTAdBgNVHQ4EFgQUX6bDEhlgLXy78gaOUoVOeAzxtzQwHwYDVR0j
+BBgwFoAUX6bDEhlgLXy78gaOUoVOeAzxtzQwDwYDVR0TAQH/BAUwAwEB/zANBgkq
+hkiG9w0BAQsFAAOCAQEAhnKL+NhIfr7I7SGsw1NwJwQ32DtpPC7sFvfqo/JUP7FI
+J9BjsV/4U+TIjnZst4EwZ9OfM7haLkRyCIlNSUfPT95Krqr44HFnsneCyMeVj4hP
+89zwV0NZGvyaSrQ30iKVUMdeRywwJo6LzWvj8zB+ARN0A8pOi9tBc/xTuW22vqGN
+0qeGcqMU0GNK1LW6Pw7zrirXl6ZlgZK1PfIgFzuSq4UAJBQAQ0TfeFItUx30OG1n
+P5VNIaEfr4aqnJfrlQ/G6j1dIgJhZx0ea8MaiwHin3hFD33JdI5dNPRbgC77TrbT
+W20+bRneoOjG5I/luPyzrcWfd/+w5WjZiR7Dl4ZC2Q==
+-----END CERTIFICATE-----
diff --git a/server/autotests/emailcontrollertest.cpp b/server/autotests/emailcontrollertest.cpp
index 243bebe..38e1bec 100644
--- a/server/autotests/emailcontrollertest.cpp
+++ b/server/autotests/emailcontrollertest.cpp
@@ -1,155 +1,157 @@
 // SPDX-FileCopyrightText: 2023 g10 code GmbH
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <QTest>
 #include <QObject>
 #include <QNetworkAccessManager>
 #include <QSignalSpy>
 #include <QNetworkReply>
 #include <QFile>
 #include <QToolBar>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QCoreApplication>
 #include <QStandardPaths>
 #include <MimeTreeParserWidgets/MessageViewerDialog>
 
 #include "../webserver.h"
 #include "../websocketclient.h"
 #include "../draft/draftmanager.h"
 #include "../editor/composerwindow.h"
 #include "../editor/recipientseditor.h"
 
 #include <QWebSocketServer>
 #include <QWebSocket>
 #include <KLocalizedString>
 
 using namespace Qt::Literals::StringLiterals;
 
 class EmailControllerTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase()
     {
         DraftManager::self(true);
         QCoreApplication::setApplicationName(u"gpgol-server"_s);
 
         KLocalizedString::setApplicationDomain(QByteArrayLiteral("gpgol"));
 
         m_webServer = new WebServer;
         m_webServer->run();
 
         auto webSocketServer = new QWebSocketServer(QStringLiteral("SSL Server"), QWebSocketServer::NonSecureMode);
 
 
         if (webSocketServer->listen(QHostAddress::Any, 5656)) {
 
         }
     }
 
     void testInfoEmailAction()
     {
         QFile file(QStringLiteral(DATA_DIR) + u"/encrypted.mbox"_s);
         QVERIFY(file.open(QIODeviceBase::ReadOnly));
 
         QNetworkRequest request(QUrl(u"http://127.0.0.1:%1/info"_s.arg(m_webServer->port())));
         auto reply = m_qnam.post(request, file.readAll());
         QSignalSpy spy(reply, &QNetworkReply::finished);
         spy.wait();
 
         QVERIFY(reply->error() == QNetworkReply::NoError);
 
         const auto doc = QJsonDocument::fromJson(reply->readAll());
         QVERIFY(!doc.isNull() && doc.isObject());
 
         const auto object = doc.object();
         QVERIFY(object["drafts"_L1].toArray().isEmpty());
         QVERIFY(object["encrypted"_L1].toBool());
         QVERIFY(!object["signed"_L1].toBool());
     }
 
     void testViewEmailAction()
     {
         QFile file(QStringLiteral(DATA_DIR) + u"/plaintext.mbox"_s);
         QVERIFY(file.open(QIODeviceBase::ReadOnly));
 
         QNetworkRequest request(QUrl(u"http://127.0.0.1:%1/view"_s.arg(m_webServer->port())));
         auto reply = m_qnam.post(request, file.readAll());
         QSignalSpy spy(reply, &QNetworkReply::finished);
         spy.wait();
 
         QVERIFY(reply->error() == QNetworkReply::NoError);
 
         const auto widgets = qApp->topLevelWidgets();
         QVERIFY(!widgets.isEmpty());
 
         MimeTreeParser::Widgets::MessageViewerDialog *dialog = nullptr;
         for (auto widget : widgets) {
             if (!widget->isHidden()) {
                 if (const auto messageViewer = qobject_cast<MimeTreeParser::Widgets::MessageViewerDialog *>(widget)) {
                     dialog = messageViewer;
                     break;
                 }
             }
         }
 
         QVERIFY(dialog);
 
-        WebsocketClient::self(QUrl(u"http://127.0.0.1"_s), 5656);
+        WebsocketClient::self(QUrl(u"ws://127.0.0.1"_s), 5656);
 
         const auto toolBar = dialog->toolBar();
         QVERIFY(toolBar->isVisible());
 
         const auto actions = toolBar->actions();
         QCOMPARE(actions.count(), 3);
         qWarning() << actions;
 
         QCOMPARE(actions[1]->icon().name(), u"mail-reply-sender-symbolic"_s);
         actions[1]->trigger();
 
         const auto widgets2 = qApp->topLevelWidgets();
         QVERIFY(!widgets2.isEmpty());
 
         ComposerWindow *composer = nullptr;
         for (auto widget : widgets2) {
             if (!widget->isHidden()) {
                 if (const auto composerWindow = qobject_cast<ComposerWindow *>(widget)) {
                     composer = composerWindow;
                     break;
                 }
             }
         }
         QVERIFY(composer);
 
         QSignalSpy spyInit(composer, &ComposerWindow::initialized);
         spyInit.wait();
 
         QCOMPARE(composer->subject(), u"RE: A random subject with alternative contenttype"_s);
 
         const auto recipients = composer->recipientsEditor()->recipients();
         QCOMPARE(recipients.count(), 2);
         QCOMPARE(recipients[0]->email(), u"konqi@example.org"_s);
         QCOMPARE(recipients[0]->name(), u"Konqi"_s);
 
         QCOMPARE(recipients[1]->email(), u"konqi@kde.org"_s);
         QVERIFY(recipients[1]->name().isEmpty());
+
+        QVERIFY(false);
     }
 
     void cleanupTestCase()
     {
         m_webServer->deleteLater();
     }
 
 private:
     QThread *m_thread = nullptr;
     WebServer *m_webServer = nullptr;
     QWebSocketServer *m_webSocketServer = nullptr;
     QNetworkAccessManager m_qnam;
 };
 
 QTEST_MAIN(EmailControllerTest)
 #include "emailcontrollertest.moc"
diff --git a/server/main.cpp b/server/main.cpp
index e56061a..263ab00 100644
--- a/server/main.cpp
+++ b/server/main.cpp
@@ -1,41 +1,46 @@
 // SPDX-FileCopyrightText: 2023 g10 code Gmbh
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "controllers/emailcontroller.h"
 
 #include <QHttpServer>
 #include <QHttpServerResponse>
 #include <QApplication>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QUuid>
 #include <QTimer>
+#include <QNetworkReply>
 #include <KLocalizedString>
 
 #include "websocketclient.h"
 #include "webserver.h"
+#include "qnam.h"
 
 using namespace Qt::Literals::StringLiterals;
 using namespace std::chrono;
 
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
     app.setQuitOnLastWindowClosed(false);
 
     KLocalizedString::setApplicationDomain(QByteArrayLiteral("gpgol"));
 
+    QObject::connect(qnam, &QNetworkAccessManager::sslErrors, qnam, [](QNetworkReply *reply, const QList<QSslError> &) {
+        reply->ignoreSslErrors();
+    });
+
     WebServer server;
     server.run();
     if (!server.running()) {
         qWarning() << "Server failed to listen on a port.";
         return 1;
     }
     const auto port = server.port();
-    qWarning() << u"Running on http://127.0.0.1:%1/ (Press CTRL+C to quit)"_s.arg(port);
 
-    WebsocketClient::self(QUrl(u"wss://127.0.0.1:5657"_s), port);
+    WebsocketClient::self(QUrl(u"wss://localhost:5656/"_s), port);
     return app.exec();
 }
diff --git a/server/websocketclient.cpp b/server/websocketclient.cpp
index 561474c..1ea0dfb 100644
--- a/server/websocketclient.cpp
+++ b/server/websocketclient.cpp
@@ -1,173 +1,186 @@
 // SPDX-FileCopyrightText: 2023 g10 code Gmbh
 // SPDX-Contributor: Carl Schwan <carl.schwan@gnupg.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "websocketclient.h"
 
 // Qt headers
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QTimer>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
+#include <QFile>
 
 // KDE headers
 #include <KLocalizedString>
 #include <Libkleo/KeyCache>
 
 // gpgme headers
 #include <gpgme++/key.h>
 
 #include "websocket_debug.h"
 #include "qnam.h"
 
 using namespace std::chrono;
 using namespace Qt::Literals::StringLiterals;
 
 namespace {
 QStringList trustedEmails(const std::shared_ptr<const Kleo::KeyCache> &keyCache)
 {
     QStringList emails;
 
     const auto keys = keyCache->keys();
     for (const auto &key : keys) {
         for (const auto &userId : key.userIDs()) {
             if (key.ownerTrust() == GpgME::Key::Ultimate) {
                 emails << QString::fromLatin1(userId.email()).toLower();
                 break;
             }
         }
     }
 
     return emails;
 }
 
 auto delay = 2000ms;
 
 void registerServer(int port, const QStringList &emails, const QString &serverId)
 {
     QNetworkRequest registerRequest(QUrl(u"https://127.0.0.1:5656/register"_s));
     registerRequest.setHeader(QNetworkRequest::ContentTypeHeader, u"application/json"_s);
     auto registerReply = qnam->post(registerRequest, QJsonDocument(QJsonObject{
         { "port"_L1, port },
         { "emails"_L1, QJsonArray::fromStringList(emails) },
         { "serverId"_L1, serverId },
     }).toJson());
 
 
     QObject::connect(registerReply, &QNetworkReply::finished, qnam, [port, emails, serverId, registerReply]() {
         if (registerReply->error() != QNetworkReply::NoError) {
             QTimer::singleShot(delay, [emails, port, serverId]() {
                 delay *= 2;
                 registerServer(port, emails, serverId);
             });
             qWarning() << "Failed to register" << registerReply->errorString() << "retrying in" << delay;
+        } else {
+            qWarning() << "Register";
         }
 
         registerReply->deleteLater();
     });
 }
 }
 
 WebsocketClient &WebsocketClient::self(const QUrl &url, int port)
 {
     static WebsocketClient *client = nullptr;
     if (!client && url.isEmpty()) {
         qFatal() << "Unable to create a client without an url";
     } else if (!client) {
         client = new WebsocketClient(url, port);
     }
     return *client;
 };
 
 WebsocketClient::WebsocketClient(const QUrl &url, int port)
     : QObject(nullptr)
     , m_url(url)
     , m_port(port)
 {
     connect(&m_webSocket, &QWebSocket::connected, this, &WebsocketClient::slotConnected);
     connect(&m_webSocket, &QWebSocket::disconnected, this, [this] {
         Q_EMIT closed(i18nc("@info", "Connection to outlook lost due to a disconnection with the broker."));
     });
     connect(&m_webSocket, &QWebSocket::errorOccurred, this, &WebsocketClient::slotErrorOccurred);
     connect(&m_webSocket, &QWebSocket::textMessageReceived, this, &WebsocketClient::slotTextMessageReceived);
     connect(&m_webSocket, QOverload<const QList<QSslError>&>::of(&QWebSocket::sslErrors), this, [this](const QList<QSslError> &errors) {
         // TODO remove
         m_webSocket.ignoreSslErrors(errors);
     });
 
+    QSslConfiguration sslConfiguration;
+    QFile certFile(QStringLiteral(":/assets/certificate.crt"));
+    if (!certFile.open(QIODevice::ReadOnly)) {
+        qFatal() << "Couldn't read certificate";
+    }
+    QSslCertificate certificate(&certFile, QSsl::Pem);
+    certFile.close();
+    sslConfiguration.addCaCertificate(certificate);
+    m_webSocket.setSslConfiguration(sslConfiguration);
+
     m_webSocket.open(url);
 
     auto globalKeyCache = Kleo::KeyCache::instance();
 
     m_emails = trustedEmails(globalKeyCache);
     if (m_emails.isEmpty()) {
         qWarning() << "No ultimately keys found in keychain";
         return;
     }
 
     m_serverId = QUuid::createUuid().toString(QUuid::WithoutBraces);
 
     // TODO remove me
     QObject::connect(qnam, &QNetworkAccessManager::sslErrors, qnam, [](QNetworkReply *reply, const QList<QSslError> &errors) {
         reply->ignoreSslErrors();
     });
 
     registerServer(m_port, m_emails, m_serverId);
 }
 
 void WebsocketClient::slotConnected()
 {
     qCInfo(WEBSOCKET_LOG) << "websocket connected";
     QJsonDocument doc(QJsonObject{
         { "command"_L1, "register"_L1 },
         { "arguments"_L1, QJsonObject {
             { "emails"_L1, QJsonArray::fromStringList(m_emails) },
             { "type"_L1, "nativeclient"_L1 }
         }}
     });
     m_webSocket.sendTextMessage(QString::fromUtf8(doc.toJson()));
 
     registerServer(m_port, m_emails, m_serverId);
 
     Q_EMIT connected();
 }
 
 void WebsocketClient::slotErrorOccurred(QAbstractSocket::SocketError error)
 {
     qCWarning(WEBSOCKET_LOG) << error << m_webSocket.errorString();
     Q_EMIT closed(i18nc("@info", "Connection to outlook lost due to a connection error."));
     reconnect();
 }
 
 void WebsocketClient::slotTextMessageReceived(QString message)
 {
     const auto doc = QJsonDocument::fromJson(message.toUtf8());
     if (!doc.isObject()) {
         qCWarning(WEBSOCKET_LOG) << "invalid text message received" << message;
         return;
     }
 
 
     const auto object = doc.object();
     qCDebug(WEBSOCKET_LOG) << object;
     if (object["type"_L1] == "disconnection"_L1) {
         // disconnection of the web client
         Q_EMIT closed(i18nc("@info", "Connection to outlook lost. Make sure the extension tab is open."));
     } else if (object["type"_L1] == "connection"_L1) {
         // reconnection of the web client
         Q_EMIT connected();
     } else if (object["type"_L1] == "email-sent"_L1) {
         // confirmation that the email was sent
         const auto args = object["arguments"_L1].toObject();
         Q_EMIT emailSentSuccessfully(args["id"_L1].toString());
     }
 }
 
 void WebsocketClient::reconnect()
 {
     QTimer::singleShot(1000ms, this, [this]() {
         m_webSocket.open(m_url);
     });
 }