Adding upstream version 4.7.upstream/4.7

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

93 files changed, 9289 insertions, 0 deletions

diff --git a/content/HttpRequest.jsm b/content/HttpRequest.jsm
new file mode 100644
index 0000000..fa28f97
--- /dev/null
+++ b/content/HttpRequest.jsm
@@ -0,0 +1,755 @@
+/*
+ * This file is part of TbSync, contributed by John Bieling.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ *
+ * Limitations:
+ * ============
+ * - no real event support (cannot add eventlisteners)
+ * - send only supports string body
+ * - onprogress not supported
+ * - readyState 2 & 3 not supported
+ *
+ * Note about HttpRequest.open(method, url, async, username, password):
+ * ============================================================================
+ * If an Authorization header is specified, HttpRequest will use the
+ * given header.
+ * 
+ * If no Authorization header is specified, but a username, HttpRequest
+ * will delegate the authentication process to nsIHttpChannel. If a password is
+ * specified as well, it will be used for authentication. If no password is
+ * specified, it will call the passwordCallback(username, realm, host) callback to 
+ * request a password for the given username, host and realm send back from
+ * the server (in the WWW-Authenticate header).
+ * 
+ */
+ 
+ "use strict";
+ 
+var EXPORTED_SYMBOLS = ["HttpRequest"];
+
+var bug669675 = [];
+var containers = [];
+var sandboxes = {};
+
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var HttpRequest = class {
+    constructor() {
+        // a private object to store xhr related properties
+        this._xhr = {};
+        
+        // HttpRequest supports two methods to receive data, using the
+        // streamLoader seems to be the more modern approach.
+        // BUT in order to overide MimeType, we need to call onStartRequest
+        this._xhr.useStreamLoader = false;
+        this._xhr.responseAsBase64 = false;
+        
+        this._xhr.loadFlags =  Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
+        this._xhr.headers = {};
+        this._xhr.readyState = 0;
+        this._xhr.responseStatus = null;
+        this._xhr.responseStatusText = null;
+        this._xhr.responseText = null;
+        this._xhr.httpchannel = null;
+        this._xhr.method = null;
+        this._xhr.uri = null;
+        this._xhr.permanentlyRedirectedUrl = null;
+        this._xhr.username = "";
+        this._xhr.password = "";
+        this._xhr.overrideMimeType = null;
+        this._xhr.mozAnon = false;
+        this._xhr.mozBackgroundRequest = false;
+        this._xhr.timeout = 0;
+        this._xhr.redirectFlags = null;
+        this._xhr.containerReset = false;
+        this._xhr.containerRealm = "default";
+        
+        this.onreadystatechange = function () {};
+        this.onerror = function () {};
+        this.onload = function () {};
+        this.ontimeout = function () {};
+        
+        // Redirects are handled internally, this callback is just called to
+        // inform the caller about the redirect.
+        // Flags: (https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM/Reference/Interface/nsIChannelEventSink)
+        //  - REDIRECT_TEMPORARY = 1 << 0;
+        //  - REDIRECT_PERMANENT = 1 << 1;
+        //  - REDIRECT_INTERNAL = 1 << 2;
+        // TB enforces a redirect from http -> https without having received a redirect,
+        // but an STS header
+        //  - REDIRECT_STS_UPGRADE = 1 << 3; 
+        // This is a custom bit set by HttpRequest to indicate, that this redirect was missed by the nsIHttpChannel implementation
+        // probably due to a CORS violation (like https -> http)
+        //  - REDIRECT_MISSED = 1 << 7; 
+        this.onredirect = function(flags, newUri) {};
+
+        // Whenever a WWW-Authenticate header has been parsed, this callback is
+        // called to inform the caller about the found realm.
+        this.realmCallback = function (username, realm, host) {};
+        
+        // Whenever a channel needs authentication, but the caller has only provided a username
+        // this callback is called to request the password.
+        this.passwordCallback = function (username, realm, host) {return null};
+
+        var self = this;
+
+        this.notificationCallbacks = {
+            // nsIInterfaceRequestor
+            getInterface : function(aIID) {
+                if (aIID.equals(Components.interfaces.nsIAuthPrompt2)) {
+                    // implement a custom nsIAuthPrompt2 - needed for auto authorization
+                    if (!self._xhr.authPrompt) {
+                        self._xhr.authPrompt = new HttpRequestPrompt(self._xhr.username,  self._xhr.password, self.passwordCallback, self.realmCallback);
+                    }
+                    return self._xhr.authPrompt;
+                } else if (aIID.equals(Components.interfaces.nsIAuthPrompt)) {
+                    // implement a custom nsIAuthPrompt
+                } else if (aIID.equals(Components.interfaces.nsIAuthPromptProvider)) {
+                    // implement a custom nsIAuthPromptProvider
+                } else if (aIID.equals(Components.interfaces.nsIPrompt)) {
+                    // implement a custom nsIPrompt
+                } else if (aIID.equals(Components.interfaces.nsIProgressEventSink)) {
+                    // implement a custom nsIProgressEventSink
+                } else if (aIID.equals(Components.interfaces.nsIChannelEventSink)) {
+                    // implement a custom nsIChannelEventSink
+                    return self.redirect;
+                }
+                throw Components.results.NS_ERROR_NO_INTERFACE;
+            },
+        };
+            
+        this.redirect = {
+            // nsIChannelEventSink implementation
+            asyncOnChannelRedirect: function(aOldChannel, aNewChannel, aFlags, aCallback) {
+                // Disallow redirects from https to http.
+                if (aOldChannel.URI.scheme == "https" && aNewChannel.URI.scheme == "http") {
+                    // Using an unused error code according to https://developer.mozilla.org/en-US/docs/Mozilla/Errors.
+                    // REJECTED_REDIRECT_FROM_HTTPS_TO_HTTP'
+                    aCallback.onRedirectVerifyCallback(0x804B002F);
+                    return;
+                }
+                
+                let uploadData;
+                let uploadContent;
+                if (aOldChannel instanceof Ci.nsIUploadChannel &&
+                    aOldChannel instanceof Ci.nsIHttpChannel &&
+                    aOldChannel.uploadStream) {
+                    uploadData = aOldChannel.uploadStream;
+                    uploadContent = aOldChannel.getRequestHeader("Content-Type");
+                }
+
+                aNewChannel.QueryInterface(Ci.nsIHttpChannel);
+                aOldChannel.QueryInterface(Ci.nsIHttpChannel);
+                            
+                function copyHeader(aHdr) {
+                    try {
+                        let hdrValue = aOldChannel.getRequestHeader(aHdr);
+                        if (hdrValue) {
+                            aNewChannel.setRequestHeader(aHdr, hdrValue, false);
+                        }
+                    } catch (e) {
+                        if (e.code != Components.results.NS_ERROR_NOT_AVAILIBLE) {
+                            // The header could possibly not be available, ignore that
+                            // case but throw otherwise
+                            throw e;
+                        }
+                    }
+                }
+
+                // Copy manually added headers
+                for (let header in self._xhr.headers) {
+                    if (self._xhr.headers.hasOwnProperty(header)) {
+                        copyHeader(header);
+                    }
+                }
+                
+                prepHttpChannelUploadData(
+                    aNewChannel, 
+                    aOldChannel.requestMethod, 
+                    uploadData, 
+                    uploadContent);
+                
+                self._xhr.redirectFlags = aFlags;
+                if (aFlags & Ci.nsIChannelEventSink.REDIRECT_PERMANENT) {
+                    self._xhr.permanentlyRedirectedUrl = aNewChannel.URI.spec;
+                }
+                self.onredirect(aFlags, aNewChannel.URI);
+                aCallback.onRedirectVerifyCallback(Components.results.NS_OK);
+            }
+        };
+        
+        this.listener = {
+            _buffer: [],
+
+            //nsIStreamListener (aUseStreamLoader = false)
+            onStartRequest: function(aRequest) {
+                //Services.console.logStringMessage("[onStartRequest] " +  aRequest.URI.spec);
+                this._buffer = [];
+                
+                if (self._xhr.overrideMimeType) {
+                    aRequest.contentType = self._xhr.overrideMimeType;
+                }
+            },
+            onDataAvailable: function (aRequest, aInputStream, aOffset, aCount) {
+                //Services.console.logStringMessage("[onDataAvailable] " +  aRequest.URI.spec + " : " + aCount);				
+                let buffer = new ArrayBuffer(aCount);
+                let stream = Components.classes["@mozilla.org/binaryinputstream;1"].createInstance(Components.interfaces.nsIBinaryInputStream);
+                stream.setInputStream(aInputStream);
+                stream.readArrayBuffer(aCount, buffer);
+                
+                // store the chunk
+                this._buffer.push(Array.from(new Uint8Array(buffer)));
+            },        
+            onStopRequest: function(aRequest, aStatusCode) {
+                //Services.console.logStringMessage("[onStopRequest] " +  aRequest.URI.spec + " : " + aStatusCode);
+                // combine all binary chunks to create a flat byte array;				
+                let combined = [].concat.apply([], this._buffer);
+                let data = convertByteArray(combined, self.responseAsBase64);
+                this.processResponse(aRequest.QueryInterface(Components.interfaces.nsIHttpChannel), aStatusCode, data);
+            },
+        
+
+
+            //nsIStreamLoaderObserver (aUseStreamLoader = true)
+            onStreamComplete: function(aLoader, aContext, aStatus, aResultLength, aResult) {
+                let result = convertByteArray(aResult, self.responseAsBase64);  
+                this.processResponse(aLoader.request.QueryInterface(Components.interfaces.nsIHttpChannel), aStatus, result);
+            },
+            
+            processResponse: function(aChannel, aStatus, aResult) {                
+                //Services.console.logStringMessage("[processResponse] " + aChannel.URI.spec + " : " + aStatus);
+                // do not set any channal response data, before we know we failed
+                // and before we know we do not have to rerun (due to bug 669675)
+                
+                let responseStatus = null;
+                try {
+                    responseStatus = aChannel.responseStatus;
+                } catch (ex) {
+                    switch (aStatus) {
+                        case Components.results.NS_ERROR_NET_TIMEOUT:
+                            self._xhr.httpchannel = aChannel;
+                            self._xhr.responseText = aResult;
+                            self._xhr.responseStatus = 0;
+                            self._xhr.responseStatusText = "";
+                            self._xhr.readyState = 4;
+                            self.onreadystatechange();				
+                            self.ontimeout();
+                            return;
+                        case Components.results.NS_BINDING_ABORTED:
+                        case 0x804B002F: //Custom error (REJECTED_REDIRECT_FROM_HTTPS_TO_HTTP')
+                            self._xhr.httpchannel = aChannel;
+                            self._xhr.responseText = aResult;
+                            self._xhr.responseStatus = 0;
+                            self._xhr.responseStatusText = "";
+                            self._xhr.readyState = 0;
+                            self.onreadystatechange();				
+                            self.onerror();
+                            return;
+                        case 0x805303F4: //NS_ERROR_DOM_BAD_URI 
+                            // Error on Strict-Transport-Security induced Redirect http -> https (these do not even show up in the console)
+                            // The redirect has been done already and the channel is already the new channel.
+                            // Due to CORS violation, it cannot be fulfilled.
+                            if (self._xhr.redirectFlags && aChannel.URI.spec != self._xhr.uri.spec) {
+                                self._xhr.uri = aChannel.URI;
+                                self.send(self._xhr.data);
+                                return;
+                            }
+                        default:
+                            self._xhr.httpchannel = aChannel;
+                            self._xhr.responseText = aResult;
+                            self._xhr.responseStatus = 0;
+                            self._xhr.responseStatusText = "";
+                            self._xhr.readyState = 4;
+                            self.onreadystatechange();				
+                            self.onerror();
+                            return;
+                    }
+                }
+                
+                // Usually redirects are handled internally, but any CORS violating request is 
+                // returning a 30x, if CORS is not allowed. This is not true for STS induced redirects (see above).
+                if ([301,302,307,308].includes(responseStatus)) {
+                    // aChannel is still the old channel
+                    let redirected = self.getResponseHeader("location");
+                    if (redirected && redirected != aChannel.URI.spec) {
+                        let flag = Ci.nsIChannelEventSink.REDIRECT_TEMPORARY;
+                        let uri = Services.io.newURI(redirected);
+                        if ([301,308].includes(responseStatus)) {
+                            flag =  Ci.nsIChannelEventSink.REDIRECT_PERMANENT;
+                            self._xhr.permanentlyRedirectedUrl = uri.spec;
+                        }
+                        // inform caller about the redirect and set the REDIRECT_MISSED bit
+
+                        self.onredirect(flag | 0x80, uri);
+                        self._xhr.uri = uri;
+                        self.send(self._xhr.data);
+                        return;
+                    }
+                }
+                
+                // mitigation for bug https://bugzilla.mozilla.org/show_bug.cgi?id=669675
+                // we need to check, if nsIHttpChannel was in charge of auth:
+                // if there was no Authentication header provided by the user, but a username
+                // nsIHttpChannel should have added one. Is there one?
+                if (
+                    (responseStatus == 401) &&
+                    !self._xhr.mozAnon &&
+                    !self.hasRequestHeader("Authorization") && // no user defined header, so nsIHttpChannel should have called the authPrompt
+                    self._xhr.username && // we can only add basic auth header if user
+                    self._xhr.password // and pass are present
+                ) {
+                    // check the actual Authorization headers send
+                    let unauthenticated;
+                    try {
+                        let header = aChannel.getRequestHeader("Authorization");
+                        unauthenticated = false;
+                    } catch (e) {
+                        unauthenticated = true;
+                    }
+                  
+                    if (unauthenticated) {
+                        if (!bug669675.includes(self._xhr.uri.spec)) {
+                            bug669675.push(self._xhr.uri.spec)
+                            console.log("Mitigation for bug 669675 for URL <"+self._xhr.uri.spec+"> (Once per URL per session)");
+                            // rerun
+                            self.send(self._xhr.data);
+                            return;
+                        } else {
+                            console.log("Mitigation failed for URL <"+self._xhr.uri.spec+">");
+                        }
+                    }
+                }
+
+                self._xhr.httpchannel = aChannel;
+                self._xhr.responseText = aResult;
+                self._xhr.responseStatus =	responseStatus;
+                self._xhr.responseStatusText = aChannel.responseStatusText;
+                self._xhr.readyState = 4;
+                self.onreadystatechange();				
+                self.onload();
+            }
+        };
+    }
+
+
+    
+    
+    /** public **/
+        
+    open(method, url, async = true, username = "", password = "") {
+        this._xhr.method = method;
+
+        try {
+            this._xhr.uri = Services.io.newURI(url);
+        } catch (e) {
+            Components.utils.reportError(e);
+            throw new Error("HttpRequest: Invalid URL <"+url+">");
+        }
+        if (!async) throw new Error ("HttpRequest: Synchronous requests not implemented.");
+
+        this._xhr.username = username;
+        this._xhr.password = password;
+
+        this._xhr.readyState = 1;
+        this.onreadystatechange();
+        
+    }
+    
+    // must be called after open, before send
+    setContainerRealm(v) {
+        this._xhr.containerRealm = v;
+    }
+    
+    // must be called after open, before send
+    clearContainerCache() {
+        this._xhr.containerReset = true;
+    }
+
+    send(data) {
+        //store the data, so we can rerun
+        this._xhr.data = data;
+        this._xhr.redirectFlags = null;
+
+        // The sandbox will have a loadingNode
+        let sandbox = getSandboxForOrigin(this._xhr.username, this._xhr.uri, this._xhr.containerRealm, this._xhr.containerReset);
+        
+        // The XHR in the sandbox will have the correct loadInfo, which will allow us
+        // to use cookies and a CodebasePrincipal for us to use userContextIds and to
+        // contact nextcloud servers (error 503).
+        // We will not use the XHR or the sandbox itself.
+        let XHR = new sandbox.XMLHttpRequest();
+        XHR.open(this._xhr.method, this._xhr.uri.spec);
+
+        // Create the channel with the loadInfo from the sandboxed XHR
+        let channel = Services.io.newChannelFromURIWithLoadInfo(this._xhr.uri, XHR.channel.loadInfo);
+
+        /*
+        // as of TB67 newChannelFromURI needs to specify a loading node to have access to the cookie jars
+        // using the main window
+        // another option would be workers
+        let options = {};
+        let mainWindow = Services.wm.getMostRecentWindow("mail:3pane");
+        
+        let channel = Services.io.newChannelFromURI(
+            this._xhr.uri,
+            mainWindow.document,
+            Services.scriptSecurityManager.createContentPrincipal(this._xhr.uri, options),
+            null,
+            Components.interfaces.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+            Components.interfaces.nsIContentPolicy.TYPE_OTHER);
+        */
+
+/*        
+        // enforce anonymous access if requested (will not work with proxy, see MDN)
+        if (this._xhr.mozAnon) {
+            channel.loadFlag |= Components.interfaces.nsIRequest.LOAD_ANONYMOUS;
+        }
+
+        // set background request
+        if (this._xhr.mozBackgroundRequest) {
+            channel.loadFlag |= Components.interfaces.nsIRequest.LOAD_BACKGROUND;
+        }
+*/        
+        this._xhr.httpchannel = channel.QueryInterface(Components.interfaces.nsIHttpChannel);
+        this._xhr.httpchannel.loadFlags |= this._xhr.loadFlags;
+        this._xhr.httpchannel.notificationCallbacks = this.notificationCallbacks;
+                
+        // Set default content type.
+        if (!this.hasRequestHeader("Content-Type")) {
+            this.setRequestHeader("Content-Type", "application/xml; charset=utf-8")
+        }
+        
+        // Set default accept value.
+        if (!this.hasRequestHeader("Accept")) {
+           this.setRequestHeader("Accept", "*/*");
+        }
+
+        // Set non-standard header to request authorization (https://github.com/jobisoft/DAV-4-TbSync/issues/106)
+        if (this._xhr.username) {
+            this.setRequestHeader("X-EnforceAuthentication", "True");
+        }
+
+        // calculate length of request and add header
+        if (data) {
+            let textEncoder = new TextEncoder();
+            let encoded = textEncoder.encode(data);
+            this.setRequestHeader("Content-Length", encoded.length);
+        }
+
+        // mitigation for bug 669675
+        if (
+            bug669675.includes(this._xhr.uri.spec) &&
+            !this._xhr.mozAnon && 
+            !this.hasRequestHeader("Authorization") &&
+            this._xhr.username &&
+            this._xhr.password
+        ) {
+            this.setRequestHeader("Authorization", "Basic " + b64EncodeUnicode(this._xhr.username + ':' + this._xhr.password));
+        }
+        
+        // add all headers to the channel
+        for (let header in this._xhr.headers) {
+            if (this._xhr.headers.hasOwnProperty(header)) {
+                this._xhr.httpchannel.setRequestHeader(header, this._xhr.headers[header], false);
+            }
+        }
+        
+        // Will overwrite the Content-Type, so it must be called after the headers have been set.
+        prepHttpChannelUploadData(this._xhr.httpchannel, this._xhr.method, data, this.getRequestHeader("Content-Type"));
+
+        if (this._xhr.useStreamLoader) {
+            let loader =  Components.classes["@mozilla.org/network/stream-loader;1"].createInstance(Components.interfaces.nsIStreamLoader);
+            loader.init(this.listener);
+            this.listener = loader;
+        }        
+
+        this._startTimeout();
+        this._xhr.httpchannel.asyncOpen(this.listener, this._xhr.httpchannel);
+    }
+
+    get readyState() { return this._xhr.readyState; }
+    get responseURI() { return this._xhr.httpchannel.URI; }
+    get responseURL() { return this._xhr.httpchannel.URI.spec; }
+    get permanentlyRedirectedUrl() { return this._xhr.permanentlyRedirectedUrl; }
+    get responseText() { return this._xhr.responseText; }
+    get status() { return this._xhr.responseStatus; }
+    get statusText() { return this._xhr.responseStatusText; }
+    get channel() { return this._xhr.httpchannel; }
+    get loadFlags() { return this._xhr.loadFlags; }
+    get timeout() { return this._xhr.timeout; }
+    get mozBackgroundRequest() { return this._xhr.mozBackgroundRequest; }    
+    get mozAnon() { return this._xhr.mozAnon; }    
+
+    set loadFlags(v) { this._xhr.loadFlags = v; }
+    set timeout(v) { this._xhr.timeout = v; }
+    set mozBackgroundRequest(v) { this._xhr.mozBackgroundRequest = (v === true); }
+    set mozAnon(v) { this._xhr.mozAnon = (v === true); }
+    
+
+    // case insensitive method to check for headers
+    hasRequestHeader(header) {
+        let lowHeaders = Object.keys(this._xhr.headers).map(x => x.toLowerCase());
+        return lowHeaders.includes(header.toLowerCase());
+    }
+    
+    // if a header exists (case insensitive), it will be replaced (keeping the original capitalization)
+    setRequestHeader(header, value) {
+        let useHeader = header;
+        let lowHeader = header.toLowerCase();
+        
+        for (let h in this._xhr.headers) {
+            if (this._xhr.headers.hasOwnProperty(h) && h.toLowerCase() == lowHeader) {
+                useHeader = h;
+                break;
+            }
+        }
+        this._xhr.headers[useHeader] = value;
+    }
+
+    // checks if a header (case insensitive) has been set by setRequestHeader - that does not mean it has been added to the channel!
+    getRequestHeader(header) {
+        let lowHeader = header.toLowerCase();
+        
+        for (let h in this._xhr.headers) {
+            if (this._xhr.headers.hasOwnProperty(h) && h.toLowerCase() == lowHeader) {
+                return this._xhr.headers[h];
+            }
+        }
+        return null;
+    }
+
+    getResponseHeader(header) {
+        try {
+            return this._xhr.httpchannel.getResponseHeader(header);
+        } catch (e) {
+            if (e.code != Components.results.NS_ERROR_NOT_AVAILIBLE) {
+                // The header could possibly not be available, ignore that
+                // case but throw otherwise
+                throw e;
+            }			
+        }
+        return null;
+    }
+
+    overrideMimeType(mime) {
+         this._xhr.overrideMimeType = mime;
+    }
+
+    abort() {
+        this._cancel(Components.results.NS_BINDING_ABORTED);
+    }
+
+    get responseAsBase64() { return this._xhr.responseAsBase64; }
+    set responseAsBase64(v) { this._xhr.responseAsBase64 = (v == true);}
+
+    /* not used */
+    
+    get responseXML() { throw new Error("HttpRequest: responseXML not implemented"); }
+
+    get response() { throw new Error("HttpRequest: response not implemented"); }
+    set response(v) { throw new Error("HttpRequest: response not implemented"); }
+
+    get responseType() { throw new Error("HttpRequest: response not implemented"); }
+    set responseType(v) { throw new Error("HttpRequest: response not implemented"); }
+
+    get upload() { throw new Error("HttpRequest: upload not implemented"); }
+    set upload(v) { throw new Error("HttpRequest: upload not implemented"); }
+
+    get withCredentials() { throw new Error("HttpRequest: withCredentials not implemented"); }
+    set withCredentials(v) { throw new Error("HttpRequest: withCredentials not implemented"); }
+
+
+
+
+
+
+    /** private helper methods **/
+    
+    _startTimeout() {
+        let that = this;
+        
+        this._xhr.timer = Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer);
+        let event = {
+            notify: function(timer) {
+                that._cancel(Components.results.NS_ERROR_NET_TIMEOUT)
+            }
+        }
+        this._xhr.timer.initWithCallback(
+            event, 
+            this._xhr.timeout, 
+            Components.interfaces.nsITimer.TYPE_ONE_SHOT);
+    }
+
+    _cancel(error) {
+        if (this._xhr.httpchannel && error) {
+            this._xhr.httpchannel.cancel(error);
+        }
+    }
+}
+
+
+
+
+
+var HttpRequestPrompt = class {
+    constructor(username, password, promptCallback, realmCallback) {
+        this.mCounts = 0;
+        this.mUsername = username;
+        this.mPassword = password;
+        this.mPromptCallback = promptCallback;
+        this.mRealmCallback = realmCallback;
+    }
+
+    // boolean promptAuth(in nsIChannel aChannel,
+    //                    in uint32_t level,
+    //                    in nsIAuthInformation authInfo)
+    promptAuth (aChannel, aLevel, aAuthInfo) {      
+        this.mRealmCallback(this.mUsername, aAuthInfo.realm, aChannel.URI.host);
+        if (this.mUsername && this.mPassword) {
+            console.log("Passing provided credentials for user <"+this.mUsername+"> to nsIHttpChannel.");
+            aAuthInfo.username = this.mUsername;
+            aAuthInfo.password = this.mPassword;
+        } else if (this.mUsername) {
+            console.log("Using passwordCallback callback to get password for user <"+this.mUsername+"> and realm <"+aAuthInfo.realm+"> @ host <"+aChannel.URI.host+">");
+            let password = this.mPromptCallback(this.mUsername, aAuthInfo.realm, aChannel.URI.host);
+            if (password) {
+                aAuthInfo.username = this.mUsername;
+                aAuthInfo.password = password;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+        
+        // The provided password could be wrong, in whichcase
+        //  we would be here more than once.
+        this.mCounts++
+        return (this.mCounts < 2);
+    }
+}
+  
+
+
+
+function getSandboxForOrigin(username, uri, containerRealm = "default", containerReset = false) {
+    let options = {};
+    let origin = uri.scheme + "://" + uri.hostPort;
+    
+    // Note:
+    // Disabled check for username to always use containers, even if no username is given.
+    // There was an issue with NC (in its container) and google being in the default container,
+    // causing NC to fail with 503. Putting google inside a container as well fixed it.
+    options.userContextId = getContainerIdForUser(containerRealm + "::" + username);
+    origin = options.userContextId + "@" + origin;
+    if (containerReset) {
+        resetContainerWithId(options.userContextId);
+    }    
+    
+    if (!sandboxes.hasOwnProperty(origin)) {
+        console.log("Creating sandbox for <"+origin+">");
+        let principal = Services.scriptSecurityManager.createContentPrincipal(uri, options);    
+        sandboxes[origin] = Components.utils.Sandbox(principal, {
+            wantXrays: true,
+            wantGlobalProperties: ["XMLHttpRequest"],
+        });
+    }
+    
+    return sandboxes[origin];
+}
+
+function resetContainerWithId(id) {
+    Services.clearData.deleteDataFromOriginAttributesPattern({ userContextId: id });
+}
+
+function getContainerIdForUser(username) {
+    // Define the allowed range of container ids to be used
+    // TbSync is using 10000 - 19999
+    // Lightning is using 20000 - 29999
+    // Cardbook is using 30000 - 39999
+    let min = 10000;
+    let max = 19999;
+    
+    //reset if adding an entry will exceed allowed range
+    if (containers.length > (max-min) && containers.indexOf(username) == -1) {
+        for (let i=0; i < containers.length; i++) {
+            resetContainerWithId(i + min);
+        }
+        containers = [];
+    }
+    
+    let idx = containers.indexOf(username);
+    return (idx == -1) ? containers.push(username) - 1 + min : (idx + min);
+}
+
+// copied from cardbook
+function b64EncodeUnicode (aString) {
+    return btoa(encodeURIComponent(aString).replace(/%([0-9A-F]{2})/g, function(match, p1) {
+        return String.fromCharCode('0x' + p1);
+    }));
+}
+
+// copied from lightning
+function prepHttpChannelUploadData(aHttpChannel, aMethod, aUploadData, aContentType) {
+    if (aUploadData) {
+        aHttpChannel.QueryInterface(Components.interfaces.nsIUploadChannel);
+        let stream;
+        if (aUploadData instanceof Components.interfaces.nsIInputStream) {
+            // Make sure the stream is reset
+            stream = aUploadData.QueryInterface(Components.interfaces.nsISeekableStream);
+            stream.seek(Components.interfaces.nsISeekableStream.NS_SEEK_SET, 0);
+        } else {
+            // Otherwise its something that should be a string, convert it.
+            let converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"]
+                .createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
+            converter.charset = "UTF-8";
+            stream = converter.convertToInputStream(aUploadData.toString());
+        }
+
+      // If aContentType is empty, the protocol will assume that no content headers are to be
+      // added to the uploaded stream and that any required headers are already encoded in
+      // the stream. In the case of HTTP, if this parameter is non-empty, then its value will
+      // replace any existing Content-Type header on the HTTP request. In the case of FTP and
+      // FILE, this parameter is ignored.
+      aHttpChannel.setUploadStream(stream, aContentType, -1);
+    }	
+
+    //must be set after setUploadStream
+    //https://developer.mozilla.org/en-US/docs/Mozilla/Creating_sandboxed_HTTP_connections
+    aHttpChannel.QueryInterface(Ci.nsIHttpChannel);
+    aHttpChannel.requestMethod = aMethod;
+}
+  
+/**
+ * Convert a byte array to a string - copied from lightning
+ *
+ * @param {octet[]} aResult            The bytes to convert
+ * @param {Boolean} responseAsBase64   Return a base64 encoded string
+ * @param {String} aCharset            The character set of the bytes, defaults to utf-8
+ * @param {Boolean} aThrow             If true, the function will raise an exception on error
+ * @returns {?String}                  The string result, or null on error
+ */
+function convertByteArray(aResult, responseAsBase64 = false, aCharset="utf-8", aThrow) {
+    if (responseAsBase64) {
+        var bin = '';
+        var bytes = Uint8Array.from(aResult);
+        var len = bytes.byteLength;
+        for (var i = 0; i < len; i++) {
+            bin += String.fromCharCode( bytes[ i ] );
+        }
+        return btoa( bin ); // if we ever need raw, return bin
+    } else {
+        try {
+            return new TextDecoder(aCharset).decode(Uint8Array.from(aResult));
+        } catch (e) {
+            if (aThrow) {
+                throw e;
+            }
+        }
+    }
+    return null;
+}
+
diff --git a/content/OverlayManager.jsm b/content/OverlayManager.jsm
new file mode 100644
index 0000000..a0c18d6
--- /dev/null
+++ b/content/OverlayManager.jsm
@@ -0,0 +1,514 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var EXPORTED_SYMBOLS = ["OverlayManager"];
+
+var { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+function OverlayManager(extension, options = {}) {
+  this.registeredOverlays = {};
+  this.overlays =  {};
+  this.stylesheets = {};
+  this.options = {verbose: 0};
+  this.extension = extension;
+  
+  let userOptions = Object.keys(options);
+  for (let i=0; i < userOptions.length; i++) {
+    this.options[userOptions[i]] = options[userOptions[i]];
+  }
+
+
+
+  this.windowListener = {
+    that: this,
+    onOpenWindow: function(xulWindow) {
+      let window = xulWindow.QueryInterface(Components.interfaces.nsIInterfaceRequestor).getInterface(Components.interfaces.nsIDOMWindow);
+      this.that.injectAllOverlays(window);
+    },
+    onCloseWindow: function(xulWindow) { },
+    onWindowTitleChange: function(xulWindow, newTitle) { }
+  };
+
+  
+
+
+  this.startObserving = function () {
+    let windows = Services.wm.getEnumerator(null);
+    while (windows.hasMoreElements()) {
+      let window = windows.getNext();
+      //inject overlays for this window
+      this.injectAllOverlays(window);
+    }
+
+    Services.wm.addListener(this.windowListener);
+  };
+
+  this.stopObserving = function () {
+    Services.wm.removeListener(this.windowListener);
+
+    let  windows = Services.wm.getEnumerator(null);
+    while (windows.hasMoreElements()) {
+      let window = windows.getNext();            
+      //remove overlays (if any)
+      this.removeAllOverlays(window);
+    }
+  };
+
+  this.hasRegisteredOverlays = function (window) {
+    return this.registeredOverlays.hasOwnProperty(window.location.href);
+  };
+
+  this.registerOverlay = async function (dst, overlay) {
+    if (overlay.startsWith("chrome://")) {
+      let xul = null;
+      try {
+        xul = await this.readChromeFile(overlay);
+      } catch (e) {
+        console.log("Error reading file <"+overlay+"> : " + e);
+        return;
+      }
+      let rootNode = this.getDataFromXULString(xul);
+  
+      if (rootNode) {
+        //get urls of stylesheets to load them
+        let styleSheetUrls = this.getStyleSheetUrls(rootNode);
+        for (let i=0; i<styleSheetUrls.length; i++) {
+        //we must replace, since we do not know, if it changed - could have been an update
+        //if (!this.stylesheets.hasOwnProperty(styleSheetUrls[i])) {
+          this.stylesheets[styleSheetUrls[i]] = await this.readChromeFile(styleSheetUrls[i]);
+        //}
+        }
+        
+        if (!this.registeredOverlays[dst]) this.registeredOverlays[dst] = [];
+        if (!this.registeredOverlays[dst].includes(overlay)) this.registeredOverlays[dst].push(overlay);
+        
+        this.overlays[overlay] = rootNode;
+      }
+    } else {
+      console.log("Only chrome:// URIs can be registered as overlays.");
+    }
+  };  
+
+  this.getDataFromXULString = function (str) {
+    let data = null;
+    let xul = "";        
+    if (str == "") {
+      if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: A provided XUL file is empty!");
+      return null;
+    }
+
+    let oParser = new DOMParser();
+    try {
+      xul = oParser.parseFromString(str, "application/xml");
+    } catch (e) {
+      //however, domparser does not throw an error, it returns an error document
+      //https://developer.mozilla.org/de/docs/Web/API/DOMParser
+      //just in case
+      if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: A provided XUL file could not be parsed correctly, something is wrong.\n" + str);
+      return null;
+    }
+
+    //check if xul is error document
+    if (xul.documentElement.nodeName == "parsererror") {
+      if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: A provided XUL file could not be parsed correctly, something is wrong.\n" + str);
+      return null;
+    }
+    
+    if (xul.documentElement.nodeName != "overlay") {
+      if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: A provided XUL file does not look like an overlay (root node is not overlay).\n" + str);
+      return null;
+    }
+    
+    return xul;
+  };
+
+
+
+
+
+  this.injectAllOverlays = async function (window, _href = null) {
+    if (window.document.readyState != "complete") {
+      // Make sure the window load has completed.
+      await new Promise(resolve => {
+      window.addEventListener("load", resolve, { once: true });
+      });
+    }
+
+    let href = (_href === null) ? window.location.href : _href;   
+    if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] Injecting into new window: " + href);
+    let injectCount = 0;
+    for (let i=0; this.registeredOverlays[href] && i < this.registeredOverlays[href].length; i++) {
+      if (this.injectOverlay(window, this.registeredOverlays[href][i])) injectCount++;
+    }
+    if (injectCount > 0) {
+        // dispatch a custom event to indicate we finished loading the overlay
+        let event = new Event("DOMOverlayLoaded_" + this.extension.id);
+        window.document.dispatchEvent(event);
+    }
+  };
+
+  this.removeAllOverlays = function (window) {
+    if (!this.hasRegisteredOverlays(window))
+      return;
+    
+    for (let i=0; i < this.registeredOverlays[window.location.href].length; i++) {            
+      this.removeOverlay(window, this.registeredOverlays[window.location.href][i]);
+    }        
+  };
+
+
+
+
+  this.injectOverlay = function (window, overlay) {
+    if (!window.hasOwnProperty("injectedOverlays")) window.injectedOverlays = [];
+
+    if (window.injectedOverlays.includes(overlay)) {
+      if (this.options.verbose>2) Services.console.logStringMessage("[OverlayManager] NOT Injecting: " + overlay);
+      return false;
+    }            
+
+    let rootNode = this.overlays[overlay];
+
+    if (rootNode) {
+      let overlayNode = rootNode.documentElement;
+      if (overlayNode) {
+        //get and load scripts
+        let scripts = this.getScripts(rootNode, overlayNode);
+        for (let i=0; i < scripts.length; i++){
+          if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Loading: " + scripts[i]);
+          try {
+            Services.scriptloader.loadSubScript(scripts[i], window);
+          } catch (e) {
+            Components.utils.reportError(e);          
+          }
+        }
+        
+        let omscopename = overlayNode.hasAttribute("omscope") ? overlayNode.getAttribute("omscope") : null;
+        let omscope = omscopename ? window[omscopename] : window;
+
+        let inject = true;
+        if (omscope.hasOwnProperty("onBeforeInject")) {
+          if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Executing " + (omscopename ? omscopename : "window") + ".onBeforeInject()");
+          try {
+            inject = omscope.onBeforeInject(window);
+          } catch (e) {
+            Components.utils.reportError(e);          
+          }
+        }
+
+        if (inject) {
+          if (this.options.verbose>2) Services.console.logStringMessage("[OverlayManager] Injecting: " + overlay);
+          window.injectedOverlays.push(overlay);
+          
+          //get urls of stylesheets to add preloaded files
+          let styleSheetUrls = this.getStyleSheetUrls(rootNode);
+          for (let i=0; i<styleSheetUrls.length; i++) {
+            let namespace = overlayNode.lookupNamespaceURI("html");
+            let element = window.document.createElementNS(namespace, "style");
+            element.id = styleSheetUrls[i];
+            element.textContent = this.stylesheets[styleSheetUrls[i]];
+            window.document.documentElement.appendChild(element);
+            if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Stylesheet: " + styleSheetUrls[i]);
+          }                        
+
+          this.insertXulOverlay(window, overlayNode.children);
+          if (omscope.hasOwnProperty("onInject")) {
+            if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Executing " + (omscopename ? omscopename : "window") + ".onInject()");
+            try {
+              omscope.onInject(window);
+            } catch (e) {
+              Components.utils.reportError(e);          
+            }
+          }
+          
+          // add to injectCounter
+          return true;
+        }
+      }
+    }
+
+    // nothing injected, do not add to inject counter
+    return false;
+  };
+
+  this.removeOverlay = function (window, overlay) {
+    if (!window.hasOwnProperty("injectedOverlays")) window.injectedOverlays = [];
+
+    if (!window.injectedOverlays.includes(overlay)) {
+      if (this.options.verbose>2) Services.console.logStringMessage("[OverlayManager] NOT Removing: " + overlay);
+      return;
+    }
+
+    if (this.options.verbose>2) Services.console.logStringMessage("[OverlayManager] Removing: " + overlay);
+    window.injectedOverlays = window.injectedOverlays.filter(e => (e != overlay));
+    
+    let rootNode = this.overlays[overlay];
+    if (rootNode) {
+      let overlayNode = rootNode.documentElement;
+      if (overlayNode) {
+        let omscopename = overlayNode.hasAttribute("omscope") ? overlayNode.getAttribute("omscope") : null;
+        let omscope = omscopename ? window[omscopename] : window;
+        
+        if (omscope.hasOwnProperty("onRemove")) {
+          if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Executing " + (omscopename ? omscopename : "window") + ".onRemove()");
+          try {
+            omscope.onRemove(window);
+          } catch (e) {
+            Components.utils.reportError(e);          
+          }
+        }
+
+        this.removeXulOverlay(window, overlayNode.children);
+      }
+      
+      //get urls of stylesheets to remove styte tag
+      let styleSheetUrls = this.getStyleSheetUrls(rootNode);
+      for (let i=0; i<styleSheetUrls.length; i++) {
+        let element = window.document.getElementById(styleSheetUrls[i]);
+        if (element) {
+          element.parentNode.removeChild(element);
+        }
+      }
+    }
+  };
+  
+
+
+
+
+
+
+
+
+
+
+  this.getStyleSheetUrls = function (rootNode) {
+    let sheetsIterator = rootNode.evaluate("processing-instruction('xml-stylesheet')", rootNode, null, 0, null); //PathResult.ANY_TYPE = 0
+    let urls = [];
+    
+    let sheet;
+    while (sheet = sheetsIterator.iterateNext()) { //returns object XMLStylesheetProcessingInstruction]
+      let attr=sheet.data.split(" ");
+      for (let a=0; a < attr.length; a++) {
+        if (attr[a].startsWith("href=")) urls.push(attr[a].substring(6,attr[a].length-1));
+      }
+    }
+    return urls;
+  };
+  
+  this.getScripts = function(rootNode, overlayNode) {
+    let nodeIterator = rootNode.evaluate("./script", overlayNode, null, 0, null); //PathResult.ANY_TYPE = 0
+    let scripts = [];
+
+    let node;
+    while (node = nodeIterator.iterateNext()) {
+      if (node.hasAttribute("src") && node.hasAttribute("type") && node.getAttribute("type").toLowerCase().includes("javascript")) {
+        scripts.push(node.getAttribute("src"));
+      }
+    } 
+    return scripts;
+  };
+
+
+
+
+
+
+
+
+
+
+  this.createXulElement = function (window, node, forcedNodeName = null) {
+    //check for namespace
+    let typedef = forcedNodeName ? forcedNodeName.split(":") : node.nodeName.split(":");
+    if (typedef.length == 2) typedef[0] = node.lookupNamespaceURI(typedef[0]);
+    
+    let CE = {}
+    if (node.attributes && node.attributes.getNamedItem("is")) {
+      for  (let i=0; i <node.attributes.length; i++) {
+        if (node.attributes[i].name == "is") {
+          CE = { "is" : node.attributes[i].value };
+          break;
+        }
+      }
+    }
+
+    let element = (typedef.length==2) ? window.document.createElementNS(typedef[0], typedef[1]) : window.document.createXULElement(typedef[0], CE);
+    if  (node.attributes) {
+      for  (let i=0; i <node.attributes.length; i++) {
+        element.setAttribute(node.attributes[i].name, node.attributes[i].value);
+      }
+    }
+
+    //add text child nodes as textContent
+    if (node.hasChildNodes) {
+      let textContent = "";
+      for (let child of node.childNodes) {
+        if (child.nodeType == "3") {
+          textContent += child.nodeValue;
+        }
+      }
+      if (textContent) element.textContent = textContent
+    }
+
+    return element;
+  };
+
+  this.insertXulOverlay = function (window, nodes, parentElement = null) {
+    /*
+       The passed nodes value could be an entire window.document in a single node (type 9) or a 
+       single element node (type 1) as returned by getElementById. It could however also 
+       be an array of nodes as returned by getElementsByTagName or a nodeList as returned
+       by childNodes. In that case node.length is defined.
+     */
+    let nodeList = [];
+    if (nodes.length === undefined) nodeList.push(nodes);
+    else nodeList = nodes;
+    
+    // nodelist contains all childs
+    for (let node of nodeList) {
+      let element = null;
+      let hookMode = null;
+      let hookName = null;
+      let hookElement = null;
+      
+      if (node.nodeName == "script" && node.hasAttribute("src")) {
+        //skip, since they are handled by getScripts()
+      } else if (node.nodeType == 1) {
+
+        if (!parentElement) { //misleading: if it does not have a parentElement, it is a top level element
+          //Adding top level elements without id is not allowed, because we need to be able to remove them!
+          if (!node.hasAttribute("id")) {
+            if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: A top level <" + node.nodeName+ "> element does not have an ID. Skipped");
+            continue;
+          }
+
+          //check for inline script tags
+          if (node.nodeName == "script") {
+            let element = this.createXulElement(window, node, "html:script"); //force as html:script
+            window.document.documentElement.appendChild(element);
+            continue;                        
+          }
+          
+          //check for inline style
+          if (node.nodeName == "style") {
+            let element = this.createXulElement(window, node, "html:style"); //force as html:style
+            window.document.documentElement.appendChild(element);
+            continue;
+          }
+          
+          if (node.hasAttribute("appendto")) hookMode = "appendto";
+          if (node.hasAttribute("insertbefore")) hookMode ="insertbefore";
+          if (node.hasAttribute("insertafter")) hookMode = "insertafter";
+          
+          if (hookMode) {
+            hookName = node.getAttribute(hookMode);
+            hookElement = window.document.getElementById(hookName);
+          
+            if (!hookElement) {
+              if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: The hook element <"+hookName+"> of top level overlay element <"+ node.nodeName+"> does not exist. Skipped");
+              continue;
+            }
+          } else {
+            hookMode = "appendto";
+            hookName = "ROOT";
+            hookElement = window.document.documentElement;
+          }                    
+        }
+        
+        element = this.createXulElement(window, node);
+        if (node.hasChildNodes) this.insertXulOverlay(window, node.children, element);
+
+        if (parentElement) {
+          // this is a child level XUL element which needs to be added to to its parent
+          parentElement.appendChild(element);
+        } else {
+          // this is a toplevel element, which needs to be added at insertafter or insertbefore
+          switch (hookMode) {
+            case "appendto": 
+              hookElement.appendChild(element);
+              break;
+            case "insertbefore":
+              hookElement.parentNode.insertBefore(element, hookElement);
+              break;
+            case "insertafter":
+              hookElement.parentNode.insertBefore(element, hookElement.nextSibling);
+              break;
+            default:
+              if (this.options.verbose>1) Services.console.logStringMessage("[OverlayManager] BAD XUL: Top level overlay element <"+ node.nodeName+"> uses unknown hook type <"+hookMode+">. Skipped.");
+              continue;
+          }
+          if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Adding <"+element.id+"> ("+element.tagName+")  " + hookMode + " <" + hookName + ">");
+        }                
+      }            
+    }
+  };
+
+  this.removeXulOverlay = function (window, nodes, parentElement = null) {
+    //only scan toplevel elements and remove them
+    let nodeList = [];
+    if (nodes.length === undefined) nodeList.push(nodes);
+    else nodeList = nodes;
+    
+    // nodelist contains all childs
+    for (let node of nodeList) {
+      let element = null;
+      switch(node.nodeType) {
+        case 1: 
+          if (node.hasAttribute("id")) {
+            let element = window.document.getElementById(node.getAttribute("id"));
+            if (element) {
+              element.parentNode.removeChild(element);
+            }
+          } 
+          break;
+      }
+    }
+  };
+
+
+
+
+
+
+
+
+
+
+  //read file from within the XPI package
+  this.readChromeFile = function (aURL) {
+    if (this.options.verbose>3) Services.console.logStringMessage("[OverlayManager] Reading file: " + aURL);
+    return new Promise((resolve, reject) => {
+      let uri = Services.io.newURI(aURL);
+      let channel = Services.io.newChannelFromURI(uri,
+                 null,
+                 Services.scriptSecurityManager.getSystemPrincipal(),
+                 null,
+                 Ci.nsILoadInfo.SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT,
+                 Ci.nsIContentPolicy.TYPE_OTHER);
+
+      NetUtil.asyncFetch(channel, (inputStream, status) => {
+        if (!Components.isSuccessCode(status)) {
+          reject(status);
+          return;
+        }
+
+        try {
+          let data = NetUtil.readInputStreamToString(inputStream, inputStream.available());
+          resolve(data);
+        } catch (ex) {
+          reject(ex);
+        }
+      });
+    });
+  };
+    
+}
diff --git a/content/api/BootstrapLoader/CHANGELOG.md b/content/api/BootstrapLoader/CHANGELOG.md
new file mode 100644
index 0000000..5006ecf
--- /dev/null
+++ b/content/api/BootstrapLoader/CHANGELOG.md
@@ -0,0 +1,75 @@
+Version: 1.21
+-------------
+- Explicitly set hasAddonManagerEventListeners flag to false on uninstall
+
+Version: 1.20
+-------------
+- hard fork BootstrapLoader v1.19 implementation and continue to serve it for
+  Thunderbird 111 and older
+- BootstrapLoader v1.20 has removed a lot of unnecessary code used for backward
+  compatibility
+
+Version: 1.19
+-------------
+- fix race condition which could prevent the AOM tab to be monkey patched correctly
+
+Version: 1.18
+-------------
+- be precise on which revision the wrench symbol should be displayed, instead of
+  the options button
+
+Version: 1.17
+-------------
+- fix "ownerDoc.getElementById() is undefined" bug
+
+Version: 1.16
+-------------
+- fix "tab.browser is undefined" bug
+
+Version 1.15
+------------
+- clear cache only if add-on is uninstalled/updated, not on app shutdown
+
+Version 1.14
+------------
+- fix for TB90 ("view-loaded" event) and TB78.10 (wrench icon for options)
+
+Version 1.13
+------------
+- removed notifyTools and move it into its own NotifyTools API
+
+Version 1.12
+------------
+- add support for notifyExperiment and onNotifyBackground
+
+Version 1.11
+------------
+- add openOptionsDialog()
+
+Version 1.10
+------------
+- fix for 68
+
+Version 1.7
+-----------
+- fix for beta 87
+
+Version 1.6
+-----------
+- add support for options button/menu in add-on manager and fix 68 double menu entry
+
+Version 1.5
+-----------
+- fix for e10s
+
+Version 1.4
+-----------
+- add registerOptionsPage
+
+Version 1.3
+-----------
+- flush cache
+
+Version 1.2
+-----------
+- add support for resource urls
diff --git a/content/api/BootstrapLoader/README.md b/content/api/BootstrapLoader/README.md
new file mode 100644
index 0000000..7e8fe2a
--- /dev/null
+++ b/content/api/BootstrapLoader/README.md
@@ -0,0 +1 @@
+Usage description can be found in the [wiki](https://github.com/thundernest/addon-developer-support/wiki/Using-the-BootstrapLoader-API-to-convert-a-Legacy-Bootstrap-WebExtension-into-a-MailExtension-for-Thunderbird-78).
diff --git a/content/api/BootstrapLoader/implementation.js b/content/api/BootstrapLoader/implementation.js
new file mode 100644
index 0000000..03e6b76
--- /dev/null
+++ b/content/api/BootstrapLoader/implementation.js
@@ -0,0 +1,917 @@
+/*
+ * This file is provided by the addon-developer-support repository at
+ * https://github.com/thundernest/addon-developer-support
+ *
+ * Version: 1.21
+ *
+ * Author: John Bieling (john@thunderbird.net)
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+// Get various parts of the WebExtension framework that we need.
+var { ExtensionCommon } = ChromeUtils.import("resource://gre/modules/ExtensionCommon.jsm");
+var { ExtensionSupport } = ChromeUtils.import("resource:///modules/ExtensionSupport.jsm");
+var { AddonManager } = ChromeUtils.import("resource://gre/modules/AddonManager.jsm");
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+function getThunderbirdVersion() {
+  let parts = Services.appinfo.version.split(".");
+  return {
+    major: parseInt(parts[0]),
+    minor: parseInt(parts[1]),
+    revision: parts.length > 2 ? parseInt(parts[2]) : 0,
+  }
+}
+
+function getMessenger(context) {
+  let apis = ["storage", "runtime", "extension", "i18n"];
+
+  function getStorage() {
+    let localstorage = null;
+    try {
+      localstorage = context.apiCan.findAPIPath("storage");
+      localstorage.local.get = (...args) =>
+        localstorage.local.callMethodInParentProcess("get", args);
+      localstorage.local.set = (...args) =>
+        localstorage.local.callMethodInParentProcess("set", args);
+      localstorage.local.remove = (...args) =>
+        localstorage.local.callMethodInParentProcess("remove", args);
+      localstorage.local.clear = (...args) =>
+        localstorage.local.callMethodInParentProcess("clear", args);
+    } catch (e) {
+      console.info("Storage permission is missing");
+    }
+    return localstorage;
+  }
+
+  let messenger = {};
+  for (let api of apis) {
+    switch (api) {
+      case "storage":
+        XPCOMUtils.defineLazyGetter(messenger, "storage", () =>
+          getStorage()
+        );
+        break;
+
+      default:
+        XPCOMUtils.defineLazyGetter(messenger, api, () =>
+          context.apiCan.findAPIPath(api)
+        );
+    }
+  }
+  return messenger;
+}
+
+var BootstrapLoader_102 = class extends ExtensionCommon.ExtensionAPI {
+  getCards(e) {
+    // This gets triggered by real events but also manually by providing the outer window.
+    // The event is attached to the outer browser, get the inner one.
+    let doc;
+
+    // 78,86, and 87+ need special handholding. *Yeah*.
+    if (getThunderbirdVersion().major < 86) {
+      let ownerDoc = e.document || e.target.ownerDocument;
+      doc = ownerDoc.getElementById("html-view-browser").contentDocument;
+    } else if (getThunderbirdVersion().major < 87) {
+      let ownerDoc = e.document || e.target;
+      doc = ownerDoc.getElementById("html-view-browser").contentDocument;
+    } else {
+      doc = e.document || e.target;
+    }
+    return doc.querySelectorAll("addon-card");
+  }
+
+  // Add pref entry to 68
+  add68PrefsEntry(event) {
+    let id = this.menu_addonPrefs_id + "_" + this.uniqueRandomID;
+
+    // Get the best size of the icon (16px or bigger)
+    let iconSizes = this.extension.manifest.icons
+      ? Object.keys(this.extension.manifest.icons)
+      : [];
+    iconSizes.sort((a, b) => a - b);
+    let bestSize = iconSizes.filter(e => parseInt(e) >= 16).shift();
+    let icon = bestSize ? this.extension.manifest.icons[bestSize] : "";
+
+    let name = this.extension.manifest.name;
+    let entry = icon
+      ? event.target.ownerGlobal.MozXULElement.parseXULToFragment(
+        `<menuitem class="menuitem-iconic" id="${id}" image="${icon}" label="${name}" />`)
+      : event.target.ownerGlobal.MozXULElement.parseXULToFragment(
+        `<menuitem id="${id}" label="${name}" />`);
+
+    event.target.appendChild(entry);
+    let noPrefsElem = event.target.querySelector('[disabled="true"]');
+    // using collapse could be undone by core, so we use display none
+    // noPrefsElem.setAttribute("collapsed", "true");
+    noPrefsElem.style.display = "none";
+    event.target.ownerGlobal.document.getElementById(id).addEventListener("command", this);
+  }
+
+  // Event handler for the addon manager, to update the state of the options button.
+  handleEvent(e) {
+    switch (e.type) {
+      // 68 add-on options menu showing
+      case "popupshowing": {
+        this.add68PrefsEntry(e);
+      }
+        break;
+
+      // 78/88 add-on options menu/button click
+      case "click": {
+        e.preventDefault();
+        e.stopPropagation();
+        let BL = {}
+        BL.extension = this.extension;
+        BL.messenger = getMessenger(this.context);
+        let w = Services.wm.getMostRecentWindow("mail:3pane");
+        w.openDialog(this.pathToOptionsPage, "AddonOptions", "chrome,resizable,centerscreen", BL);
+      }
+        break;
+
+      // 68 add-on options menu command
+      case "command": {
+        let BL = {}
+        BL.extension = this.extension;
+        BL.messenger = getMessenger(this.context);
+        e.target.ownerGlobal.openDialog(this.pathToOptionsPage, "AddonOptions", "chrome,resizable,centerscreen", BL);
+      }
+        break;
+
+      // update, ViewChanged and manual call for add-on manager options overlay
+      default: {
+        let cards = this.getCards(e);
+        for (let card of cards) {
+          // Setup either the options entry in the menu or the button
+          if (card.addon.id == this.extension.id) {
+            let optionsMenu =
+              (getThunderbirdVersion().major > 78 && getThunderbirdVersion().major < 88) ||
+              (getThunderbirdVersion().major == 78 && getThunderbirdVersion().minor < 10) ||
+              (getThunderbirdVersion().major == 78 && getThunderbirdVersion().minor == 10 && getThunderbirdVersion().revision < 2);
+            if (optionsMenu) {
+              // Options menu in 78.0-78.10 and 79-87
+              let addonOptionsLegacyEntry = card.querySelector(".extension-options-legacy");
+              if (card.addon.isActive && !addonOptionsLegacyEntry) {
+                let addonOptionsEntry = card.querySelector("addon-options panel-list panel-item[action='preferences']");
+                addonOptionsLegacyEntry = card.ownerDocument.createElement("panel-item");
+                addonOptionsLegacyEntry.setAttribute("data-l10n-id", "preferences-addon-button");
+                addonOptionsLegacyEntry.classList.add("extension-options-legacy");
+                addonOptionsEntry.parentNode.insertBefore(
+                  addonOptionsLegacyEntry,
+                  addonOptionsEntry
+                );
+                card.querySelector(".extension-options-legacy").addEventListener("click", this);
+              } else if (!card.addon.isActive && addonOptionsLegacyEntry) {
+                addonOptionsLegacyEntry.remove();
+              }
+            } else {
+              // Add-on button in 88
+              let addonOptionsButton = card.querySelector(".extension-options-button2");
+              if (card.addon.isActive && !addonOptionsButton) {
+                addonOptionsButton = card.ownerDocument.createElement("button");
+                addonOptionsButton.classList.add("extension-options-button2");
+                addonOptionsButton.style["min-width"] = "auto";
+                addonOptionsButton.style["min-height"] = "auto";
+                addonOptionsButton.style["width"] = "24px";
+                addonOptionsButton.style["height"] = "24px";
+                addonOptionsButton.style["margin"] = "0";
+                addonOptionsButton.style["margin-inline-start"] = "8px";
+                addonOptionsButton.style["-moz-context-properties"] = "fill";
+                addonOptionsButton.style["fill"] = "currentColor";
+                addonOptionsButton.style["background-image"] = "url('chrome://messenger/skin/icons/developer.svg')";
+                addonOptionsButton.style["background-repeat"] = "no-repeat";
+                addonOptionsButton.style["background-position"] = "center center";
+                addonOptionsButton.style["padding"] = "1px";
+                addonOptionsButton.style["display"] = "flex";
+                addonOptionsButton.style["justify-content"] = "flex-end";
+                card.optionsButton.parentNode.insertBefore(
+                  addonOptionsButton,
+                  card.optionsButton
+                );
+                card.querySelector(".extension-options-button2").addEventListener("click", this);
+              } else if (!card.addon.isActive && addonOptionsButton) {
+                addonOptionsButton.remove();
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Some tab/add-on-manager related functions
+  getTabMail(window) {
+    return window.document.getElementById("tabmail");
+  }
+
+  // returns the outer browser, not the nested browser of the add-on manager
+  // events must be attached to the outer browser
+  getAddonManagerFromTab(tab) {
+    if (tab.browser && tab.mode.name == "contentTab") {
+      let win = tab.browser.contentWindow;
+      if (win && win.location.href == "about:addons") {
+        return win;
+      }
+    }
+  }
+
+  getAddonManagerFromWindow(window) {
+    let tabMail = this.getTabMail(window);
+    for (let tab of tabMail.tabInfo) {
+      let managerWindow = this.getAddonManagerFromTab(tab);
+      if (managerWindow) {
+        return managerWindow;
+      }
+    }
+  }
+
+  async getAddonManagerFromWindowWaitForLoad(window) {
+    let { setTimeout } = Services.wm.getMostRecentWindow("mail:3pane");
+
+    let tabMail = this.getTabMail(window);
+    for (let tab of tabMail.tabInfo) {
+      if (tab.browser && tab.mode.name == "contentTab") {
+        // Instead of registering a load observer, wait until its loaded. Not nice,
+        // but gets aroud a lot of edge cases.
+        while (!tab.pageLoaded) {
+          await new Promise(r => setTimeout(r, 150));
+        }
+        let managerWindow = this.getAddonManagerFromTab(tab);
+        if (managerWindow) {
+          return managerWindow;
+        }
+      }
+    }
+  }
+
+  setupAddonManager(managerWindow, forceLoad = false) {
+    if (!managerWindow) {
+      return;
+    }
+    if (
+      managerWindow &&
+      managerWindow[this.uniqueRandomID] &&
+      managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners
+    ) {
+      return;
+    }
+    managerWindow.document.addEventListener("ViewChanged", this);
+    managerWindow.document.addEventListener("update", this);
+    managerWindow.document.addEventListener("view-loaded", this);
+    managerWindow[this.uniqueRandomID] = {};
+    managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners = true;
+    if (forceLoad) {
+      this.handleEvent(managerWindow);
+    }
+  }
+
+  getAPI(context) {
+    this.uniqueRandomID = "AddOnNS" + context.extension.instanceId;
+    this.menu_addonPrefs_id = "addonPrefs";
+
+
+    this.pathToBootstrapScript = null;
+    this.pathToOptionsPage = null;
+    this.chromeHandle = null;
+    this.chromeData = null;
+    this.resourceData = null;
+    this.bootstrappedObj = {};
+
+    // make the extension object and the messenger object available inside
+    // the bootstrapped scope
+    this.bootstrappedObj.extension = context.extension;
+    this.bootstrappedObj.messenger = getMessenger(this.context);
+
+    this.BOOTSTRAP_REASONS = {
+      APP_STARTUP: 1,
+      APP_SHUTDOWN: 2,
+      ADDON_ENABLE: 3,
+      ADDON_DISABLE: 4,
+      ADDON_INSTALL: 5,
+      ADDON_UNINSTALL: 6, // not supported
+      ADDON_UPGRADE: 7,
+      ADDON_DOWNGRADE: 8,
+    };
+
+    const aomStartup = Cc["@mozilla.org/addons/addon-manager-startup;1"].getService(Ci.amIAddonManagerStartup);
+    const resProto = Cc["@mozilla.org/network/protocol;1?name=resource"].getService(Ci.nsISubstitutingProtocolHandler);
+
+    let self = this;
+
+    // TabMonitor to detect opening of tabs, to setup the options button in the add-on manager.
+    this.tabMonitor = {
+      onTabTitleChanged(tab) { },
+      onTabClosing(tab) { },
+      onTabPersist(tab) { },
+      onTabRestored(tab) { },
+      onTabSwitched(aNewTab, aOldTab) { },
+      async onTabOpened(tab) {
+        if (tab.browser && tab.mode.name == "contentTab") {
+          let { setTimeout } = Services.wm.getMostRecentWindow("mail:3pane");
+          // Instead of registering a load observer, wait until its loaded. Not nice,
+          // but gets aroud a lot of edge cases.
+          while (!tab.pageLoaded) {
+            await new Promise(r => setTimeout(r, 150));
+          }
+          self.setupAddonManager(self.getAddonManagerFromTab(tab));
+        }
+      },
+    };
+
+    return {
+      BootstrapLoader: {
+
+        registerOptionsPage(optionsUrl) {
+          self.pathToOptionsPage = optionsUrl.startsWith("chrome://")
+            ? optionsUrl
+            : context.extension.rootURI.resolve(optionsUrl);
+        },
+
+        openOptionsDialog(windowId) {
+          let window = context.extension.windowManager.get(windowId, context).window
+          let BL = {}
+          BL.extension = self.extension;
+          BL.messenger = getMessenger(self.context);
+          window.openDialog(self.pathToOptionsPage, "AddonOptions", "chrome,resizable,centerscreen", BL);
+        },
+
+        registerChromeUrl(data) {
+          let chromeData = [];
+          let resourceData = [];
+          for (let entry of data) {
+            if (entry[0] == "resource") resourceData.push(entry);
+            else chromeData.push(entry)
+          }
+
+          if (chromeData.length > 0) {
+            const manifestURI = Services.io.newURI(
+              "manifest.json",
+              null,
+              context.extension.rootURI
+            );
+            self.chromeHandle = aomStartup.registerChrome(manifestURI, chromeData);
+          }
+
+          for (let res of resourceData) {
+            // [ "resource", "shortname" , "path" ]
+            let uri = Services.io.newURI(
+              res[2],
+              null,
+              context.extension.rootURI
+            );
+            resProto.setSubstitutionWithFlags(
+              res[1],
+              uri,
+              resProto.ALLOW_CONTENT_ACCESS
+            );
+          }
+
+          self.chromeData = chromeData;
+          self.resourceData = resourceData;
+        },
+
+        registerBootstrapScript: async function (aPath) {
+          self.pathToBootstrapScript = aPath.startsWith("chrome://")
+            ? aPath
+            : context.extension.rootURI.resolve(aPath);
+
+          // Get the addon object belonging to this extension.
+          let addon = await AddonManager.getAddonByID(context.extension.id);
+          //make the addon globally available in the bootstrapped scope
+          self.bootstrappedObj.addon = addon;
+
+          // add BOOTSTRAP_REASONS to scope
+          for (let reason of Object.keys(self.BOOTSTRAP_REASONS)) {
+            self.bootstrappedObj[reason] = self.BOOTSTRAP_REASONS[reason];
+          }
+
+          // Load registered bootstrap scripts and execute its startup() function.
+          try {
+            if (self.pathToBootstrapScript) Services.scriptloader.loadSubScript(self.pathToBootstrapScript, self.bootstrappedObj, "UTF-8");
+            if (self.bootstrappedObj.startup) self.bootstrappedObj.startup.call(self.bootstrappedObj, self.extension.addonData, self.BOOTSTRAP_REASONS[self.extension.startupReason]);
+          } catch (e) {
+            Components.utils.reportError(e)
+          }
+
+          // Register window listener for main TB window
+          if (self.pathToOptionsPage) {
+            ExtensionSupport.registerWindowListener("injectListener_" + self.uniqueRandomID, {
+              chromeURLs: [
+                "chrome://messenger/content/messenger.xul",
+                "chrome://messenger/content/messenger.xhtml",
+              ],
+              async onLoadWindow(window) {
+                if (getThunderbirdVersion().major < 78) {
+                  let element_addonPrefs = window.document.getElementById(self.menu_addonPrefs_id);
+                  element_addonPrefs.addEventListener("popupshowing", self);
+                } else {
+                  // Add a tabmonitor, to be able to setup the options button/menu in the add-on manager.
+                  self.getTabMail(window).registerTabMonitor(self.tabMonitor);
+                  window[self.uniqueRandomID] = {};
+                  window[self.uniqueRandomID].hasTabMonitor = true;
+                  // Setup the options button/menu in the add-on manager, if it is already open.
+                  let managerWindow = await self.getAddonManagerFromWindowWaitForLoad(window);
+                  self.setupAddonManager(managerWindow, true);
+                }
+              },
+
+              onUnloadWindow(window) {
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+
+  onShutdown(isAppShutdown) {
+    if (isAppShutdown) {
+      return; // the application gets unloaded anyway
+    }
+
+    //remove our entry in the add-on options menu
+    if (this.pathToOptionsPage) {
+      for (let window of Services.wm.getEnumerator("mail:3pane")) {
+        if (getThunderbirdVersion().major < 78) {
+          let element_addonPrefs = window.document.getElementById(this.menu_addonPrefs_id);
+          element_addonPrefs.removeEventListener("popupshowing", this);
+          // Remove our entry.
+          let entry = window.document.getElementById(this.menu_addonPrefs_id + "_" + this.uniqueRandomID);
+          if (entry) entry.remove();
+          // Do we have to unhide the noPrefsElement?
+          if (element_addonPrefs.children.length == 1) {
+            let noPrefsElem = element_addonPrefs.querySelector('[disabled="true"]');
+            noPrefsElem.style.display = "inline";
+          }
+        } else {
+          // Remove event listener for addon manager view changes
+          let managerWindow = this.getAddonManagerFromWindow(window);
+          if (
+            managerWindow && 
+            managerWindow[this.uniqueRandomID] && 
+            managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners
+          ) {
+            managerWindow.document.removeEventListener("ViewChanged", this);
+            managerWindow.document.removeEventListener("update", this);
+            managerWindow.document.removeEventListener("view-loaded", this);
+            managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners = false;
+
+            let cards = this.getCards(managerWindow);
+            if (getThunderbirdVersion().major < 88) {
+              // Remove options menu in 78-87
+              for (let card of cards) {
+                let addonOptionsLegacyEntry = card.querySelector(".extension-options-legacy");
+                if (addonOptionsLegacyEntry) addonOptionsLegacyEntry.remove();
+              }
+            } else {
+              // Remove options button in 88
+              for (let card of cards) {
+                if (card.addon.id == this.extension.id) {
+                  let addonOptionsButton = card.querySelector(".extension-options-button2");
+                  if (addonOptionsButton) addonOptionsButton.remove();
+                  break;
+                }
+              }
+            }
+          }
+
+          // Remove tabmonitor
+          if (window[this.uniqueRandomID].hasTabMonitor) {
+            this.getTabMail(window).unregisterTabMonitor(this.tabMonitor);
+            window[this.uniqueRandomID].hasTabMonitor = false;
+          }
+
+        }
+      }
+      // Stop listening for new windows.
+      ExtensionSupport.unregisterWindowListener("injectListener_" + this.uniqueRandomID);
+    }
+
+    // Execute registered shutdown()
+    try {
+      if (this.bootstrappedObj.shutdown) {
+        this.bootstrappedObj.shutdown(
+          this.extension.addonData,
+          isAppShutdown
+            ? this.BOOTSTRAP_REASONS.APP_SHUTDOWN
+            : this.BOOTSTRAP_REASONS.ADDON_DISABLE);
+      }
+    } catch (e) {
+      Components.utils.reportError(e)
+    }
+
+    if (this.resourceData) {
+      const resProto = Cc["@mozilla.org/network/protocol;1?name=resource"].getService(Ci.nsISubstitutingProtocolHandler);
+      for (let res of this.resourceData) {
+        // [ "resource", "shortname" , "path" ]
+        resProto.setSubstitution(
+          res[1],
+          null,
+        );
+      }
+    }
+
+    if (this.chromeHandle) {
+      this.chromeHandle.destruct();
+      this.chromeHandle = null;
+    }
+    // Flush all caches
+    Services.obs.notifyObservers(null, "startupcache-invalidate");
+    console.log("BootstrapLoader for " + this.extension.id + " unloaded!");
+  }
+};
+
+// Removed all extra code for backward compatibility for better maintainability.
+var BootstrapLoader_115 = class extends ExtensionCommon.ExtensionAPI {
+  getCards(e) {
+    // This gets triggered by real events but also manually by providing the outer window.
+    // The event is attached to the outer browser, get the inner one.
+    let doc = e.document || e.target;
+    return doc.querySelectorAll("addon-card");
+  }
+
+  // Event handler for the addon manager, to update the state of the options button.
+  handleEvent(e) {
+    switch (e.type) {
+      case "click": {
+        e.preventDefault();
+        e.stopPropagation();
+        let BL = {}
+        BL.extension = this.extension;
+        BL.messenger = getMessenger(this.context);
+        let w = Services.wm.getMostRecentWindow("mail:3pane");
+        w.openDialog(
+          this.pathToOptionsPage,
+          "AddonOptions",
+          "chrome,resizable,centerscreen",
+          BL
+        );
+      }
+        break;
+
+
+      // update, ViewChanged and manual call for add-on manager options overlay
+      default: {
+        let cards = this.getCards(e);
+        for (let card of cards) {
+          // Setup either the options entry in the menu or the button
+          if (card.addon.id == this.extension.id) {
+            // Add-on button
+            let addonOptionsButton = card.querySelector(
+              ".windowlistener-options-button"
+            );
+            if (card.addon.isActive && !addonOptionsButton) {
+              let origAddonOptionsButton = card.querySelector(".extension-options-button")
+              origAddonOptionsButton.setAttribute("hidden", "true");
+
+              addonOptionsButton = card.ownerDocument.createElement("button");
+              addonOptionsButton.classList.add("windowlistener-options-button");
+              addonOptionsButton.classList.add("extension-options-button");
+              card.optionsButton.parentNode.insertBefore(
+                addonOptionsButton,
+                card.optionsButton
+              );
+              card
+                .querySelector(".windowlistener-options-button")
+                .addEventListener("click", this);
+            } else if (!card.addon.isActive && addonOptionsButton) {
+              addonOptionsButton.remove();
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Some tab/add-on-manager related functions
+  getTabMail(window) {
+    return window.document.getElementById("tabmail");
+  }
+
+  // returns the outer browser, not the nested browser of the add-on manager
+  // events must be attached to the outer browser
+  getAddonManagerFromTab(tab) {
+    if (tab.browser && tab.mode.name == "contentTab") {
+      let win = tab.browser.contentWindow;
+      if (win && win.location.href == "about:addons") {
+        return win;
+      }
+    }
+  }
+
+  getAddonManagerFromWindow(window) {
+    let tabMail = this.getTabMail(window);
+    for (let tab of tabMail.tabInfo) {
+      let managerWindow = this.getAddonManagerFromTab(tab);
+      if (managerWindow) {
+        return managerWindow;
+      }
+    }
+  }
+
+  async getAddonManagerFromWindowWaitForLoad(window) {
+    let { setTimeout } = Services.wm.getMostRecentWindow("mail:3pane");
+
+    let tabMail = this.getTabMail(window);
+    for (let tab of tabMail.tabInfo) {
+      if (tab.browser && tab.mode.name == "contentTab") {
+        // Instead of registering a load observer, wait until its loaded. Not nice,
+        // but gets aroud a lot of edge cases.
+        while (!tab.pageLoaded) {
+          await new Promise(r => setTimeout(r, 150));
+        }
+        let managerWindow = this.getAddonManagerFromTab(tab);
+        if (managerWindow) {
+          return managerWindow;
+        }
+      }
+    }
+  }
+
+  setupAddonManager(managerWindow, forceLoad = false) {
+    if (!managerWindow) {
+      return;
+    }
+    if (!this.pathToOptionsPage) {
+      return;
+    }
+    if (
+      managerWindow &&
+      managerWindow[this.uniqueRandomID] &&
+      managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners
+    ) {
+      return;
+    }
+    
+    managerWindow.document.addEventListener("ViewChanged", this);
+    managerWindow.document.addEventListener("update", this);
+    managerWindow.document.addEventListener("view-loaded", this);
+    managerWindow[this.uniqueRandomID] = {};
+    managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners = true;
+    if (forceLoad) {
+      this.handleEvent(managerWindow);
+    }
+  }
+
+  getAPI(context) {
+    this.uniqueRandomID = "AddOnNS" + context.extension.instanceId;
+    this.menu_addonPrefs_id = "addonPrefs";
+
+
+    this.pathToBootstrapScript = null;
+    this.pathToOptionsPage = null;
+    this.chromeHandle = null;
+    this.chromeData = null;
+    this.resourceData = null;
+    this.bootstrappedObj = {};
+
+    // make the extension object and the messenger object available inside
+    // the bootstrapped scope
+    this.bootstrappedObj.extension = context.extension;
+    this.bootstrappedObj.messenger = getMessenger(this.context);
+
+    this.BOOTSTRAP_REASONS = {
+      APP_STARTUP: 1,
+      APP_SHUTDOWN: 2,
+      ADDON_ENABLE: 3,
+      ADDON_DISABLE: 4,
+      ADDON_INSTALL: 5,
+      ADDON_UNINSTALL: 6, // not supported
+      ADDON_UPGRADE: 7,
+      ADDON_DOWNGRADE: 8,
+    };
+
+    const aomStartup = Cc["@mozilla.org/addons/addon-manager-startup;1"].getService(Ci.amIAddonManagerStartup);
+    const resProto = Cc["@mozilla.org/network/protocol;1?name=resource"].getService(Ci.nsISubstitutingProtocolHandler);
+
+    let self = this;
+
+    // TabMonitor to detect opening of tabs, to setup the options button in the add-on manager.
+    this.tabMonitor = {
+      onTabTitleChanged(tab) { },
+      onTabClosing(tab) { },
+      onTabPersist(tab) { },
+      onTabRestored(tab) { },
+      onTabSwitched(aNewTab, aOldTab) { },
+      async onTabOpened(tab) {
+        if (tab.browser && tab.mode.name == "contentTab") {
+          let { setTimeout } = Services.wm.getMostRecentWindow("mail:3pane");
+          // Instead of registering a load observer, wait until its loaded. Not nice,
+          // but gets aroud a lot of edge cases.
+          while (!tab.pageLoaded) {
+            await new Promise(r => setTimeout(r, 150));
+          }
+          self.setupAddonManager(self.getAddonManagerFromTab(tab));
+        }
+      },
+    };
+
+    return {
+      BootstrapLoader: {
+
+        registerOptionsPage(optionsUrl) {
+          self.pathToOptionsPage = optionsUrl.startsWith("chrome://")
+            ? optionsUrl
+            : context.extension.rootURI.resolve(optionsUrl);
+        },
+
+        openOptionsDialog(windowId) {
+          let window = context.extension.windowManager.get(windowId, context).window
+          let BL = {}
+          BL.extension = self.extension;
+          BL.messenger = getMessenger(self.context);
+          window.openDialog(self.pathToOptionsPage, "AddonOptions", "chrome,resizable,centerscreen", BL);
+        },
+
+        registerChromeUrl(data) {
+          let chromeData = [];
+          let resourceData = [];
+          for (let entry of data) {
+            if (entry[0] == "resource") resourceData.push(entry);
+            else chromeData.push(entry)
+          }
+
+          if (chromeData.length > 0) {
+            const manifestURI = Services.io.newURI(
+              "manifest.json",
+              null,
+              context.extension.rootURI
+            );
+            self.chromeHandle = aomStartup.registerChrome(manifestURI, chromeData);
+          }
+
+          for (let res of resourceData) {
+            // [ "resource", "shortname" , "path" ]
+            let uri = Services.io.newURI(
+              res[2],
+              null,
+              context.extension.rootURI
+            );
+            resProto.setSubstitutionWithFlags(
+              res[1],
+              uri,
+              resProto.ALLOW_CONTENT_ACCESS
+            );
+          }
+
+          self.chromeData = chromeData;
+          self.resourceData = resourceData;
+        },
+
+        registerBootstrapScript: async function (aPath) {
+          self.pathToBootstrapScript = aPath.startsWith("chrome://")
+            ? aPath
+            : context.extension.rootURI.resolve(aPath);
+
+          // Get the addon object belonging to this extension.
+          let addon = await AddonManager.getAddonByID(context.extension.id);
+          //make the addon globally available in the bootstrapped scope
+          self.bootstrappedObj.addon = addon;
+
+          // add BOOTSTRAP_REASONS to scope
+          for (let reason of Object.keys(self.BOOTSTRAP_REASONS)) {
+            self.bootstrappedObj[reason] = self.BOOTSTRAP_REASONS[reason];
+          }
+
+          // Load registered bootstrap scripts and execute its startup() function.
+          try {
+            if (self.pathToBootstrapScript) Services.scriptloader.loadSubScript(self.pathToBootstrapScript, self.bootstrappedObj, "UTF-8");
+            if (self.bootstrappedObj.startup) self.bootstrappedObj.startup.call(self.bootstrappedObj, self.extension.addonData, self.BOOTSTRAP_REASONS[self.extension.startupReason]);
+          } catch (e) {
+            Components.utils.reportError(e)
+          }
+
+          // Register window listener for main TB window
+          if (self.pathToOptionsPage) {
+            ExtensionSupport.registerWindowListener("injectListener_" + self.uniqueRandomID, {
+              chromeURLs: [
+                "chrome://messenger/content/messenger.xul",
+                "chrome://messenger/content/messenger.xhtml",
+              ],
+              async onLoadWindow(window) {
+                if (getThunderbirdVersion().major < 78) {
+                  let element_addonPrefs = window.document.getElementById(self.menu_addonPrefs_id);
+                  element_addonPrefs.addEventListener("popupshowing", self);
+                } else {
+                  // Add a tabmonitor, to be able to setup the options button/menu in the add-on manager.
+                  self.getTabMail(window).registerTabMonitor(self.tabMonitor);
+                  window[self.uniqueRandomID] = {};
+                  window[self.uniqueRandomID].hasTabMonitor = true;
+                  // Setup the options button/menu in the add-on manager, if it is already open.
+                  let managerWindow = await self.getAddonManagerFromWindowWaitForLoad(window);
+                  self.setupAddonManager(managerWindow, true);
+                }
+              },
+
+              onUnloadWindow(window) {
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+
+  onShutdown(isAppShutdown) {
+    if (isAppShutdown) {
+      return; // the application gets unloaded anyway
+    }
+
+    //remove our entry in the add-on options menu
+    if (this.pathToOptionsPage) {
+      for (let window of Services.wm.getEnumerator("mail:3pane")) {
+        if (getThunderbirdVersion().major < 78) {
+          let element_addonPrefs = window.document.getElementById(this.menu_addonPrefs_id);
+          element_addonPrefs.removeEventListener("popupshowing", this);
+          // Remove our entry.
+          let entry = window.document.getElementById(this.menu_addonPrefs_id + "_" + this.uniqueRandomID);
+          if (entry) entry.remove();
+          // Do we have to unhide the noPrefsElement?
+          if (element_addonPrefs.children.length == 1) {
+            let noPrefsElem = element_addonPrefs.querySelector('[disabled="true"]');
+            noPrefsElem.style.display = "inline";
+          }
+        } else {
+          // Remove event listener for addon manager view changes
+          let managerWindow = this.getAddonManagerFromWindow(window);
+          if (
+            managerWindow && 
+            managerWindow[this.uniqueRandomID] && 
+            managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners
+          ) {
+            managerWindow.document.removeEventListener("ViewChanged", this);
+            managerWindow.document.removeEventListener("update", this);
+            managerWindow.document.removeEventListener("view-loaded", this);
+            managerWindow[this.uniqueRandomID].hasAddonManagerEventListeners = false;
+
+            let cards = this.getCards(managerWindow);
+            if (getThunderbirdVersion().major < 88) {
+              // Remove options menu in 78-87
+              for (let card of cards) {
+                let addonOptionsLegacyEntry = card.querySelector(".extension-options-legacy");
+                if (addonOptionsLegacyEntry) addonOptionsLegacyEntry.remove();
+              }
+            } else {
+              // Remove options button in 88
+              for (let card of cards) {
+                if (card.addon.id == this.extension.id) {
+                  let addonOptionsButton = card.querySelector(".extension-options-button2");
+                  if (addonOptionsButton) addonOptionsButton.remove();
+                  break;
+                }
+              }
+            }
+          }
+
+          // Remove tabmonitor
+          if (window[this.uniqueRandomID].hasTabMonitor) {
+            this.getTabMail(window).unregisterTabMonitor(this.tabMonitor);
+            window[this.uniqueRandomID].hasTabMonitor = false;
+          }
+
+        }
+      }
+      // Stop listening for new windows.
+      ExtensionSupport.unregisterWindowListener("injectListener_" + this.uniqueRandomID);
+    }
+
+    // Execute registered shutdown()
+    try {
+      if (this.bootstrappedObj.shutdown) {
+        this.bootstrappedObj.shutdown(
+          this.extension.addonData,
+          isAppShutdown
+            ? this.BOOTSTRAP_REASONS.APP_SHUTDOWN
+            : this.BOOTSTRAP_REASONS.ADDON_DISABLE);
+      }
+    } catch (e) {
+      Components.utils.reportError(e)
+    }
+
+    if (this.resourceData) {
+      const resProto = Cc["@mozilla.org/network/protocol;1?name=resource"].getService(Ci.nsISubstitutingProtocolHandler);
+      for (let res of this.resourceData) {
+        // [ "resource", "shortname" , "path" ]
+        resProto.setSubstitution(
+          res[1],
+          null,
+        );
+      }
+    }
+
+    if (this.chromeHandle) {
+      this.chromeHandle.destruct();
+      this.chromeHandle = null;
+    }
+    // Flush all caches
+    Services.obs.notifyObservers(null, "startupcache-invalidate");
+    console.log("BootstrapLoader for " + this.extension.id + " unloaded!");
+  }
+};
+
+var BootstrapLoader = getThunderbirdVersion().major < 111
+  ? BootstrapLoader_102
+  : BootstrapLoader_115;
diff --git a/content/api/BootstrapLoader/schema.json b/content/api/BootstrapLoader/schema.json
new file mode 100644
index 0000000..fe48fb6
--- /dev/null
+++ b/content/api/BootstrapLoader/schema.json
@@ -0,0 +1,61 @@
+[
+  {
+    "namespace": "BootstrapLoader",
+    "functions": [
+      {
+        "name": "registerOptionsPage",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "aPath",
+            "type": "string",
+            "description": "Path to the options page, which should be made accessible in the (legacy) Add-On Options menu."
+          }
+        ]
+      },
+      {
+        "name": "openOptionsDialog",
+        "type": "function",
+        "parameters": [
+          {
+            "name": "windowId",
+            "type": "integer",
+            "description": "Id of the window the dialog should be opened from."
+          }
+        ]
+      },
+      {
+        "name": "registerChromeUrl",
+        "type": "function",
+        "description": "Register folders which should be available as chrome:// urls (as defined in the legacy chrome.manifest)",
+        "async": true,
+        "parameters": [
+          {
+            "name": "chromeData",
+            "type": "array",
+            "items": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "description": "Array of ChromeData Arrays."
+          }
+        ]
+      },
+      {
+        "name": "registerBootstrapScript",
+        "type": "function",
+        "description": "Register a bootstrap.js style script",
+        "async": true,
+        "parameters": [
+          {
+            "name": "aPath",
+            "type": "string",
+            "description": "Either the chrome:// path to the script or its relative location from the root of the extension,"
+          }
+        ]
+      }
+    ]
+  }
+]
\ No newline at end of file
diff --git a/content/manager/accountManager.js b/content/manager/accountManager.js
new file mode 100644
index 0000000..d442222
--- /dev/null
+++ b/content/manager/accountManager.js
@@ -0,0 +1,140 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+var tbSyncAccountManager = {
+  
+  onloadoptions: function () {
+    window.close();
+  },    
+  
+  onunloadoptions: function () {
+    TbSync.manager.openManagerWindow(0);
+  },
+  
+  onload: function () {
+    TbSync.AccountManagerTabs = ["accounts.xhtml", "catman.xhtml", "supporter.xhtml", "help.xhtml"];
+    tbSyncAccountManager.selectTab(0);
+  },
+  
+  onunload: function () {
+    TbSync.manager.prefWindowObj = null;
+  },
+
+  selectTab: function (t) {
+    const LOAD_FLAGS_NONE = Components.interfaces.nsIWebNavigation.LOAD_FLAGS_NONE;
+
+    //set active tab (css selector for background color)
+    for (let i=0; i<TbSync.AccountManagerTabs.length; i++) {            
+      if (i==t) document.getElementById("tbSyncAccountManager.t" + i).setAttribute("active","true");
+      else document.getElementById("tbSyncAccountManager.t" + i).setAttribute("active","false");
+    }
+    TbSync.manager.prefWindowObj.document.getElementById("tbSyncAccountManager.installProvider").hidden=true;
+    
+    //load XUL
+    document.getElementById("tbSyncAccountManager.contentWindow").setAttribute("src", "chrome://tbsync/content/manager/"+TbSync.AccountManagerTabs[t]);
+  },
+  
+  
+  
+  //help tab
+  getLogPref: function() {
+    let log = document.getElementById("tbSyncAccountManager.logLevel");
+    log.value = Math.min(3, TbSync.prefs.getIntPref("log.userdatalevel"));
+  },
+  
+  toggleLogPref: function() {
+    let log = document.getElementById("tbSyncAccountManager.logLevel");
+    TbSync.prefs.setIntPref("log.userdatalevel", log.value);
+  },
+  
+  initSupportWizard: function() {
+    document.getElementById("SupportWizard").getButton("finish").disabled = true;
+
+    let menu = document.getElementById("tbsync.supportwizard.faultycomponent");
+
+    let providers = Object.keys(TbSync.providers.loadedProviders);
+    for (let i=0; i < providers.length; i++) {
+      let item = document.createXULElement("menuitem");
+      item.setAttribute("value", providers[i]);
+      item.setAttribute("label", TbSync.getString("supportwizard.provider::" + TbSync.providers[providers[i]].Base.getProviderName()));
+      menu.appendChild(item); 
+    }
+  
+    document.getElementById("tbsync.supportwizard.faultycomponent.menulist").addEventListener("select", tbSyncAccountManager.checkSupportWizard);
+    document.getElementById("tbsync.supportwizard.description").addEventListener("input", tbSyncAccountManager.checkSupportWizard);
+    document.addEventListener("wizardfinish", tbSyncAccountManager.prepareBugReport);
+
+    // bug https://bugzilla.mozilla.org/show_bug.cgi?id=1618252
+    document.getElementById('SupportWizard')._adjustWizardHeader();
+  },
+  
+  checkSupportWizard: function() {
+    let provider = document.getElementById("tbsync.supportwizard.faultycomponent").parentNode.value;
+    let subject = document.getElementById("tbsync.supportwizard.summary").value;
+    let description = document.getElementById("tbsync.supportwizard.description").value;
+
+    //just check and update button status
+    document.getElementById("SupportWizard").getButton("finish").disabled = (provider == "" || subject == "" || description== "");        
+  },
+
+  prepareBugReport: function(event) {
+    let provider = document.getElementById("tbsync.supportwizard.faultycomponent").parentNode.value;
+    let subject = document.getElementById("tbsync.supportwizard.summary").value;
+    let description = document.getElementById("tbsync.supportwizard.description").value;
+
+    if (provider == "" || subject == "" || description== "") {
+      event.preventDefault();
+      return;
+    }
+
+    //special if core is selected, which is not a provider
+    let email = (TbSync.providers.loadedProviders.hasOwnProperty(provider)) ? TbSync.providers[provider].Base.getMaintainerEmail() : "john.bieling@gmx.de";
+    let version = (TbSync.providers.loadedProviders.hasOwnProperty(provider)) ? " " + TbSync.providers.loadedProviders[provider].version : "";
+    TbSync.manager.createBugReport(email, "[" + provider.toUpperCase() + version + "] " + subject, description);
+  },
+  
+  
+  
+  //community tab
+  initCommunity: function() {
+    let listOfContributors = document.getElementById("listOfContributors");
+    let sponsors = {};
+      
+    let providers = Object.keys(TbSync.providers.loadedProviders);
+    for (let i=0; i < providers.length; i++) {
+      let provider = providers[i];
+      let template = listOfContributors.firstElementChild.cloneNode(true);
+      template.setAttribute("provider", provider);
+      template.children[0].setAttribute("src", TbSync.providers[provider].Base.getProviderIcon(48));
+      template.children[1].children[0].textContent = TbSync.providers[provider].Base.getProviderName();
+      listOfContributors.appendChild(template);
+      Object.assign(sponsors, TbSync.providers[provider].Base.getSponsors());
+    }
+    listOfContributors.removeChild(listOfContributors.firstElementChild);
+
+    let listOfSponsors = document.getElementById("listOfSponsors");
+    let sponsorlist = Object.keys(sponsors);
+    sponsorlist.sort();
+    for (let i=0; i < sponsorlist.length; i++) {
+      let sponsor = sponsors[sponsorlist[i]];
+      let template = listOfSponsors.firstElementChild.cloneNode(true);
+      if (sponsor.link) template.setAttribute("link", sponsor.link);
+      if (sponsor.icon) template.children[0].setAttribute("src", sponsor.icon);
+      template.children[1].children[0].textContent = sponsor.name;
+      template.children[1].children[1].textContent = sponsor.description;
+      listOfSponsors.appendChild(template);
+      listOfSponsors.appendChild(template);
+    }
+    listOfSponsors.removeChild(listOfSponsors.firstElementChild);
+  }        
+};
diff --git a/content/manager/accountManager.xhtml b/content/manager/accountManager.xhtml
new file mode 100644
index 0000000..d136240
--- /dev/null
+++ b/content/manager/accountManager.xhtml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    title="__TBSYNCMSG_manager.title__" 
+    onload="tbSyncAccountManager.onload();"
+    onunload="tbSyncAccountManager.onunload();"
+    width="760" height="620" >
+        
+    <vbox id="manager" flex="1">
+        <hbox id="tbtoolbar">
+            <vbox id="tbSyncAccountManager.t0" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="tbSyncAccountManager.selectTab(0)"><hbox flex="1" pack="center" style="min-width:60px"><image src="chrome://tbsync/content/skin/settings32.png" style="width: 32px; height: 32px" /></hbox><hbox flex="1"  pack="center"><label value="__TBSYNCMSG_manager.accountsettings__" /></hbox></vbox>
+            <vbox id="tbSyncAccountManager.t1" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="tbSyncAccountManager.selectTab(1)"><hbox flex="1" pack="center" style="min-width:60px"><image src="chrome://tbsync/content/skin/catman32.png" style="width: 32px; height: 32px" /></hbox><hbox flex="1"  pack="center"><label value="Category Manager" /></hbox></vbox>
+            <vbox id="tbSyncAccountManager.t2" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="tbSyncAccountManager.selectTab(2)"><hbox flex="1" pack="center" style="min-width:60px"><image src="chrome://tbsync/content/skin/group32.png" style="width: 32px; height: 32px" /></hbox><hbox flex="1"  pack="center"><label value="__TBSYNCMSG_manager.community__" /></hbox></vbox>
+            <vbox id="tbSyncAccountManager.t3" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="tbSyncAccountManager.selectTab(3)"><hbox flex="1" pack="center" style="min-width:60px"><image src="chrome://tbsync/content/skin/help32.png" style="width: 32px; height: 32px" /></hbox><hbox flex="1"  pack="center"><label value="__TBSYNCMSG_manager.help__" /></hbox></vbox>
+            <vbox id="tbSyncAccountManager.installProvider" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'"  hidden="true"><hbox flex="1" pack="center" style="min-width:60px"><image src="chrome://tbsync/content/skin/provider32.png" style="width: 32px; height: 32px" /></hbox><hbox flex="1"  pack="center"><label value="__TBSYNCMSG_manager.provider__" /></hbox></vbox>
+        </hbox>
+        <browser id="tbSyncAccountManager.contentWindow" type="chrome" src="" disablehistory="true" flex="1"/>
+    </vbox>
+    
+    <script type="text/javascript" src="chrome://tbsync/content/manager/accountManager.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/accounts.js b/content/manager/accounts.js
new file mode 100644
index 0000000..45774b1
--- /dev/null
+++ b/content/manager/accounts.js
@@ -0,0 +1,498 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+var tbSyncAccounts = {
+
+  selectedAccount: null,
+
+  onload: function () {
+    //scan accounts, update list and select first entry (because no id is passed to updateAccountList)
+    //the onSelect event of the List will load the selected account
+    //also update/init add menu
+    this.updateAvailableProvider(); 
+    
+    Services.obs.addObserver(tbSyncAccounts.updateProviderListObserver, "tbsync.observer.manager.updateProviderList", false);
+    Services.obs.addObserver(tbSyncAccounts.updateAccountsListObserver, "tbsync.observer.manager.updateAccountsList", false);
+    Services.obs.addObserver(tbSyncAccounts.updateAccountSyncStateObserver, "tbsync.observer.manager.updateSyncstate", false);
+    Services.obs.addObserver(tbSyncAccounts.updateAccountNameObserver, "tbsync.observer.manager.updateAccountName", false);
+    Services.obs.addObserver(tbSyncAccounts.toggleEnableStateObserver, "tbsync.observer.manager.toggleEnableState", false);
+  },
+
+  onunload: function () {
+    Services.obs.removeObserver(tbSyncAccounts.updateProviderListObserver, "tbsync.observer.manager.updateProviderList");
+    Services.obs.removeObserver(tbSyncAccounts.updateAccountsListObserver, "tbsync.observer.manager.updateAccountsList");
+    Services.obs.removeObserver(tbSyncAccounts.updateAccountSyncStateObserver, "tbsync.observer.manager.updateSyncstate");
+    Services.obs.removeObserver(tbSyncAccounts.updateAccountNameObserver, "tbsync.observer.manager.updateAccountName");
+    Services.obs.removeObserver(tbSyncAccounts.toggleEnableStateObserver, "tbsync.observer.manager.toggleEnableState");
+  },       
+  
+  hasInstalledProvider: function (accountID) {
+    let provider = TbSync.db.getAccountProperty(accountID, "provider");
+    return TbSync.providers.loadedProviders.hasOwnProperty(provider);
+  },
+
+  updateDropdown: function (selector) {
+    let accountsList = document.getElementById("tbSyncAccounts.accounts");
+    let selectedAccount = null;
+    let selectedAccountName = "";
+    let isActionsDropdown = (selector == "accountActions");
+
+    let isSyncing = false;
+    let isConnected = false;
+    let isEnabled = false;
+    let isInstalled = false;
+    
+    if (accountsList.selectedItem !== null && !isNaN(accountsList.selectedItem.value)) {
+      //some item is selected
+      let selectedItem = accountsList.selectedItem;
+      selectedAccount = selectedItem.value;
+      selectedAccountName = selectedItem.childNodes[1].getAttribute("value");
+      isSyncing = TbSync.core.isSyncing(selectedAccount);
+      isConnected = TbSync.core.isConnected(selectedAccount);
+      isEnabled = TbSync.core.isEnabled(selectedAccount);
+      isInstalled = tbSyncAccounts.hasInstalledProvider(selectedAccount);
+    }
+
+    //hide if no accounts are avail (which is identical to no account selected)
+    if (isActionsDropdown) document.getElementById(selector + "SyncAllAccounts").hidden = (selectedAccount === null);
+    
+    //hide if no account is selected
+    if (isActionsDropdown) document.getElementById(selector + "Separator").hidden = (selectedAccount === null);
+    document.getElementById(selector + "DeleteAccount").hidden = (selectedAccount === null);
+    document.getElementById(selector + "DisableAccount").hidden = (selectedAccount === null) || !isEnabled || !isInstalled;
+    document.getElementById(selector + "EnableAccount").hidden = (selectedAccount === null) || isEnabled || !isInstalled;
+    document.getElementById(selector + "SyncAccount").hidden = (selectedAccount === null) || !isConnected || !isInstalled;
+    document.getElementById(selector + "RetryConnectAccount").hidden = (selectedAccount === null) || isConnected || !isEnabled || !isInstalled;
+
+    if (document.getElementById(selector + "ShowEventLog")) {
+      document.getElementById(selector + "ShowEventLog").hidden = false;
+      document.getElementById(selector + "ShowEventLog").disabled = false;
+    }
+    
+    if (selectedAccount !== null) {
+      //disable if currently syncing (and displayed)
+      document.getElementById(selector + "DeleteAccount").disabled = isSyncing;
+      document.getElementById(selector + "DisableAccount").disabled = isSyncing;
+      document.getElementById(selector + "EnableAccount").disabled = isSyncing;
+      document.getElementById(selector + "SyncAccount").disabled = isSyncing;
+      //adjust labels - only in global actions dropdown
+      if (isActionsDropdown) document.getElementById(selector + "DeleteAccount").label = TbSync.getString("accountacctions.delete").replace("##accountname##", selectedAccountName);
+      if (isActionsDropdown) document.getElementById(selector + "SyncAccount").label = TbSync.getString("accountacctions.sync").replace("##accountname##", selectedAccountName);
+      if (isActionsDropdown) document.getElementById(selector + "EnableAccount").label = TbSync.getString("accountacctions.enable").replace("##accountname##", selectedAccountName);
+      if (isActionsDropdown) document.getElementById(selector + "DisableAccount").label = TbSync.getString("accountacctions.disable").replace("##accountname##", selectedAccountName);
+    }
+  },
+  
+  synchronizeAccount: function () {
+    let accountsList = document.getElementById("tbSyncAccounts.accounts");
+    if (accountsList.selectedItem !== null && !isNaN(accountsList.selectedItem.value)  && !TbSync.core.isSyncing(accountsList.selectedItem.value)) {            
+      if (tbSyncAccounts.hasInstalledProvider(accountsList.selectedItem.value)) {
+        TbSync.core.syncAccount(accountsList.selectedItem.value);
+      }
+    }
+  },
+
+  deleteAccount: function () {
+    let accountsList = document.getElementById("tbSyncAccounts.accounts");
+    if (accountsList.selectedItem !== null && !isNaN(accountsList.selectedItem.value)  && !TbSync.core.isSyncing(accountsList.selectedItem.value)) {
+      let nextAccount =  -1;
+      if (accountsList.selectedIndex > 0) {
+        //first try to select the item after this one, otherwise take the one before
+        if (accountsList.selectedIndex + 1 < accountsList.getRowCount()) nextAccount = accountsList.getItemAtIndex(accountsList.selectedIndex + 1).value;
+        else nextAccount = accountsList.getItemAtIndex(accountsList.selectedIndex - 1).value;
+      }
+      
+      if (!tbSyncAccounts.hasInstalledProvider(accountsList.selectedItem.value)) {
+        if (confirm(TbSync.getString("prompt.Erase").replace("##accountName##", accountsList.selectedItem.getAttribute("label")))) {
+          //delete account and all folders from db
+          TbSync.db.removeAccount(accountsList.selectedItem.value);
+          //update list
+          this.updateAccountsList(nextAccount);
+        } 
+      } else if (confirm(TbSync.getString("prompt.DeleteAccount").replace("##accountName##", accountsList.selectedItem.getAttribute("label")))) {
+        //cache all folders and remove associated targets 
+        TbSync.core.disableAccount(accountsList.selectedItem.value);
+        
+        // the following call might fail, as not all providers provide that method, it was mainly added to cleanup stored passwords
+        try  {
+          let accountData = new TbSync.AccountData(accountsList.selectedItem.value);
+          TbSync.providers[accountData.getAccountProperty("provider")].Base.onDeleteAccount(accountData);
+        } catch (e) {                Components.utils.reportError(e);}
+
+        //delete account and all folders from db
+        TbSync.db.removeAccount(accountsList.selectedItem.value);
+        //update list
+        this.updateAccountsList(nextAccount);
+      }
+    }
+  },
+
+
+
+  /* * *
+  * Observer to catch update list request (upon provider load/unload)
+  */
+  updateAccountsListObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //aData is the accountID to be selected
+      //if missing, it will try to not change selection
+      tbSyncAccounts.updateAccountsList(aData); 
+    }
+  },
+  
+  updateProviderListObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //aData is a provider
+      tbSyncAccounts.updateAvailableProvider(aData); 
+    }
+  },    
+
+  toggleEnableState: function () {
+    let accountsList = document.getElementById("tbSyncAccounts.accounts");
+    
+    if (accountsList.selectedItem !== null && !isNaN(accountsList.selectedItem.value) && !TbSync.core.isSyncing(accountsList.selectedItem.value)) {            
+      let isConnected = TbSync.core.isConnected(accountsList.selectedItem.value);
+      if (!isConnected || window.confirm(TbSync.getString("prompt.Disable"))) {           
+        tbSyncAccounts.toggleAccountEnableState(accountsList.selectedItem.value);
+      }
+    }
+  },
+
+  /* * *
+  * Observer to catch enable state toggle
+  */
+  toggleEnableStateObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      tbSyncAccounts.toggleAccountEnableState(aData);
+    }
+  },
+  
+  //is not prompting, this is doing the actual toggle
+  toggleAccountEnableState: function (accountID) {
+    if (tbSyncAccounts.hasInstalledProvider(accountID)) {
+      let isEnabled = TbSync.core.isEnabled(accountID);
+      
+      if (isEnabled) {
+        //we are enabled and want to disable (do not ask, if not connected)
+        TbSync.core.disableAccount(accountID);
+        Services.obs.notifyObservers(null, "tbsync.observer.manager.updateAccountSettingsGui", accountID);
+        tbSyncAccounts.updateAccountStatus(accountID);
+      } else {
+        //we are disabled and want to enabled
+        TbSync.core.enableAccount(accountID);
+        Services.obs.notifyObservers(null, "tbsync.observer.manager.updateAccountSettingsGui", accountID);
+        TbSync.core.syncAccount(accountID);
+      }
+    }
+  },
+
+  /* * *
+  * Observer to catch synstate changes and to update account icons
+  */
+  updateAccountSyncStateObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      if (aData) {
+        //since we want rotating arrows on each syncstate change, we need to run this on each syncstate
+        tbSyncAccounts.updateAccountStatus(aData);
+      }
+    }
+  },
+
+  setStatusImage: function (accountID, obj) {
+    let statusImage = this.getStatusImage(accountID, obj.src);
+    if (statusImage != obj.src) {
+      obj.src = statusImage;
+    }
+  },
+  
+  getStatusImage: function (accountID, current = "") {
+    let src = "";   
+
+    if (!tbSyncAccounts.hasInstalledProvider(accountID)) {
+      src = "error16.png";
+    } else {
+      switch (TbSync.db.getAccountProperty(accountID, "status").split(".")[0]) {
+        case "success":
+          src = "tick16.png";
+          break;
+        
+        case "disabled":
+          src = "disabled16.png";
+          break;
+        
+        case "info":
+        case "notsyncronized":
+        case "modified":
+          src = "info16.png";
+          break;
+
+        case "warning":
+          src = "warning16.png";
+          break;
+
+        case "syncing":
+          switch (current.replace("chrome://tbsync/content/skin/","")) {
+            case "sync16_1.png": 
+              src = "sync16_2.png"; 
+              break;
+            case "sync16_2.png": 
+              src = "sync16_3.png"; 
+              break;
+            case "sync16_3.png": 
+              src = "sync16_4.png"; 
+              break;
+            case "sync16_4.png": 
+              src = "sync16_1.png"; 
+              break;
+            default: 
+              src = "sync16_1.png";
+              TbSync.core.getSyncDataObject(accountID).accountManagerLastUpdated = 0;
+              break;
+          }                
+          if ((Date.now() - TbSync.core.getSyncDataObject(accountID).accountManagerLastUpdated) < 300) {
+            return current;
+          }
+          TbSync.core.getSyncDataObject(accountID).accountManagerLastUpdated = Date.now();
+          break;
+
+        default:
+          src = "error16.png";
+      }
+    }
+    
+    return "chrome://tbsync/content/skin/" + src;
+  },
+
+  updateAccountLogo: function (id) {
+    let accountData = new TbSync.AccountData(id);
+    let listItem = document.getElementById("tbSyncAccounts.accounts." + id);
+    if (listItem) {
+      let obj = listItem.childNodes[0];
+      obj.src = tbSyncAccounts.hasInstalledProvider(id) ? TbSync.providers[accountData.getAccountProperty("provider")].Base.getProviderIcon(16, accountData) : "chrome://tbsync/content/skin/provider16.png";
+    }
+  },
+
+  updateAccountStatus: function (id) {
+    let listItem = document.getElementById("tbSyncAccounts.accounts." + id);
+    if (listItem) {
+      let obj = listItem.childNodes[2];
+      this.setStatusImage(id, obj);
+    }
+  },
+
+  updateAccountNameObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      let pos = aData.indexOf(":");
+      let id = aData.substring(0, pos);
+      let name = aData.substring(pos+1);
+      tbSyncAccounts.updateAccountName (id, name);
+    }
+  },
+
+  updateAccountName: function (id, name) {
+    let listItem = document.getElementById("tbSyncAccounts.accounts." + id);
+    if (listItem.childNodes[1].getAttribute("value") != name) {
+      listItem.childNodes[1].setAttribute("value", name);
+    }
+  },
+  
+  updateAvailableProvider: function (provider = null) {        
+    //either add/remove a specific provider, or rebuild the list from scratch
+    if (provider) {
+      //update single provider entry
+      tbSyncAccounts.updateAddMenuEntry(provider);
+    } else {
+      //add default providers
+      for (let provider in TbSync.providers.defaultProviders) {
+        tbSyncAccounts.updateAddMenuEntry(provider);
+      }
+      //update/add all remaining installed providers
+      for (let provider in TbSync.providers.loadedProviders) {
+        tbSyncAccounts.updateAddMenuEntry(provider);
+      }
+    }
+    
+    this.updateAccountsList();
+    
+    let selectedAccount = this.getSelectedAccount();
+    if (selectedAccount !== null && TbSync.db.getAccountProperty(selectedAccount, "provider") == provider) {
+      tbSyncAccounts.loadSelectedAccount();
+    }
+  },
+  
+  updateAccountsList: function (accountToSelect = null) {
+    let accountsList = document.getElementById("tbSyncAccounts.accounts");
+    let accounts = TbSync.db.getAccounts();
+
+    // try to keep the currently selected account, if accountToSelect is not given
+    if (accountToSelect === null) {
+      let s = accountsList.getItemAtIndex(accountsList.selectedIndex);
+      if (s) {
+        // there is an entry selected, do not change it
+        accountToSelect = s.value;
+      }
+    }
+    
+    if (accounts.allIDs.length > null) {
+
+      //get current accounts in list and remove entries of accounts no longer there
+      let listedAccounts = [];
+      for (let i=accountsList.getRowCount()-1; i>=0; i--) {
+        let item = accountsList.getItemAtIndex(i);
+        listedAccounts.push(item.value);
+        if (accounts.allIDs.indexOf(item.value) == -1) {
+          item.remove();
+        }
+      }
+
+      //accounts array is without order, extract keys (ids) and loop over keys
+      for (let i = 0; i < accounts.allIDs.length; i++) {
+
+        if (listedAccounts.indexOf(accounts.allIDs[i]) == -1) {
+          //add all missing accounts (always to the end of the list)
+          let newListItem = document.createXULElement("richlistitem");
+          newListItem.setAttribute("id", "tbSyncAccounts.accounts." + accounts.allIDs[i]);
+          newListItem.setAttribute("value", accounts.allIDs[i]);
+          newListItem.setAttribute("align", "center");
+          newListItem.setAttribute("label", accounts.data[accounts.allIDs[i]].accountname);
+          newListItem.setAttribute("style", "padding: 5px 0px;");
+          newListItem.setAttribute("ondblclick", "tbSyncAccounts.toggleEnableState();");
+          
+          //add icon (use "install provider" icon, if provider not installed)
+          let itemType = document.createXULElement("image");
+          //itemType.setAttribute("width", "16");
+          //itemType.setAttribute("height", "16");
+          itemType.setAttribute("style", "margin: 0px 0px 0px 5px; width:16px; height:16px");
+          newListItem.appendChild(itemType);
+
+          //add account name
+          let itemLabel = document.createXULElement("label");
+          itemLabel.setAttribute("flex", "1");
+          newListItem.appendChild(itemLabel);
+
+          //add account status
+          let itemStatus = document.createXULElement("image");
+          //itemStatus.setAttribute("width", "16");
+          //itemStatus.setAttribute("height", "16");
+          itemStatus.setAttribute("style", "margin: 0px 5px; width:16px; height:16px");
+          newListItem.appendChild(itemStatus);
+          
+          accountsList.appendChild(newListItem);
+        } 
+        
+        //update/set actual values
+        this.updateAccountName(accounts.allIDs[i], accounts.data[accounts.allIDs[i]].accountname);
+        this.updateAccountStatus(accounts.allIDs[i]);
+        this.updateAccountLogo(accounts.allIDs[i]);
+      }
+      
+      //find selected item
+      for (let i=0; i<accountsList.getRowCount(); i++) {
+        if (accountToSelect === null || accountToSelect == accountsList.getItemAtIndex(i).value) {
+          accountsList.selectedIndex = i;
+          accountsList.ensureIndexIsVisible(i);
+          break;
+        }
+      }
+
+    } else {
+      //No defined accounts, empty accounts list and load dummy
+      for (let i=accountsList.getRowCount()-1; i>=0; i--) {
+        accountsList.getItemAtIndex(i).remove();
+      }
+      document.getElementById("tbSyncAccounts.contentFrame").setAttribute("src", "chrome://tbsync/content/manager/noaccounts.xhtml");
+    }
+  },
+
+  updateAddMenuEntry: function (provider) {
+    let isDefault = TbSync.providers.defaultProviders.hasOwnProperty(provider);
+    let isInstalled = TbSync.providers.loadedProviders.hasOwnProperty(provider);
+    
+    let entry = document.getElementById("addMenuEntry_" + provider);
+    if (entry === null) {
+      //add basic menu entry
+      let newItem = window.document.createXULElement("menuitem");
+      newItem.setAttribute("id", "addMenuEntry_" + provider);
+      newItem.setAttribute("value",  provider);
+      newItem.setAttribute("class", "menuitem-iconic");
+      newItem.addEventListener("click", function () {tbSyncAccounts.addAccountAction(provider)}, false);
+      newItem.setAttribute("hidden", true);
+      entry = window.document.getElementById("accountActionsAddAccount").appendChild(newItem);
+    }
+    
+    //Update label, icon and hidden according to isDefault and isInstalled
+    if (isInstalled) {
+      entry.setAttribute("label",  TbSync.providers[provider].Base.getProviderName());
+      entry.setAttribute("image", TbSync.providers[provider].Base.getProviderIcon(16));
+      entry.setAttribute("hidden", false);
+    } else if (isDefault) {
+      entry.setAttribute("label", TbSync.providers.defaultProviders[provider].name);
+      entry.setAttribute("image", "chrome://tbsync/content/skin/provider16.png");                    
+      entry.setAttribute("hidden", false);
+    } else {
+      entry.setAttribute("hidden", true);
+    }
+  },
+
+  getSelectedAccount: function () {
+    let accountsList = document.getElementById("tbSyncAccounts.accounts");
+    if (accountsList.selectedItem !== null && !isNaN(accountsList.selectedItem.value)) {
+      //get id of selected account from value of selectedItem
+      return accountsList.selectedItem.value;
+    }
+    return null;
+  },
+  
+  //load the pref page for the currently selected account (triggered by onSelect)
+  loadSelectedAccount: function () {
+    let selectedAccount = this.getSelectedAccount();
+    
+    if (selectedAccount !== null) { //account id could be 0, so need to check for null explicitly
+      let provider = TbSync.db.getAccountProperty(selectedAccount, "provider");            
+      if (tbSyncAccounts.hasInstalledProvider(selectedAccount)) {
+        document.getElementById("tbSyncAccounts.contentFrame").setAttribute("src", "chrome://tbsync/content/manager/editAccount.xhtml?provider="+provider+"&id=" + selectedAccount);
+      } else {
+        document.getElementById("tbSyncAccounts.contentFrame").setAttribute("src", "chrome://tbsync/content/manager/missingProvider.xhtml?provider="+provider);
+      }
+    }
+  },
+  
+
+
+
+  addAccountAction: function (provider) {
+    let isDefault = TbSync.providers.defaultProviders.hasOwnProperty(provider);
+    let isInstalled = TbSync.providers.loadedProviders.hasOwnProperty(provider);
+    
+    if (isInstalled) {
+      tbSyncAccounts.addAccount(provider);
+    } else if (isDefault) {
+      tbSyncAccounts.installProvider(provider);
+    }
+  },
+  
+  addAccount: function (provider) {
+    TbSync.providers.loadedProviders[provider].createAccountWindow = window.openDialog(TbSync.providers[provider].Base.getCreateAccountWindowUrl(), "TbSyncNewAccountWindow", "centerscreen,resizable=no");
+    TbSync.providers.loadedProviders[provider].createAccountWindow.addEventListener("unload", function () { TbSync.manager.prefWindowObj.focus(); });
+  },
+
+  installProvider: function (provider) {
+    for (let i=0; i<TbSync.AccountManagerTabs.length; i++) {            
+       TbSync.manager.prefWindowObj.document.getElementById("tbSyncAccountManager.t" + i).setAttribute("active","false");
+    }
+    TbSync.manager.prefWindowObj.document.getElementById("tbSyncAccountManager.installProvider").hidden=false;
+    TbSync.manager.prefWindowObj.document.getElementById("tbSyncAccountManager.installProvider").setAttribute("active","true");
+    TbSync.manager.prefWindowObj.document.getElementById("tbSyncAccountManager.contentWindow").setAttribute("src", "chrome://tbsync/content/manager/installProvider.xhtml?provider="+provider);        
+  },
+      
+};
diff --git a/content/manager/accounts.xhtml b/content/manager/accounts.xhtml
new file mode 100644
index 0000000..663c835
--- /dev/null
+++ b/content/manager/accounts.xhtml
@@ -0,0 +1,119 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    onload="tbSyncAccounts.onload();"
+    onunload="tbSyncAccounts.onunload();"
+    title="TbSync Account Settings" >
+
+    <popupset>
+        <menupopup id="tbsync.accountmanger.ContextMenu" onpopupshowing="tbSyncAccounts.updateDropdown('contextMenu');">
+            <menuitem id="contextMenuRetryConnectAccount" 
+                    class="menuitem-iconic"
+                    image="chrome://tbsync/content/skin/connect16.png"
+                    label="__TBSYNCMSG_manager.RetryConnectAccount__" 
+                    oncommand="tbSyncAccounts.synchronizeAccount();"/>
+            <menuitem id="contextMenuSyncAccount" 
+                    class="menuitem-iconic"
+                    image="chrome://tbsync/content/skin/sync16.png"
+                    label="__TBSYNCMSG_manager.SynchronizeAccount__" 
+                    oncommand="tbSyncAccounts.synchronizeAccount();"/>
+            <menuitem id="contextMenuEnableAccount" 
+                    class="menuitem-iconic"
+                    image="chrome://tbsync/content/skin/connect16.png"
+                    label="__TBSYNCMSG_manager.EnableAccount__" 
+                    oncommand="tbSyncAccounts.toggleEnableState();"/>
+            <menuitem id="contextMenuDisableAccount" 
+                    class="menuitem-iconic"
+                    image="chrome://tbsync/content/skin/disabled16.png"
+                    label="__TBSYNCMSG_manager.DisableAccount__" 
+                    oncommand="tbSyncAccounts.toggleEnableState();"/>
+            <menuitem id="contextMenuDeleteAccount"
+                    class="menuitem-iconic"
+                    image="chrome://tbsync/content/skin/del16.png"
+                    label="__TBSYNCMSG_manager.DeleteAccount__"
+                    oncommand="tbSyncAccounts.deleteAccount();"/>
+        </menupopup>
+    </popupset>
+    
+    <hbox flex="1">
+        <vbox width="200">
+            <richlistbox 
+                id="tbSyncAccounts.accounts"
+                flex="1"
+                style="margin: 0 1px; width: 200px;"
+                seltype="single"
+                context="tbsync.accountmanger.ContextMenu"
+                onkeypress="if (event.keyCode == 46) {tbSyncAccounts.deleteAccount();}"
+                onselect="tbSyncAccounts.loadSelectedAccount();">
+                <listheader style="border-bottom: 1px solid lightgrey;">
+                    <treecol style="font-weight:bold;" label="" width="26" flex="0" />
+                    <treecol style="font-weight:bold;" label="__TBSYNCMSG_manager.accounts__" flex="1" />
+                    <treecol style="font-weight:bold;text-align:right;" label="__TBSYNCMSG_manager.status__" flex="0" />
+                </listheader>
+            </richlistbox>
+            <hbox style="margin:1ex 0 0 0">
+             <vbox style="margin:0" flex="1">
+                <button 
+                id="tbSyncAccounts.btnAccountActions"
+                label="__TBSYNCMSG_manager.AccountActions__"
+                style="margin:0"
+                type="menu">
+                        <menupopup id="accountActionsDropdown" onpopupshowing="tbSyncAccounts.updateDropdown('accountActions');">
+                            <menu
+                                class="menu-iconic"
+                                image="chrome://tbsync/content/skin/add16.png"
+                                label="__TBSYNCMSG_manager.AddAccount__">
+                                        <menupopup id="accountActionsAddAccount" />
+                            </menu>
+                            <menuitem id="accountActionsSyncAllAccounts"
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/sync16.png"
+                                    label="__TBSYNCMSG_manager.SyncAll__"
+                                    oncommand="TbSync.core.syncAllAccounts();"/>
+                            <menuitem id="accountActionsShowEventLog"
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/warning16.png"
+                                    label="__TBSYNCMSG_manager.ShowEventLog__"
+                                    oncommand="TbSync.eventlog.open()"/>
+                            <menuseparator id="accountActionsSeparator"/>
+                            <menuitem id="accountActionsDeleteAccount"
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/del16.png"
+                                    label="__TBSYNCMSG_manager.DeleteAccount__"
+                                    oncommand="tbSyncAccounts.deleteAccount();"/>
+                            <menuitem id="accountActionsDisableAccount" 
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/disabled16.png"
+                                    label="__TBSYNCMSG_manager.DisableAccount__" 
+                                    oncommand="tbSyncAccounts.toggleEnableState();"/>
+                            <menuitem id="accountActionsEnableAccount" 
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/connect16.png"
+                                    label="__TBSYNCMSG_manager.EnableAccount__" 
+                                    oncommand="tbSyncAccounts.toggleEnableState();"/>
+                            <menuitem id="accountActionsSyncAccount" 
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/sync16.png"
+                                    label="__TBSYNCMSG_manager.SynchronizeAccount__" 
+                                    oncommand="tbSyncAccounts.synchronizeAccount();"/>
+                            <menuitem id="accountActionsRetryConnectAccount" 
+                                    class="menuitem-iconic"
+                                    image="chrome://tbsync/content/skin/connect16.png"
+                                    label="__TBSYNCMSG_manager.RetryConnectAccount__" 
+                                    oncommand="tbSyncAccounts.synchronizeAccount();"/>                                    
+                        </menupopup>
+                </button>
+             </vbox>
+            </hbox>
+        </vbox>
+        <browser id="tbSyncAccounts.contentFrame" type="chrome" src="" disablehistory="true" flex="1"  style="margin-left:12px;"/>	
+    </hbox>
+
+    <script type="text/javascript" src="chrome://tbsync/content/manager/accounts.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/addonoptions.xhtml b/content/manager/addonoptions.xhtml
new file mode 100644
index 0000000..8ee9c10
--- /dev/null
+++ b/content/manager/addonoptions.xhtml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    title="__TBSYNCMSG_manager.title__" 
+    onload="tbSyncAccountManager.onloadoptions();"
+    onunload="tbSyncAccountManager.onunloadoptions();"
+    width="180" height="80" >
+    
+    <script type="text/javascript" src="chrome://tbsync/content/manager/accountManager.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/catman.xhtml b/content/manager/catman.xhtml
new file mode 100644
index 0000000..ce78783
--- /dev/null
+++ b/content/manager/catman.xhtml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    title="Category Manager" >
+
+    <hbox flex="1" id="mainframe">
+        <vbox flex="1">
+            <html:p>
+                __TBSYNCMSG_manager.catman.text__
+            </html:p>
+            
+            <html:p onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="TbSync.manager.openLink('https://addons.thunderbird.net/addon/categorymanager/');" style="color:blue;text-decoration: underline;padding-left:1em;">
+              https://addons.thunderbird.net/addon/categorymanager/
+            </html:p>
+        </vbox>
+    </hbox>
+    
+    <script type="text/javascript" src="chrome://tbsync/content/manager/accountManager.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/editAccount.js b/content/manager/editAccount.js
new file mode 100644
index 0000000..ff4db50
--- /dev/null
+++ b/content/manager/editAccount.js
@@ -0,0 +1,391 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+var tbSyncAccountSettings = {
+
+  accountID: null,
+  provider: null,
+  settings: null,
+  updateTimer: Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer),
+
+  updateFolderListObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //only run if is request for this account and main frame is visible
+      let accountID = aData;            
+      if (accountID == tbSyncAccountSettings.accountID && !document.getElementById('tbsync.accountsettings.frame').hidden) {
+        //make sure, folderlist is visible, otherwise our updates will be discarded (may cause errors)
+        tbSyncAccountSettings.updateFolderList();
+        tbSyncAccountSettings.updateGui();
+      }
+    }
+  },
+
+  reloadAccountSettingObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //only run if is request for this account and main frame is visible
+      let data = JSON.parse(aData);
+      if (data.accountID == tbSyncAccountSettings.accountID && !document.getElementById('tbsync.accountsettings.frame').hidden) {
+        tbSyncAccountSettings.reloadSetting(data.setting);
+      }
+    }
+  },
+
+  updateGuiObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //only run if is request for this account and main frame is visible
+      let accountID = aData;            
+      if (accountID == tbSyncAccountSettings.accountID && !document.getElementById('tbsync.accountsettings.frame').hidden) {
+        tbSyncAccountSettings.updateGui();
+      }
+    }
+  },
+
+  updateSyncstateObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //only run if is request for this account and main frame is visible
+      let accountID = aData;            
+      if (accountID == tbSyncAccountSettings.accountID && !document.getElementById('tbsync.accountsettings.frame').hidden) {
+        let syncstate = TbSync.core.getSyncDataObject(accountID).getSyncState().state;
+        if (syncstate == "accountdone") {
+          tbSyncAccountSettings.updateGui();
+        } else {
+          tbSyncAccountSettings.updateSyncstate();
+        }
+      }
+    }
+  },
+
+  onload: function () {
+    //load observers
+    Services.obs.addObserver(tbSyncAccountSettings.updateFolderListObserver, "tbsync.observer.manager.updateFolderList", false);
+    Services.obs.addObserver(tbSyncAccountSettings.updateGuiObserver, "tbsync.observer.manager.updateAccountSettingsGui", false);
+    Services.obs.addObserver(tbSyncAccountSettings.reloadAccountSettingObserver, "tbsync.observer.manager.reloadAccountSetting", false);
+    Services.obs.addObserver(tbSyncAccountSettings.updateSyncstateObserver, "tbsync.observer.manager.updateSyncstate", false);
+    //get the selected account from the loaded URI
+    tbSyncAccountSettings.accountID = window.location.toString().split("id=")[1];
+    tbSyncAccountSettings.accountData = new TbSync.AccountData(tbSyncAccountSettings.accountID);
+
+    //get information for that acount
+    tbSyncAccountSettings.provider = TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, "provider");
+    tbSyncAccountSettings.settings = Object.keys(TbSync.providers.getDefaultAccountEntries(tbSyncAccountSettings.provider)).sort();
+
+    //add header to folderlist
+    let header = TbSync.providers[tbSyncAccountSettings.provider].folderList.getHeader();
+    let folderlistHeader = window.document.getElementById('tbsync.accountsettings.folderlist.header');
+    for (let h=0; h < header.length; h++) {
+      let listheader = window.document.createXULElement("treecol");
+      for (let a in header[h]) {
+        if (header[h].hasOwnProperty(a)) {
+          listheader.setAttribute(a, header[h][a]);
+        }
+      }
+      folderlistHeader.appendChild(listheader);
+    }        
+    
+    //load overlays from the provider (if any)
+    TbSync.messenger.overlayManager.injectAllOverlays(window, "chrome://tbsync/content/manager/editAccount.xhtml?provider=" + tbSyncAccountSettings.provider);
+    if (window.tbSyncEditAccountOverlay && window.tbSyncEditAccountOverlay.hasOwnProperty("onload")) {
+      tbSyncEditAccountOverlay.onload(window, new TbSync.AccountData(tbSyncAccountSettings.accountID));
+    }
+    tbSyncAccountSettings.loadSettings();
+    
+    //done, folderlist must be updated while visible
+    document.getElementById('tbsync.accountsettings.frame').hidden = false;	    
+    tbSyncAccountSettings.updateFolderList();      
+
+    if (Services.appinfo.OS == "Darwin") { //we might need to find a way to detect MacOS like styling, other themes move the header bar into the tabpanel as well
+      document.getElementById('manager.tabpanels').style["padding-top"] = "3ex";
+    }
+  },
+
+
+  onunload: function () {
+    tbSyncAccountSettings.updateTimer.cancel();
+    if (!document.getElementById('tbsync.accountsettings.frame').hidden) {
+      Services.obs.removeObserver(tbSyncAccountSettings.updateFolderListObserver, "tbsync.observer.manager.updateFolderList");
+      Services.obs.removeObserver(tbSyncAccountSettings.updateGuiObserver, "tbsync.observer.manager.updateAccountSettingsGui");
+      Services.obs.removeObserver(tbSyncAccountSettings.reloadAccountSettingObserver, "tbsync.observer.manager.reloadAccountSetting");
+      Services.obs.removeObserver(tbSyncAccountSettings.updateSyncstateObserver, "tbsync.observer.manager.updateSyncstate");
+    }
+  },
+  
+
+   folderListVisible: function () {
+    let box = document.getElementById('tbsync.accountsettings.folderlist').getBoundingClientRect();
+    let visible = box.width && box.height;
+    return visible;
+  },
+  
+
+  reloadSetting: function (setting) {
+    let pref = document.getElementById("tbsync.accountsettings.pref." + setting);
+    let label = document.getElementById("tbsync.accountsettings.label." + setting);
+
+    if (pref) {
+      //is this a checkbox?
+      if ((pref.tagName == "checkbox") || ((pref.tagName == "input") && (pref.type == "checkbox"))) {
+        //BOOL
+        if (TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, setting)) pref.setAttribute("checked", true);
+        else pref.removeAttribute("checked");
+      } else {
+        //Not BOOL
+        pref.value = TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, setting);
+      }
+    }    
+  },
+
+
+  /**
+   * Run through all defined TbSync settings and if there is a corresponding
+   * field in the settings dialog, fill it with the stored value.
+   */
+  loadSettings: function () {
+    for (let i=0; i < tbSyncAccountSettings.settings.length; i++) {
+      let pref = document.getElementById("tbsync.accountsettings.pref." + tbSyncAccountSettings.settings[i]);
+      let label = document.getElementById("tbsync.accountsettings.label." + tbSyncAccountSettings.settings[i]);
+
+      if (pref) {
+        //is this a checkbox?
+        let event = "blur";
+        if ((pref.tagName == "checkbox") || ((pref.tagName == "input") && (pref.type == "checkbox"))) {
+          //BOOL
+          if (TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, tbSyncAccountSettings.settings[i])) pref.setAttribute("checked", true);
+          else pref.removeAttribute("checked");
+          event = "command";
+        } else {
+          //Not BOOL
+          if (pref.tagName == "menulist") {
+            pref.value = TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, tbSyncAccountSettings.settings[i]);
+            event = "command";
+          } else {
+            pref.setAttribute("value", TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, tbSyncAccountSettings.settings[i]));
+          }
+        }
+        
+        pref.addEventListener(event, function() {tbSyncAccountSettings.instantSaveSetting(this)});
+      }
+    }
+    
+    tbSyncAccountSettings.updateGui();        
+  },
+
+  updateGui: function () {
+    let status = TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, "status");
+
+    let isConnected = TbSync.core.isConnected(tbSyncAccountSettings.accountID);
+    let isEnabled = TbSync.core.isEnabled(tbSyncAccountSettings.accountID);      
+    let isSyncing = TbSync.core.isSyncing(tbSyncAccountSettings.accountID);
+    
+    { //disable settings if connected or syncing
+      let items = document.getElementsByClassName("lockIfConnected");
+      for (let i=0; i < items.length; i++) {
+        if (isConnected || isSyncing || items[i].getAttribute("alwaysDisabled") == "true") {
+          items[i].setAttribute("disabled", true);
+          items[i].style["color"] =  "darkgrey";            
+        } else {
+          items[i].removeAttribute("disabled");
+          items[i].style["color"] = "black";
+        }                    
+      }
+    }
+
+    document.getElementById('tbsync.accountsettings.connectbtn.container').hidden = !(isEnabled && !isConnected && !isSyncing); 
+    //currently we use a fixed button which is hidden during sync
+    //document.getElementById('tbsync.accountsettings.connectbtn').label = TbSync.getString("manager." + (isSyncing ? "connecting" : "tryagain"));
+    
+    { //show elements if connected (this also hides/unhides the folderlist)
+      let items = document.getElementsByClassName("showIfConnected");
+      for (let i=0; i < items.length; i++) {
+        items[i].hidden = !isConnected;    
+      }
+    }
+
+    { //show elements if enabled
+      let items = document.getElementsByClassName("showIfEnabled");
+      for (let i=0; i < items.length; i++) {
+        items[i].hidden = !isEnabled;    
+      }
+    }
+    
+    document.getElementById('tbsync.accountsettings.enabled').checked = isEnabled;
+    document.getElementById('tbsync.accountsettings.enabled').disabled = isSyncing;
+    document.getElementById('tbsync.accountsettings.folderlist').disabled = isSyncing;
+    document.getElementById('tbsync.accountsettings.syncbtn').disabled = isSyncing;
+    document.getElementById('tbsync.accountsettings.connectbtn').disabled = isSyncing;
+  
+    tbSyncAccountSettings.updateSyncstate();
+  
+    //change color of syncstate according to status
+    let showEventLogButton = false;
+    switch (status) {
+      case "success":
+      case "disabled":
+      case "syncing":
+        document.getElementById("syncstate").removeAttribute("style");
+        break;
+      
+      case "notsyncronized":
+        document.getElementById("syncstate").setAttribute("style","color: red");
+        break;
+      
+      default:
+        document.getElementById("syncstate").setAttribute("style","color: red");
+        showEventLogButton = TbSync.eventlog.get(tbSyncAccountSettings.accountID).length > 0;
+    }
+    document.getElementById('tbsync.accountsettings.eventlogbtn').hidden = !showEventLogButton;
+  },
+
+  updateSyncstate: function () {
+    tbSyncAccountSettings.updateTimer.cancel();
+
+    // if this account is beeing synced, display syncstate, otherwise print status
+    let status = TbSync.db.getAccountProperty(tbSyncAccountSettings.accountID, "status");
+    let isSyncing = TbSync.core.isSyncing(tbSyncAccountSettings.accountID);
+    let isConnected = TbSync.core.isConnected(tbSyncAccountSettings.accountID);
+    let isEnabled = TbSync.core.isEnabled(tbSyncAccountSettings.accountID);
+    let syncdata = TbSync.core.getSyncDataObject(tbSyncAccountSettings.accountID);
+
+    if (isSyncing) {
+      let accounts = TbSync.db.getAccounts().data;
+      
+      let s = syncdata.getSyncState();
+      let syncstate = s.state;
+      let synctime = s.timestamp;
+
+      let msg = TbSync.getString("syncstate." + syncstate, tbSyncAccountSettings.provider);
+    
+      if (syncstate.split(".")[0] == "send") {
+        // append timeout countdown
+        let diff = Date.now() - synctime;
+        if (diff > 2000) msg = msg + " (" + Math.round((TbSync.providers[tbSyncAccountSettings.provider].Base.getConnectionTimeout(tbSyncAccountSettings.accountData) - diff)/1000) + "s)";
+        // re-schedule update, if this is a waiting syncstate
+        tbSyncAccountSettings.updateTimer.init(tbSyncAccountSettings.updateSyncstate, 1000, 0);
+      }            
+      document.getElementById("syncstate").textContent = msg;
+    } else {
+      let localized = TbSync.getString("status." + (isEnabled ? status : "disabled"), tbSyncAccountSettings.provider);
+      document.getElementById("syncstate").textContent = localized;
+    }
+        
+    
+    if (tbSyncAccountSettings.folderListVisible()) {
+      //update syncstates of folders in folderlist, if visible - remove obsolete entries while we are here
+      let folderData = TbSync.providers[tbSyncAccountSettings.provider].Base.getSortedFolders(tbSyncAccountSettings.accountData);
+      let folderList = document.getElementById("tbsync.accountsettings.folderlist");
+
+      for (let i=folderList.getRowCount()-1; i>=0; i--) {
+        let item = folderList.getItemAtIndex(i);
+        if (folderData.filter(f => f.folderID == item.folderData.folderID).length == 0) {
+          item.remove();
+        } else {
+          TbSync.providers[tbSyncAccountSettings.provider].folderList.updateRow(document, item, item.folderData);
+        }
+      }
+    }
+  },
+
+  updateFolderList: function () {
+    //get updated list of folderIDs
+    let folderData = TbSync.providers[tbSyncAccountSettings.provider].Base.getSortedFolders(tbSyncAccountSettings.accountData);
+    
+    //remove entries from folderlist, which no longer exists and build reference array with  current elements
+    let folderList = document.getElementById("tbsync.accountsettings.folderlist");
+    folderList.hidden=true;
+
+    let foldersElements = {};
+    for (let i=folderList.getRowCount()-1; i>=0; i--) {
+      if (folderData.filter(f => f.folderID == folderList.getItemAtIndex(i).folderData.folderID).length == 0) {
+        folderList.getItemAtIndex(i).remove();
+      } else {
+        foldersElements[folderList.getItemAtIndex(i).folderData.folderID] = folderList.getItemAtIndex(i);
+      }
+    }
+
+    //update folderlist
+    for (let i=0; i < folderData.length; i++) {
+      let nextItem = null;
+      
+      //if this entry does not exist, create it
+      if (foldersElements.hasOwnProperty(folderData[i].folderID)) {
+        //get reference to current element
+        nextItem = foldersElements[folderData[i].folderID];
+      } else {
+        //add new entry, attach FolderData of this folder as folderData
+        nextItem = document.createXULElement("richlistitem");
+        nextItem.folderData = folderData[i];
+        
+        //add row
+        nextItem.appendChild(TbSync.providers[tbSyncAccountSettings.provider].folderList.getRow(document, folderData[i]));
+      }
+
+      //add/move row and update its content
+      let addedItem = folderList.appendChild(nextItem);
+      TbSync.providers[tbSyncAccountSettings.provider].folderList.updateRow(document, addedItem, folderData[i]);
+
+      //ensureElementIsVisible also forces internal update of rowCount, which sometimes is not updated automatically upon appendChild
+      folderList.ensureElementIsVisible(addedItem);
+    }
+    folderList.hidden = false;
+  },
+
+
+
+
+
+  instantSaveSetting: function (field) {
+    let setting = field.id.replace("tbsync.accountsettings.pref.","");
+    let value = "";
+    
+    if ((field.tagName == "checkbox") || ((field.tagName == "input") && (field.type == "checkbox"))) {
+      if (field.checked) value = true;
+      else value = false;
+    } else {
+      value = field.value;
+    }
+    TbSync.db.setAccountProperty(tbSyncAccountSettings.accountID, setting, value);
+    
+    if (setting == "accountname") {
+      Services.obs.notifyObservers(null, "tbsync.observer.manager.updateAccountName", tbSyncAccountSettings.accountID + ":" + field.value);
+    }
+    TbSync.db.saveAccounts(); //write modified accounts to disk
+  },
+
+  toggleEnableState: function (element) {
+    if (!TbSync.core.isConnected(tbSyncAccountSettings.accountID)) {
+      //if not connected, we can toggle without prompt
+      Services.obs.notifyObservers(null, "tbsync.observer.manager.toggleEnableState", tbSyncAccountSettings.accountID);
+      return;
+    }      
+
+    if (window.confirm(TbSync.getString("prompt.Disable"))) {
+      Services.obs.notifyObservers(null, "tbsync.observer.manager.toggleEnableState", tbSyncAccountSettings.accountID);
+    } else {
+      //invalid, toggle checkbox back
+      element.setAttribute("checked", true);
+    }
+  },
+
+  
+  onFolderListContextMenuShowing: function () {
+    let folderList = document.getElementById("tbsync.accountsettings.folderlist");
+    let aFolderIsSelected = (!folderList.disabled && folderList.selectedItem !== null && folderList.selectedItem.value !== undefined);
+    let menupopup = document.getElementById("tbsync.accountsettings.FolderListContextMenu");
+    
+    if (aFolderIsSelected) {
+      TbSync.providers[tbSyncAccountSettings.provider].folderList.onContextMenuShowing(window, folderList.selectedItem.folderData);
+    } else {
+      TbSync.providers[tbSyncAccountSettings.provider].folderList.onContextMenuShowing(window, null);
+    }
+  },
+
+};
diff --git a/content/manager/editAccount.xhtml b/content/manager/editAccount.xhtml
new file mode 100644
index 0000000..9381678
--- /dev/null
+++ b/content/manager/editAccount.xhtml
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window id="tbsync.accountsettings" 
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    omscope="tbSyncAccountSettings"
+    onload="tbSyncAccountSettings.onload()"
+    onunload="tbSyncAccountSettings.onunload()"
+    title="" >
+
+    <script type="text/javascript" src="chrome://tbsync/content/manager/editAccount.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+
+    <popupset>
+        <menupopup 
+        id="tbsync.accountsettings.FolderListContextMenu" 
+        folderID=""
+        onpopupshowing="tbSyncAccountSettings.onFolderListContextMenuShowing();">
+            <menuitem 
+            class="menuitem-iconic"
+            image="chrome://tbsync/content/skin/warning16.png"
+            label="__TBSYNCMSG_manager.ShowEventLog__"
+            oncommand="TbSync.eventlog.open(tbSyncAccountSettings.accountID, this.parentNode.getAttribute('folderID'));"/>
+        </menupopup>
+    </popupset>
+    
+    <tabbox id="tbsync.accountsettings.frame" hidden="true" flex="1">
+
+        <tabs  id="manager.tabs" orient="horizontal" value="">
+            <tab id="manager.tabs.status" label="__TBSYNCMSG_manager.tabs.status__" />
+        </tabs>
+      
+        <tabpanels flex="1" id="manager.tabpanels" style="margin:0;padding:1ex;">
+            <tabpanel  id="manager.tabpanels.status" orient="vertical"><!-- STATUS -->
+                <vbox flex="1">
+                    <label class="header" style="margin-left:0; margin-bottom:1ex;" value="__TBSYNCMSG_manager.tabs.status.general__" />
+                    <checkbox id="tbsync.accountsettings.enabled" oncommand="tbSyncAccountSettings.toggleEnableState(this);" label="__TBSYNCMSG_manager.tabs.status.enableThisAccount__"  />
+
+                    <vbox class="showIfEnabled" style="height:100px; overflow-x: hidden; overflow-y:hidden">
+                        <hbox flex="1">
+                            <vbox flex="1">
+                                <label class="header" style="margin-left:0; margin-bottom:1ex; margin-top:2ex;" value="__TBSYNCMSG_manager.status__" />
+                                <description id="syncstate"></description>
+                            </vbox>
+                            <vbox flex="0">
+                                <label class="header" style="margin-left:0; margin-bottom:1ex; margin-top:1ex; visibility: hidden" value="nix" />
+                                <button id="tbsync.accountsettings.eventlogbtn" label="__TBSYNCMSG_manager.ShowEventLog__" oncommand="TbSync.eventlog.open()" />
+                            </vbox>
+                        </hbox>
+                    </vbox>
+                    
+                    <vbox flex="1">
+                        <vbox class="showIfConnected" flex="1">
+                            <label style="margin-left:0; margin-bottom: 1ex; margin-top: 2ex" class="header" value="__TBSYNCMSG_manager.tabs.status.resources__"/>
+                            <description>__TBSYNCMSG_manager.tabs.status.resources.intro__</description>
+                            <richlistbox 
+                              id="tbsync.accountsettings.folderlist"
+                              style="margin: 0 1px 1px 1ex;padding:0; height:225px; overflow-x: hidden;"
+                              context="tbsync.accountsettings.FolderListContextMenu"
+                              seltype="single">
+                                <listheader id="tbsync.accountsettings.folderlist.header" style="border-bottom: 1px solid lightgrey;">
+                                </listheader>
+                            </richlistbox>
+                            <vbox flex="0" style="margin:1ex 0 0 0;">
+                                <hbox flex="1" align="center" pack="end">
+                                    <description style="text-align:right" flex="1" control="tbsync.accountsettings.pref.autosync" tooltiptext="__TBSYNCMSG_manager.tabs.status.never__">__TBSYNCMSG_manager.tabs.status.autotime__</description>
+                                    <html:input style="width:50px;margin-bottom:0; margin-top:0" id="tbsync.accountsettings.pref.autosync" tooltiptext="__TBSYNCMSG_manager.tabs.status.never__" />
+                                    <button id="tbsync.accountsettings.syncbtn" style="margin-right:0; margin-bottom:0; margin-top:0; padding: 0 1ex;" label="__TBSYNCMSG_manager.tabs.status.sync__" oncommand="TbSync.core.syncAccount(tbSyncAccountSettings.accountID)" />
+                                </hbox>
+                            </vbox>
+                        </vbox>
+                    </vbox>
+
+                    <hbox id="tbsync.accountsettings.connectbtn.container" flex="0" style="margin:1ex 0 0 0;" pack="end">
+                        <button id="tbsync.accountsettings.connectbtn" style="margin-right:0; margin-bottom:0; margin-top:0; padding: 0 1ex;" label="__TBSYNCMSG_manager.tabs.status.tryagain__" oncommand="TbSync.core.syncAccount(tbSyncAccountSettings.accountID)" />
+                    </hbox>
+        
+                </vbox>
+            </tabpanel>
+        </tabpanels>
+
+    </tabbox>
+    
+</window>
diff --git a/content/manager/eventlog/eventlog.js b/content/manager/eventlog/eventlog.js
new file mode 100644
index 0000000..eaa0b47
--- /dev/null
+++ b/content/manager/eventlog/eventlog.js
@@ -0,0 +1,158 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+var tbSyncEventLog = {
+  
+  onload: function () {
+    Services.obs.addObserver(tbSyncEventLog.updateEventLog, "tbsync.observer.eventlog.update", false);
+
+    let eventlog = document.getElementById('tbsync.eventlog');
+    eventlog.hidden = true;
+    
+    //init list
+    let events = TbSync.eventlog.get();
+    for (let i=0; i < events.length; i++) {
+      let item = tbSyncEventLog.addLogEntry(events[i]);
+      eventlog.appendChild(item);
+    }
+    eventlog.hidden = false;
+    eventlog.ensureIndexIsVisible(eventlog.getRowCount()-1);
+    document.getElementById("tbsync.eventlog.clear").addEventListener("click", tbSyncEventLog.onclear);
+    document.getElementById("tbsync.eventlog.close").addEventListener("click", () => window.close());
+  },
+
+  onclear: function () {
+    TbSync.eventlog.clear();
+
+    let eventlog = document.getElementById('tbsync.eventlog');
+    eventlog.hidden = true;
+
+    for (let i=eventlog.getRowCount()-1; i>=0; i--) {
+      eventlog.getItemAtIndex(i).remove();
+    }
+    
+    eventlog.hidden = false;
+  },
+  
+  onunload: function () {
+    Services.obs.removeObserver(tbSyncEventLog.updateEventLog, "tbsync.observer.eventlog.update");
+  },
+
+  updateEventLog: {
+    observe: function (aSubject, aTopic, aData) {
+      let events = TbSync.eventlog.get();
+      if (events.length > 0) {
+        let eventlog = document.getElementById('tbsync.eventlog');
+        eventlog.hidden = true;
+        
+        let item = tbSyncEventLog.addLogEntry(events[events.length-1]);
+        eventlog.appendChild(item);
+
+        eventlog.hidden = false;
+        eventlog.ensureIndexIsVisible(eventlog.getRowCount()-1);
+      }
+    }
+  },
+
+  
+  addLogEntry: function (entry) {
+    
+    //left column
+    let leftColumn = document.createXULElement("vbox");
+    //leftColumn.setAttribute("width", "24");
+    leftColumn.setAttribute("style", "width: 24px;");
+
+    let image = document.createXULElement("image");
+    let src = entry.type.endsWith("_rerun") ? "sync" : entry.type;
+    image.setAttribute("src", "chrome://tbsync/content/skin/" + src + "16.png");
+    image.setAttribute("style", "margin:4px 4px 4px 4px;");
+    leftColumn.appendChild(image);
+    
+    //right column        
+    let rightColumn = document.createXULElement("vbox");
+    rightColumn.setAttribute("flex","1");
+
+    let d = new Date(entry.timestamp);
+    let timestamp = document.createXULElement("description");
+    timestamp.setAttribute("flex", "1");
+    timestamp.setAttribute("class", "header");
+    timestamp.textContent = d.toLocaleTimeString();
+    rightColumn.appendChild(timestamp);
+
+      let hBox = document.createXULElement("hbox");
+      hBox.flex = "1";
+      let vBoxLeft = document.createXULElement("vbox");
+      vBoxLeft.flex = "1";
+      let vBoxRight = document.createXULElement("vbox");
+      
+      let msg = document.createXULElement("description");
+      msg.setAttribute("flex", "1");
+      msg.setAttribute("class", "header");
+      msg.textContent = entry.message;
+      vBoxLeft.appendChild(msg);
+
+      if (entry.link) {
+        let link = document.createXULElement("button");
+        link.setAttribute("label",  TbSync.getString("manager.help"));
+        link.setAttribute("oncommand",  "TbSync.manager.openLink('" + entry.link + "')");
+        vBoxRight.appendChild(link);
+      }
+
+      hBox.appendChild(vBoxLeft);
+      hBox.appendChild(vBoxRight);
+      rightColumn.appendChild(hBox);
+    
+    if (entry.accountname || entry.provider) {
+      let account = document.createXULElement("label");
+      if (entry.accountname) account.setAttribute("value",  "Account: " + entry.accountname + (entry.provider ? " (" + entry.provider.toUpperCase() + ")" : ""));
+      else account.setAttribute("value",  "Provider: " + entry.provider.toUpperCase());
+      rightColumn.appendChild(account);
+    }
+
+    if (entry.foldername) {
+      let folder = document.createXULElement("label");
+      folder.setAttribute("value",  "Resource: " + entry.foldername);
+      rightColumn.appendChild(folder);
+    }
+
+    if (entry.details) {
+      let lines = entry.details.split("\n");
+      let line = document.createElementNS("http://www.w3.org/1999/xhtml", "textarea");
+      line.setAttribute("readonly", "true");                
+      line.setAttribute("wrap", "off");                           
+      line.setAttribute("rows", lines.length);                
+      line.setAttribute("style", "font-family: monospace; font-size: 10px;");                
+      line.setAttribute("class", "plain");                
+      line.value = entry.details.trim();
+      
+      let container = document.createXULElement("vbox");
+      container.setAttribute("style", "margin-left:1ex;margin-top:1ex;");                
+      container.appendChild(line);
+      
+      rightColumn.appendChild(container);
+    }
+    
+    //columns
+    let columns = document.createXULElement("hbox");
+    columns.setAttribute("flex", "1");
+    columns.appendChild(leftColumn);
+    columns.appendChild(rightColumn);
+    
+    //richlistitem
+    let richlistitem = document.createXULElement("richlistitem");
+    richlistitem.setAttribute("style", "padding:4px; border-bottom: 1px solid lightgrey;");
+    richlistitem.appendChild(columns);
+    
+    return richlistitem;
+  },    
+};
diff --git a/content/manager/eventlog/eventlog.xhtml b/content/manager/eventlog/eventlog.xhtml
new file mode 100644
index 0000000..b71af18
--- /dev/null
+++ b/content/manager/eventlog/eventlog.xhtml
@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+
+<window
+    title="__TBSYNCMSG_eventlog.title__"
+    onload="tbSyncEventLog.onload();"
+    onunload="tbSyncEventLog.onunload();"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" >
+
+    <script type="application/javascript" src="chrome://tbsync/content/manager/eventlog/eventlog.js"/>
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+
+    <vbox flex="1">
+        <richlistbox id="tbsync.eventlog" style="padding:5px; height:360px" seltype="single" disabled="true"/>
+        <hbox style="padding: 5px">
+            <vbox flex="1"></vbox>
+            <button id="tbsync.eventlog.clear" label="__TBSYNCMSG_eventlog.clear__" />
+            <button id="tbsync.eventlog.close" label="__TBSYNCMSG_eventlog.close__" />
+        </hbox>
+    </vbox>
+</window>
diff --git a/content/manager/help.xhtml b/content/manager/help.xhtml
new file mode 100644
index 0000000..675bf53
--- /dev/null
+++ b/content/manager/help.xhtml
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window 
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    onload="tbSyncAccountManager.getLogPref();"
+    title="Help" >
+
+    <hbox flex="1" id="mainframe">
+        <vbox flex="1">
+
+            <html:p>
+                <html:b>__TBSYNCMSG_manager.help.needhelp__</html:b><html:br/><html:br/>
+                __TBSYNCMSG_manager.help.wiki__
+            </html:p>
+
+            <html:p onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="TbSync.manager.openTranslatedLink('https://github.com/jobisoft/TbSync/wiki');" style="color:blue;text-decoration: underline;padding-left:1em;margin:0 0 24px 0">
+                https://github.com/jobisoft/TbSync/wiki
+            </html:p>
+
+            <html:p>
+                <html:b>__TBSYNCMSG_manager.help.foundabug__</html:b><html:br/><html:br/>
+                <html:span>__TBSYNCMSG_manager.help.fixit__</html:span>
+            </html:p>
+
+            <hbox align="center">
+                <label value="__TBSYNCMSG_manager.help.debugmode__" />
+                <menulist flex="0" id="tbSyncAccountManager.logLevel" oncommand="tbSyncAccountManager.toggleLogPref();">
+                  <menupopup>
+                      <menuitem label="__TBSYNCMSG_manager.help.debuglevel.0__" value="0" />
+                      <menuitem label="__TBSYNCMSG_manager.help.debuglevel.1__" value="1" />
+                      <menuitem label="__TBSYNCMSG_manager.help.debuglevel.2__" value="2" />
+                      <menuitem label="__TBSYNCMSG_manager.help.debuglevel.3__" value="3" />
+                </menupopup>
+              </menulist>
+            </hbox>
+
+            <html:p> 
+                __TBSYNCMSG_manager.help.createbugreportinfo__
+            </html:p>     
+            
+            <hbox>
+                <button style="margin:0 0 0 1em; padding: 0 1ex;" label="__TBSYNCMSG_manager.help.createbugreport__" oncommand="TbSync.manager.openBugReportWizard();" />
+                <button style="margin:0 0 0 1em; padding: 0 1ex;" label="__TBSYNCMSG_manager.help.viewdebuglog__" oncommand="TbSync.manager.viewDebugLog();" />
+            </hbox>
+            
+            <hbox flex="1">
+            </hbox>  
+
+        </vbox>
+    </hbox>
+    
+    <script type="text/javascript" src="chrome://tbsync/content/manager/accountManager.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/installProvider.xhtml b/content/manager/installProvider.xhtml
new file mode 100644
index 0000000..9ccdd75
--- /dev/null
+++ b/content/manager/installProvider.xhtml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    onload="tbSyncManageProvider.prepInstall();"
+    title="Install additional synchronization provider for TbSync" >
+
+    <hbox flex="1" id="mainframe">
+        <vbox flex="1">
+
+            <hbox>
+              <html:p style="font-weight: bold" id="header"></html:p>
+            </hbox>
+
+            <html:p>
+                __TBSYNCMSG_manager.installprovider.link__
+            </html:p>
+            
+            <html:p id="link" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="TbSync.manager.prefWindowObj.tbSyncAccountManager.selectTab(0); TbSync.manager.openTBtab(this.getAttribute('link'));" style="color:blue;text-decoration: underline;padding-left:1em;">
+            </html:p>
+
+            <html:p id="warning" style="font-weight: bold">
+                __TBSYNCMSG_manager.installprovider.warning__
+            </html:p>
+
+        </vbox>
+    </hbox>
+    
+    <script type="text/javascript" src="chrome://tbsync/content/manager/manageProvider.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/manageProvider.js b/content/manager/manageProvider.js
new file mode 100644
index 0000000..01b3be5
--- /dev/null
+++ b/content/manager/manageProvider.js
@@ -0,0 +1,40 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+var tbSyncManageProvider = {
+  
+  prepInstall: function () {
+    let url = window.location.toString();
+    let provider = url.split("provider=")[1];
+    window.document.getElementById("header").textContent = TbSync.getString("installProvider.header::" + TbSync.providers.defaultProviders[provider].name);
+
+    window.document.getElementById("link").textContent = TbSync.providers.defaultProviders[provider].homepageUrl;
+    window.document.getElementById("link").setAttribute("link", TbSync.providers.defaultProviders[provider].homepageUrl);
+
+    window.document.getElementById("warning").hidden = TbSync.providers.defaultProviders[provider].homepageUrl.startsWith("https://addons.thunderbird.net"); 
+  },
+
+  prepMissing: function () {
+    let url = window.location.toString();
+    let provider = url.split("provider=")[1];
+
+    let e = window.document.getElementById("missing");
+    let v = e.textContent;
+    e.textContent = v.replace("##provider##", provider.toUpperCase());
+    
+    if (TbSync.providers.defaultProviders.hasOwnProperty(provider)) {
+      window.document.getElementById("link").textContent = TbSync.providers.defaultProviders[provider].homepageUrl;
+      window.document.getElementById("link").setAttribute("link", TbSync.providers.defaultProviders[provider].homepageUrl);
+    }
+    
+  },    
+};
diff --git a/content/manager/manager.css b/content/manager/manager.css
new file mode 100644
index 0000000..c6359bf
--- /dev/null
+++ b/content/manager/manager.css
@@ -0,0 +1,38 @@
+#manager {
+    margin:8px 12px 12px 12px;
+}
+
+#tbtoolbar {
+    border:1px solid darkgrey;
+    background-color: #ffffff; 
+    padding: 0; 
+    margin:0 0 12px 0;
+}
+
+#tbtoolbar vbox  {
+    margin: 0;
+    padding:6px 6px 2px 6px;
+    background-color: #ffffff;
+}
+
+#tbtoolbar vbox:hover  {
+    background-color: #e0e8f6;
+}
+
+#tbtoolbar vbox[active="true"]  {
+    background-color: #c1d2ee;
+}
+
+#mainframe {
+    padding:0 12px;
+    margin:0;
+}
+
+.row vbox {
+    width:140px;
+}
+
+iframe {
+    margin:0;
+    padding:0;
+}
diff --git a/content/manager/missingProvider.xhtml b/content/manager/missingProvider.xhtml
new file mode 100644
index 0000000..fbdc26f
--- /dev/null
+++ b/content/manager/missingProvider.xhtml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    onload="tbSyncManageProvider.prepMissing();"
+    title="TbSync Account Settings" >
+
+    <hbox flex="1" pack="center">
+        <vbox flex="1" pack="center">
+            <description style="text-align:center" id="missing">__TBSYNCMSG_manager.missingprovider__</description>
+            <html:p id="link" onmouseover="this.style.cursor='pointer'" onmouseout="this.style.cursor='default'" onclick="TbSync.manager.openTBtab(this.getAttribute('link'));" style="color:blue; text-decoration: underline; text-align:center;"></html:p>	             
+        </vbox>
+
+    </hbox>
+
+    <script type="text/javascript" src="chrome://tbsync/content/manager/manageProvider.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/noaccounts.xhtml b/content/manager/noaccounts.xhtml
new file mode 100644
index 0000000..2437218
--- /dev/null
+++ b/content/manager/noaccounts.xhtml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+
+<window
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    title="TbSync Account Settings" >
+
+    <hbox flex="1" pack="center">
+        <vbox flex="1" pack="center">
+             <description style="text-align:center">__TBSYNCMSG_manager.noaccounts__</description>	     
+        </vbox>
+    </hbox>
+    
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/manager/support-wizard/support-wizard.xhtml b/content/manager/support-wizard/support-wizard.xhtml
new file mode 100644
index 0000000..ce7ea27
--- /dev/null
+++ b/content/manager/support-wizard/support-wizard.xhtml
@@ -0,0 +1,44 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+
+<window
+  width="500"
+  height="600"
+  onload="tbSyncAccountManager.initSupportWizard();"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+  <linkset>
+    <html:link rel="localization" href="toolkit/global/wizard.ftl"/>
+  </linkset>
+  
+  <wizard 
+    id="SupportWizard" 
+    title="__TBSYNCMSG_supportwizard.title__">
+     
+    <wizardpage onFirstPage="true" label="__TBSYNCMSG_supportwizard.pagetitle__">
+      <label value="__TBSYNCMSG_supportwizard.label.faultycomponent__"/>
+      <menulist id="tbsync.supportwizard.faultycomponent.menulist">
+        <menupopup id="tbsync.supportwizard.faultycomponent">
+          <menuitem hidden="true" selected="true" label="__TBSYNCMSG_supportwizard.label.selectcomponent__" value="" />
+          <menuitem label="__TBSYNCMSG_manager.title__" value="core" />
+        </menupopup>
+      </menulist>    
+
+      <label style="margin-top:1em" value="__TBSYNCMSG_supportwizard.label.summary__"/>
+     <html:input id="tbsync.supportwizard.summary" oninput="tbSyncAccountManager.checkSupportWizard()" />
+    
+     <label style="margin-top:1em" value="__TBSYNCMSG_supportwizard.label.description__"/>
+     <html:textarea rows="15" style="margin-left: 1ex;" id="tbsync.supportwizard.description" />
+
+     <description style="margin-top:1em">
+      __TBSYNCMSG_supportwizard.footer__
+     </description>  
+    </wizardpage>
+
+  </wizard>
+
+  <script type="text/javascript" src="chrome://tbsync/content/manager/accountManager.js" /> 
+  <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+
+</window>
diff --git a/content/manager/supporter.xhtml b/content/manager/supporter.xhtml
new file mode 100644
index 0000000..a9bee40
--- /dev/null
+++ b/content/manager/supporter.xhtml
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/manager/manager.css" type="text/css"?>
+
+<window 
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    onload="tbSyncAccountManager.initCommunity();"
+    title="Community" >
+
+    <hbox flex="1" id="mainframe">
+        <vbox flex="1">
+            <html:p>
+                <html:b>__TBSYNCMSG_manager.supporter.contributors__</html:b>
+                <html:div id="listOfContributors" style="margin-top:10px">
+
+                  <html:div provider="" style="width:225px; margin: 0 0 10px 0; float:left;">
+                    <html:img 
+                    src="" 
+                    style="width:48px; height:48px; margin:4px 0 0 10px; float:left" 
+                    onclick="TbSync.manager.openLink(TbSync.providers.loadedProviders[this.parentNode.getAttribute('provider')].addon.homepageURL);" 
+                    onmouseover="this.style.cursor='pointer'" 
+                    onmouseout="this.style.cursor='default'" />
+                    <html:div style="padding-left: 65px;">
+                      <html:div>__TBSYNCMSG_manager.title__</html:div>
+                      <html:div style="font-style:italic">__TBSYNCMSG_manager.provider4tbsync__</html:div>
+                      <html:div style="font-style:italic;">[<html:span 
+                      onclick="TbSync.manager.openLink(TbSync.providers.loadedProviders[this.parentNode.parentNode.parentNode.getAttribute('provider')].addon.contributorsURL);" 
+                      onmouseover="this.style.cursor='pointer'" 
+                      onmouseout="this.style.cursor='default'"
+                      style="color:blue;text-decoration: underline;">__TBSYNCMSG_manager.supporter.details__</html:span>]</html:div>
+                    </html:div>
+                  </html:div>
+
+                  <html:div provider="" style="width:225px; margin: 0 0 10px 0; float:left;">
+                    <html:img 
+                    src="chrome://tbsync/content/skin/tbsync64.png" 
+                    style="width:48px; height:48px; margin:4px 0 0 10px; float:left" 
+                    onclick="TbSync.manager.openLink(TbSync.addon.homepageURL);" 
+                    onmouseover="this.style.cursor='pointer'" 
+                    onmouseout="this.style.cursor='default'" />
+                    <html:div style="padding-left: 65px;">
+                      <html:span></html:span>
+                      <html:div>TbSync</html:div>
+                      <html:div style="font-style:italic">__TBSYNCMSG_manager.shorttitle__</html:div>
+                      <html:div style="font-style:italic;">[<html:span 
+                      onclick="TbSync.manager.openLink(TbSync.addon.contributorsURL);" 
+                      onmouseover="this.style.cursor='pointer'" 
+                      onmouseout="this.style.cursor='default'"
+                      style="color:blue;text-decoration: underline;">__TBSYNCMSG_manager.supporter.details__</html:span>]</html:div>
+                    </html:div>
+                  </html:div>
+
+                </html:div> 
+            </html:p>
+
+
+            <html:p>
+                <html:b>__TBSYNCMSG_manager.supporter.sponsors__</html:b>
+                <html:div id="listOfSponsors" style="margin-top:10px">
+                  <html:div link="" style="width:225px; margin: 0 0 10px 0; float:left;">
+                    <html:img src="chrome://tbsync/content/skin/user48.png" style="width:48px; height:48px; padding:0px; margin:0 0 0 10px; border:1px solid #d3d3d3; float:left" onclick="if (this.parentNode.getAttribute('link') != '') {TbSync.manager.openLink(this.parentNode.getAttribute('link'));}" onmouseover="if (this.parentNode.getAttribute('link') != '') {this.style.cursor='pointer'}" onmouseout="this.style.cursor='default'" />
+                    <html:div style="padding-left: 65px;">
+                      <html:div >Name</html:div>
+                      <html:div style="font-style:italic">Description</html:div>
+                    </html:div>
+                  </html:div>
+                </html:div> 
+            </html:p>
+            
+        </vbox>
+    </hbox>
+    
+    <script type="text/javascript" src="chrome://tbsync/content/manager/accountManager.js" /> 
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+</window>
diff --git a/content/modules/addressbook.js b/content/modules/addressbook.js
new file mode 100644
index 0000000..d239a95
--- /dev/null
+++ b/content/modules/addressbook.js
@@ -0,0 +1,1149 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+
+ var { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  AddrBookCard: "resource:///modules/AddrBookCard.jsm"
+});
+
+var addressbook = {
+  
+  _notifications: [
+    "addrbook-directory-updated",
+    "addrbook-directory-deleted",
+    "addrbook-contact-created",
+    "addrbook-contact-updated",
+    "addrbook-contact-deleted",
+    "addrbook-list-member-added",
+    "addrbook-list-member-removed",
+    "addrbook-list-deleted",
+    "addrbook-list-updated",
+    "addrbook-list-created"
+  ],
+
+  load : async function () {
+    for (let topic of this._notifications) {
+      Services.obs.addObserver(this.addressbookObserver, topic);
+    }
+  },
+
+  unload : async function () {
+    for (let topic of this._notifications) {
+      Services.obs.removeObserver(this.addressbookObserver, topic);
+    }
+  },
+
+  getStringValue : function (ab, value, fallback) {
+    try {
+      return ab.getStringValue(value, fallback);
+    } catch (e) {
+      return fallback;
+    }
+  },
+
+  searchDirectory: function (uri, search) {
+    return new Promise((resolve, reject) => {
+      let listener = {
+        cards : [],
+        
+        onSearchFinished(aResult, aErrorMsg) {
+          resolve(this.cards);
+        },
+        onSearchFoundCard(aCard) {
+          this.cards.push(aCard.QueryInterface(Components.interfaces.nsIAbCard));
+        }
+      }
+    
+      let result = MailServices.ab.getDirectory(uri).search(search, "", listener);
+    });
+  },
+  
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * AdvancedTargetData, an extended TargetData implementation, providers
+  // * can use this as their own TargetData by extending it and just
+  // * defining the extra methods
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  
+  AdvancedTargetData : class {
+    constructor(folderData) {            
+      this._folderData = folderData;
+      this._targetObj = null;
+    }
+
+    
+    // Check, if the target exists and return true/false.
+    hasTarget() { 
+      let target = this._folderData.getFolderProperty("target");
+      let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(target);
+      return directory ? true : false;
+    }
+
+    // Returns the target obj, which TbSync should return as the target. It can
+    // be whatever you want and is returned by FolderData.targetData.getTarget().
+    // If the target does not exist, it should be created. Throw a simple Error, if that
+    // failed.
+    async getTarget() { 
+      let target = this._folderData.getFolderProperty("target");
+      let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(target);
+      
+      if (!directory) {
+        // create a new addressbook and store its UID in folderData
+        directory = await TbSync.addressbook.prepareAndCreateAddressbook(this._folderData);
+        if (!directory)
+          throw new Error("notargets");
+      }
+      
+      if (!this._targetObj || this._targetObj.UID != directory.UID)
+        this._targetObj = new TbSync.addressbook.AbDirectory(directory, this._folderData);
+
+      return this._targetObj;
+    }
+    
+    /**
+     * Removes the target from the local storage. If it does not exist, return
+     * silently. A call to ``hasTarget()`` should return false, after this has
+     * been executed.
+     *
+     */
+    removeTarget() {
+      let target = this._folderData.getFolderProperty("target");
+      let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(target);
+      try {
+        if (directory) {
+          MailServices.ab.deleteAddressBook(directory.URI);
+        }
+      } catch (e) {}
+
+      TbSync.db.clearChangeLog(target);
+      this._folderData.resetFolderProperty("target");        
+    }
+    
+    /**
+     * Disconnects the target in the local storage from this TargetData, but
+     * does not delete it, so it becomes a stale "left over" . A call
+     * to ``hasTarget()`` should return false, after this has been executed.
+     * 
+     */
+    disconnectTarget() {
+      let target = this._folderData.getFolderProperty("target");
+      let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(target);
+      if (directory) {
+        let changes = TbSync.db.getItemsFromChangeLog(target, 0, "_by_user");        
+        if (changes.length > 0) {
+          this.targetName = this.targetName + " (*)";
+        }        
+        directory.setStringValue("tbSyncIcon", "orphaned");
+        directory.setStringValue("tbSyncProvider", "orphaned");
+        directory.setStringValue("tbSyncAccountID", "");
+      }
+      TbSync.db.clearChangeLog(target);
+      this._folderData.resetFolderProperty("target");      
+    }     
+    
+    set targetName(newName) {
+      let target = this._folderData.getFolderProperty("target");
+      let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(target);
+      if (directory) {
+        directory.dirName = newName;
+      } else {
+        throw new Error("notargets");
+      }
+    }
+  
+    get targetName() {
+      let target = this._folderData.getFolderProperty("target");
+      let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(target);
+      if (directory) {
+        return directory.dirName;
+      } else {
+        throw new Error("notargets");
+      }
+    }
+    
+    setReadOnly(value) {
+    }
+
+
+    // * * * * * * * * * * * * * * * * *
+    // * AdvancedTargetData extension  * 
+    // * * * * * * * * * * * * * * * * *
+    
+    get isAdvancedAddressbookTargetData() {
+      return true;
+    }
+    
+    get folderData() {
+      return this._folderData;
+    }
+    
+    // define a card property, which should be used for the changelog
+    // basically your primary key for the abItem properties
+    // UID will be used, if nothing specified
+    get primaryKeyField() {
+      return "UID";
+    }
+
+    generatePrimaryKey() {
+       return TbSync.generateUUID();
+    }
+        
+    // enable or disable changelog
+    get logUserChanges() {
+      return true;
+    }
+
+    directoryObserver(aTopic) {
+      switch (aTopic) {
+        case "addrbook-directory-deleted":
+        case "addrbook-directory-updated":
+          //Services.console.logStringMessage("["+ aTopic + "] " + folderData.getFolderProperty("foldername"));
+          break;
+      }
+    }
+        
+    cardObserver(aTopic, abCardItem) {
+      switch (aTopic) {
+        case "addrbook-contact-updated":
+        case "addrbook-contact-deleted":
+        case "addrbook-contact-created":
+          //Services.console.logStringMessage("["+ aTopic + "] " + abCardItem.getProperty("DisplayName"));
+          break;
+      }
+    }
+
+    listObserver(aTopic, abListItem, abListMember) {
+      switch (aTopic) {
+        case "addrbook-list-member-added":
+        case "addrbook-list-member-removed":
+          //Services.console.logStringMessage("["+ aTopic + "] MemberName: " + abListMember.getProperty("DisplayName"));
+          break;
+        
+        case "addrbook-list-deleted":
+        case "addrbook-list-updated":
+          //Services.console.logStringMessage("["+ aTopic + "] ListName: " + abListItem.getProperty("ListName"));
+          break;
+        
+        case "addrbook-list-created": 
+          //Services.console.logStringMessage("["+ aTopic + "] Created new X-DAV-UID for List <"+abListItem.getProperty("ListName")+">");
+          break;
+      }
+    }
+
+    // replace this with your own implementation to create the actual addressbook,
+    // when this class is extended
+    async createAddressbook(newname) {
+      // https://searchfox.org/comm-central/source/mailnews/addrbook/src/nsDirPrefs.h
+      let dirPrefId = MailServices.ab.newAddressBook(newname, "", 101);
+      let directory = MailServices.ab.getDirectoryFromId(dirPrefId);
+      return directory;
+    }    
+  },
+
+
+
+
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * AbItem and AbDirectory Classes
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  
+  AbItem : class {
+    constructor(abDirectory, item) {
+      if (!abDirectory)
+        throw new Error("AbItem::constructor is missing its first parameter!");
+
+      if (!item)
+        throw new Error("AbItem::constructor is missing its second parameter!");
+
+      this._abDirectory = abDirectory;
+      this._card = null;
+      this._tempListDirectory = null;
+      this._tempProperties = null;
+      this._isMailList = false;
+      
+      if (item instanceof Components.interfaces.nsIAbDirectory) {
+        this._tempListDirectory = item;
+        this._isMailList = true;
+        this._tempProperties = {};
+      } else {
+        this._card = item;
+        this._isMailList = item.isMailList;
+      }
+    }
+    
+    get abDirectory() {
+      return this._abDirectory;
+    }
+    
+    get isMailList() {
+      return this._isMailList;
+    }
+
+
+
+
+
+    get nativeItem() {
+      return this._card;
+    }
+
+    get UID() {
+      if (this._tempListDirectory) return this._tempListDirectory.UID;
+      return this._card.UID;
+    }
+    
+    get primaryKey() {
+      //use UID as fallback
+      let key = this._abDirectory.primaryKeyField;
+      return key ? this.getProperty(key) : this.UID;  
+    }
+
+    set primaryKey(value) {
+      //use UID as fallback
+      let key = this._abDirectory.primaryKeyField;
+      if (key) this.setProperty(key, value)
+      else throw ("TbSync.addressbook.AbItem.set primaryKey: UID is used as primaryKeyField but changing the UID of an item is currently not supported. Please use a custom primaryKeyField.");
+    }
+
+    clone() { //no real clone ... this is just here to match the calendar target
+      return new TbSync.addressbook.AbItem(this._abDirectory, this._card);
+    }
+    
+    toString() {
+      return this._card.displayName + " (" + this._card.firstName + ", " + this._card.lastName + ") <"+this._card.primaryEmail+">";
+    }
+    
+    // mailinglist aware method to get properties of cards
+    // mailinglist properties cannot be stored in mailinglists themselves, so we store them in changelog
+    getProperty(property, fallback = "") {
+      if (property == "UID")
+        return this.UID;
+      
+      if (this._isMailList) {
+        const directListProperties = {
+          ListName: "dirName",
+          ListNickName: "listNickName",
+          ListDescription: "description"
+        };
+        
+        let value;
+        if (directListProperties.hasOwnProperty(property)) {
+          try {
+            let mailListDirectory = this._tempListDirectory || MailServices.ab.getDirectory(this._card.mailListURI); //this._card.asDirectory
+            value = mailListDirectory[directListProperties[property]];
+          } catch (e) {
+            // list does not exists
+          }
+        } else {
+          value = this._tempProperties ? this._tempProperties[property] : TbSync.db.getItemStatusFromChangeLog(this._abDirectory.UID + "#" + this.UID, property);
+        }
+        return value || fallback;        
+      } else {
+        return this._card.getProperty(property, fallback);
+      }
+    }
+
+    // mailinglist aware method to set properties of cards
+    // mailinglist properties cannot be stored in mailinglists themselves, so we store them in changelog
+    // while the list has not been added, we keep all props in an object (UID changes on adding)
+    setProperty(property, value) {
+      // UID cannot be changed (currently)
+      if (property == "UID") {
+        throw ("TbSync.addressbook.AbItem.setProperty: UID cannot be changed currently.");
+        return;
+      }
+      
+      if (this._isMailList) {
+        const directListProperties = {
+          ListName: "dirName",
+          ListNickName: "listNickName",
+          ListDescription: "description"
+        };
+        
+        if (directListProperties.hasOwnProperty(property)) {
+          try {
+            let mailListDirectory = this._tempListDirectory || MailServices.ab.getDirectory(this._card.mailListURI);
+            mailListDirectory[directListProperties[property]] = value;
+          } catch (e) {
+            // list does not exists
+          }     
+        } else {
+            if (this._tempProperties) {
+              this._tempProperties[property] = value;
+            } else {
+               TbSync.db.addItemToChangeLog(this._abDirectory.UID + "#" + this.UID, property, value);
+            }
+        }
+      } else {
+        this._card.setProperty(property, value);
+      }
+    }
+    
+    deleteProperty(property) {
+      if (this._isMailList) {
+        if (this._tempProperties) {
+          delete this._tempProperties[property];
+        } else {
+          TbSync.db.removeItemFromChangeLog(this._abDirectory.UID + "#" + this.UID, property);
+        }
+      } else {
+        this._card.deleteProperty(property);
+      }
+    }
+   
+    get changelogData() {         
+      return TbSync.db.getItemDataFromChangeLog(this._abDirectory.UID, this.primaryKey);
+    }
+
+    get changelogStatus() {         
+      return TbSync.db.getItemStatusFromChangeLog(this._abDirectory.UID, this.primaryKey);
+    }
+
+    set changelogStatus(status) {            
+      let value = this.primaryKey;
+                  
+      if (value) {
+        if (!status) {
+          TbSync.db.removeItemFromChangeLog(this._abDirectory.UID, value);
+          return;
+        }
+
+        if (this._abDirectory.logUserChanges || status.endsWith("_by_server")) {
+          TbSync.db.addItemToChangeLog(this._abDirectory.UID, value, status);
+        }
+      }
+    }    
+
+
+
+
+
+    // get the property given from all members and return it as an array (that property better be uniqe)
+    getMembersPropertyList(property) {
+      let members = [];
+      if (this._card && this._card.isMailList) {
+        // get mailListDirectory
+        let mailListDirectory = MailServices.ab.getDirectory(this._card.mailListURI);
+        for (let member of mailListDirectory.childCards) {
+          let prop = member.getProperty(property, "");
+          if (prop) members.push(prop);
+        }
+      }
+      return members;
+    }
+    
+    addListMembers(property, candidates) {
+      if (this._card && this._card.isMailList) {            
+        let members = this.getMembersPropertyList(property);
+        let mailListDirectory = MailServices.ab.getDirectory(this._card.mailListURI);
+
+        for (let candidate of candidates) {
+          if (members.includes(candidate))
+            continue;
+
+          let card = this._abDirectory._directory.getCardFromProperty(property, candidate, true);
+          if (card) mailListDirectory.addCard(card);
+        }
+      }
+    }
+
+    removeListMembers(property, candidates) {
+      if (this._card && this._card.isMailList) {
+        let members = this.getMembersPropertyList(property);
+        let mailListDirectory = MailServices.ab.getDirectory(this._card.mailListURI);
+
+        let cardsToRemove = [];
+        for (let candidate of candidates) {
+          if (!members.includes(candidate))
+            continue;
+
+          let card = this._abDirectory._directory.getCardFromProperty(property, candidate, true);
+          if (card) cardsToRemove.push(card);
+        }
+        if (cardsToRemove.length > 0) mailListDirectory.deleteCards(cardsToRemove);        
+      }
+    }
+       
+    addPhoto(photo, data, extension = "jpg", url = "") {	
+      let dest = [];
+      let card = this._card;
+      let bookUID = this.abDirectory.UID;
+
+      // TbSync storage must be set as last
+      let book64 = btoa(bookUID);
+      let photo64 = btoa(photo);	    
+      let photoName64 = book64 + "_" + photo64 + "." + extension;
+      
+      dest.push(["Photos", photoName64]);
+      // I no longer see a reason for this
+      // dest.push(["TbSync","Photos", book64, photo64]);
+      
+      let filePath = "";
+      for (let i=0; i < dest.length; i++) {
+        let file = FileUtils.getFile("ProfD",  dest[i]);
+
+        let foStream = Components.classes["@mozilla.org/network/file-output-stream;1"].createInstance(Components.interfaces.nsIFileOutputStream);
+        foStream.init(file, 0x02 | 0x08 | 0x20, 0x180, 0); // write, create, truncate
+        let binary = "";
+        try {
+          binary = atob(data.split(" ").join(""));
+        } catch (e) {
+          console.log("Failed to decode base64 string:", data);
+        }
+        foStream.write(binary, binary.length);
+        foStream.close();
+
+        filePath = 'file:///' + file.path.replace(/\\/g, '\/').replace(/^\s*\/?/, '').replace(/\ /g, '%20');
+      }
+      card.setProperty("PhotoName", photoName64);
+      card.setProperty("PhotoType", url ? "web" : "file");
+      card.setProperty("PhotoURI", url ? url : filePath);
+      return filePath;
+    }
+
+    getPhoto() {	
+      let card = this._card;
+      let photo = card.getProperty("PhotoName", "");
+      let data = "";
+
+      if (photo) {
+        try {
+          let file = FileUtils.getFile("ProfD", ["Photos", photo]);
+
+          let fiStream = Components.classes["@mozilla.org/network/file-input-stream;1"].createInstance(Components.interfaces.nsIFileInputStream);
+          fiStream.init(file, -1, -1, false);
+          
+          let bstream = Components.classes["@mozilla.org/binaryinputstream;1"].createInstance(Components.interfaces.nsIBinaryInputStream);
+          bstream.setInputStream(fiStream);
+
+          data = btoa(bstream.readBytes(bstream.available()));
+          fiStream.close();
+        } catch (e) {}
+      }
+      return data;
+    }
+  },
+
+  AbDirectory : class {
+    constructor(directory, folderData) {
+      this._directory = directory;
+      this._folderData = folderData;
+     }
+
+    get directory() {
+      return this._directory;
+    }
+    
+    get logUserChanges() {
+      return this._folderData.targetData.logUserChanges;
+    }
+    
+    get primaryKeyField() {
+      return this._folderData.targetData.primaryKeyField;
+    }
+    
+    get UID() {
+      return this._directory.UID;
+    }
+
+    get URI() {
+      return this._directory.URI;
+    }
+
+    createNewCard() {
+      let card = new AddrBookCard();
+      return new TbSync.addressbook.AbItem(this, card);
+    }
+
+    createNewList() {
+      let listDirectory = Components.classes["@mozilla.org/addressbook/directoryproperty;1"].createInstance(Components.interfaces.nsIAbDirectory);
+      listDirectory.isMailList = true;
+      return new TbSync.addressbook.AbItem(this, listDirectory);
+    }
+
+    async addItem(abItem, pretagChangelogWithByServerEntry = true) {
+      if (this.primaryKeyField && !abItem.getProperty(this.primaryKeyField)) {
+        abItem.setProperty(this.primaryKeyField, this._folderData.targetData.generatePrimaryKey());
+        //Services.console.logStringMessage("[AbDirectory::addItem] Generated primary key!");
+      }
+      
+      if (pretagChangelogWithByServerEntry) {
+        abItem.changelogStatus = "added_by_server";
+      }
+      
+      if (abItem.isMailList && abItem._tempListDirectory) {
+        let list = this._directory.addMailList(abItem._tempListDirectory);
+        // the list has been added and we can now get the corresponding card via its UID
+        let found = await this.getItemFromProperty("UID", list.UID);
+        
+        // clone and clear temporary properties
+        let props = {...abItem._tempProperties};
+        abItem._tempListDirectory = null;
+        abItem._tempProperties = null;
+        
+        // store temporary properties
+        for (const [property, value] of Object.entries(props)) {
+          found.setProperty(property, value);
+        }
+
+        abItem._card = found._card;
+      } else if (!abItem.isMailList) {
+        this._directory.addCard(abItem._card);
+
+      } else {
+        throw new Error("Cannot re-add a list to a directory.");
+      }
+    }
+    
+    modifyItem(abItem, pretagChangelogWithByServerEntry = true) {
+      // only add entry if the current entry does not start with _by_user
+      let status = abItem.changelogStatus ? abItem.changelogStatus : "";
+      if (pretagChangelogWithByServerEntry && !status.endsWith("_by_user")) {
+        abItem.changelogStatus = "modified_by_server";
+      }
+      
+      if (abItem.isMailList) {                
+        // get mailListDirectory
+        let mailListDirectory = MailServices.ab.getDirectory(abItem._card.mailListURI);
+
+        // store
+        mailListDirectory.editMailListToDatabase(abItem._card);
+      } else {
+        this._directory.modifyCard(abItem._card); 
+      }
+    }        
+    
+    deleteItem(abItem, pretagChangelogWithByServerEntry = true) {
+      if (pretagChangelogWithByServerEntry) {
+        abItem.changelogStatus = "deleted_by_server";
+      }
+      this._directory.deleteCards([abItem._card]);
+    }
+
+    async getItem(searchId) {
+      //use UID as fallback
+      let key = this.primaryKeyField ? this.primaryKeyField : "UID";
+      return await this.getItemFromProperty(key, searchId);
+    }
+
+    async getItemFromProperty(property, value) {
+      // try to use the standard card method first
+      let card = this._directory.getCardFromProperty(property, value, true);
+      if (card) {
+        return new TbSync.addressbook.AbItem(this, card);
+      }
+      
+      // search for list cards
+      // we cannot search for the prop directly, because for mailinglists
+      // they are not part of the card (expect UID) but stored in a custom storage
+      let searchList = "(IsMailList,=,TRUE)"; 
+      let foundCards = await TbSync.addressbook.searchDirectory(this._directory.URI, "(or" + searchList+")");
+      for (let aCard of foundCards) {
+        let card = new TbSync.addressbook.AbItem(this, aCard);
+        //does this list card have the req prop?
+        if (card.getProperty(property) == value) {
+          return card;
+        }
+      }
+      return null;
+    }
+    
+    getAllItems () {
+      let rv = [];
+      for (let card of this._directory.childCards) {
+        rv.push(new TbSync.addressbook.AbItem( this._directory, card ));
+      }
+      return rv;
+    }
+
+
+
+
+
+    getAddedItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this._directory.UID, maxitems, "added_by_user").map(item => item.itemId);
+    }
+
+    getModifiedItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this._directory.UID, maxitems, "modified_by_user").map(item => item.itemId);
+    }
+    
+    getDeletedItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this._directory.UID, maxitems, "deleted_by_user").map(item => item.itemId);
+    }
+    
+    getItemsFromChangeLog(maxitems = 0) { // Document what this returns         
+      return TbSync.db.getItemsFromChangeLog(this._directory.UID, maxitems, "_by_user");
+    }
+
+    removeItemFromChangeLog(id, moveToEndInsteadOfDelete = false) {             
+      TbSync.db.removeItemFromChangeLog(this._directory.UID, id, moveToEndInsteadOfDelete);
+    }
+    
+    clearChangelog() {
+      TbSync.db.clearChangeLog(this._directory.UID);
+    }
+    
+  },
+
+
+
+
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * Internal Functions
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+  prepareAndCreateAddressbook: async function (folderData) {
+    let target = folderData.getFolderProperty("target");
+    let provider = folderData.accountData.getAccountProperty("provider");
+    
+    // Get cached or new unique name for new address book
+    let cachedName = folderData.getFolderProperty("targetName");                         
+    let newname = cachedName == "" ? folderData.accountData.getAccountProperty("accountname") + " (" + folderData.getFolderProperty("foldername")+ ")" : cachedName;
+   
+    //Create the new book with the unique name
+    let directory = await folderData.targetData.createAddressbook(newname);
+    if (directory && directory instanceof Components.interfaces.nsIAbDirectory) {
+      directory.setStringValue("tbSyncProvider", provider);
+      directory.setStringValue("tbSyncAccountID", folderData.accountData.accountID);
+      
+      // Prevent gContactSync to inject its stuff into New/EditCard dialogs
+      // https://github.com/jdgeenen/gcontactsync/pull/127
+      directory.setStringValue("gContactSyncSkipped", "true");
+
+      folderData.setFolderProperty("target", directory.UID);            
+      folderData.setFolderProperty("targetName", directory.dirName);
+      //notify about new created address book
+      Services.obs.notifyObservers(null, 'tbsync.observer.addressbook.created', null)
+      return directory;
+    }
+    
+    return null;
+  },
+
+  getFolderFromDirectoryUID: function(bookUID) {
+    let folders = TbSync.db.findFolders({"target": bookUID});
+    if (folders.length == 1) {
+      let accountData = new TbSync.AccountData(folders[0].accountID);
+      return new TbSync.FolderData(accountData, folders[0].folderID);
+    }
+    return null;
+  },
+  
+  getDirectoryFromDirectoryUID: function(UID) {
+    if (!UID)
+      return null;
+
+    for (let directory of MailServices.ab.directories) {
+      if (directory instanceof Components.interfaces.nsIAbDirectory) {
+        if (directory.UID == UID) return directory;
+      }
+    }       
+    return null;
+  },
+  
+  getListInfoFromListUID: async function(UID) {
+    for (let directory of MailServices.ab.directories) {
+      if (directory instanceof Components.interfaces.nsIAbDirectory && !directory.isRemote) {
+        let searchList = "(IsMailList,=,TRUE)";
+        let foundCards = await TbSync.addressbook.searchDirectory(directory.URI, "(and" + searchList+")");
+        for (let listCard of foundCards) {
+          //return after first found card
+          if (listCard.UID == UID) return {directory, listCard};
+        }
+      }
+    }       
+    throw new Error("List with UID <" + UID + "> does not exists");
+  },
+
+
+
+
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * Addressbook Observer and Listener
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  
+  addressbookObserver: {
+    observe: async function (aSubject, aTopic, aData) {
+      switch (aTopic) {
+        // we do not need addrbook-created
+        case "addrbook-directory-updated":
+        case "addrbook-directory-deleted":
+        {
+          //aSubject: nsIAbDirectory (we can get URI and UID directly from the object, but the directory no longer exists)
+          aSubject.QueryInterface(Components.interfaces.nsIAbDirectory);
+          let bookUID = aSubject.UID;
+          
+          let folderData = TbSync.addressbook.getFolderFromDirectoryUID(bookUID);
+          if (folderData 
+            && folderData.targetData 
+            && folderData.targetData.isAdvancedAddressbookTargetData) {
+              
+            switch(aTopic) {
+              case "addrbook-directory-updated": 
+              {
+                //update name of target (if changed)
+                folderData.setFolderProperty("targetName", aSubject.dirName);                         
+                //update settings window, if open
+                 Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folderData.accountID);
+              }
+              break;
+
+              case "addrbook-directory-deleted": 
+              {
+                //delete any pending changelog of the deleted book
+                TbSync.db.clearChangeLog(bookUID);			
+
+                //unselect book if deleted by user and update settings window, if open
+                if (folderData.getFolderProperty("selected")) {
+                  folderData.setFolderProperty("selected", false);
+                  //update settings window, if open
+                  Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folderData.accountID);
+                }
+                
+                folderData.resetFolderProperty("target");
+              }
+              break;
+            }
+            
+            folderData.targetData.directoryObserver(aTopic);                        
+          }
+        }
+        break;             
+
+        case "addrbook-contact-created":
+        case "addrbook-contact-updated":
+        case "addrbook-contact-deleted":
+        {
+          //aSubject: nsIAbCard
+          aSubject.QueryInterface(Components.interfaces.nsIAbCard);
+          //aData: 128-bit unique identifier for the parent directory
+          let bookUID = aData;
+
+          let folderData = TbSync.addressbook.getFolderFromDirectoryUID(bookUID);                    
+          if (folderData 
+            && folderData.targetData 
+            && folderData.targetData.isAdvancedAddressbookTargetData) {
+            
+            let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(bookUID);
+            let abDirectory = new TbSync.addressbook.AbDirectory(directory, folderData);
+            let abItem = new TbSync.addressbook.AbItem(abDirectory, aSubject);
+            let itemStatus = abItem.changelogStatus || "";
+
+            // during create the following can happen
+            // card has no primary key
+            // another process could try to mod
+            //  -> we need to identify this card with an always available ID and block any other MODS until we free it again
+            // -> store creation type
+            
+            if (aTopic == "addrbook-contact-created" && itemStatus ==  "") {
+              // add this new card to changelog to keep track of it
+              TbSync.db.addItemToChangeLog(bookUID, aSubject.UID + "#DelayedUserCreation", Date.now());
+              // new cards must get a NEW(!) primaryKey first
+              if (abDirectory.primaryKeyField) {
+                console.log("New primary Key generated!");
+                abItem.setProperty(abDirectory.primaryKeyField, folderData.targetData.generatePrimaryKey());
+              }
+              // special case: do not add "modified_by_server"
+              abDirectory.modifyItem(abItem, /*pretagChangelogWithByServerEntry */ false);
+              // We will see this card again as updated but delayed created
+              return;
+            }
+
+            // during follow up MODs we can identify this card via
+            let delayedUserCreation = TbSync.db.getItemStatusFromChangeLog(bookUID, aSubject.UID + "#DelayedUserCreation");
+            
+            // if we reach this point and if we have adelayedUserCreation,
+            // we can remove the delayedUserCreation marker and can 
+            // continue to process this event as an addrbook-contact-created
+            let bTopic = aTopic;
+            if (delayedUserCreation) {
+              let age = Date.now() - delayedUserCreation;
+              if (age < 1500) {
+                bTopic = "addrbook-contact-created";
+              } else {
+                TbSync.db.removeItemFromChangeLog(bookUID, aSubject.UID + "#DelayedUserCreation");
+              }
+            }
+            
+            // if this card was created by us, it will be in the log
+            // we want to ignore any MOD for a freeze time, because
+            // gContactSync modifies our(!) contacts (GoogleID) after we added them, so they get
+            // turned into "modified_by_user" and will be send back to the server.
+            if (itemStatus && itemStatus.endsWith("_by_server")) {
+              let age = Date.now() - abItem.changelogData.timestamp;
+              if (age < 1500) {
+                // during freeze, local modifications are not possible
+                return;
+              } else {
+                // remove blocking entry from changelog after freeze time is over (1.5s),
+                // and continue evaluating this event
+                abItem.changelogStatus = "";
+              }
+            }
+            
+            // From here on, we only process user changes as server changes are self freezed            
+            // update changelog based on old status
+            switch (bTopic) {
+              case "addrbook-contact-created":
+              {
+                switch (itemStatus) {
+                  case "added_by_user": 
+                    // late create notification
+                    break;
+
+                  case "modified_by_user": 
+                    // late create notification
+                    abItem.changelogStatus = "added_by_user";
+                    break;
+
+                  case "deleted_by_user":
+                    // unprocessed delete for this card, undo the delete (moved out and back in)
+                    abItem.changelogStatus = "modified_by_user";
+                    break;
+                  
+                  default:
+                    // new card
+                    abItem.changelogStatus = "added_by_user";
+                }
+              }
+              break;
+
+              case "addrbook-contact-updated":
+              {
+                switch (itemStatus) {
+                  case "added_by_user": 
+                    // unprocessed add for this card, keep status
+                    break;
+
+                  case "modified_by_user": 
+                    // double notification, keep status
+                    break;
+
+                  case "deleted_by_user":
+                    // race? unprocessed delete for this card, moved out and back in and modified
+                  default: 
+                    abItem.changelogStatus = "modified_by_user";
+                    break;
+                }
+              }
+              break;
+              
+              case "addrbook-contact-deleted":
+              {
+                switch (itemStatus) {
+                  case "added_by_user": 
+                    // unprocessed add for this card, revert
+                    abItem.changelogStatus = "";
+                    return;
+
+                  case "deleted_by_user":
+                    // double notification
+                    break;
+                  
+                  case "modified_by_user": 
+                    // unprocessed mod for this card
+                  default: 
+                    abItem.changelogStatus = "deleted_by_user";
+                    break;
+                }
+              }
+              break;
+            }
+
+            if (abDirectory.logUserChanges) TbSync.core.setTargetModified(folderData);
+            
+            // notify observers only if status changed
+            if (itemStatus != abItem.changelogStatus) {
+              folderData.targetData.cardObserver(bTopic, abItem);
+            }
+            return;
+          }
+        }
+        break;
+
+        case "addrbook-list-created": 
+        case "addrbook-list-deleted": 
+        {
+          //aSubject: nsIAbDirectory
+          aSubject.QueryInterface(Components.interfaces.nsIAbDirectory);
+          //aData: 128-bit unique identifier for the parent directory
+          let bookUID = aData;
+
+          let folderData = TbSync.addressbook.getFolderFromDirectoryUID(bookUID);
+          if (folderData 
+            && folderData.targetData 
+            && folderData.targetData.isAdvancedAddressbookTargetData) {
+
+            let directory = TbSync.addressbook.getDirectoryFromDirectoryUID(bookUID);
+            let abDirectory = new TbSync.addressbook.AbDirectory(directory, folderData);
+            let abItem = new TbSync.addressbook.AbItem(abDirectory, aSubject);
+          
+            let itemStatus = abItem.changelogStatus;
+            if (itemStatus && itemStatus.endsWith("_by_server")) {
+              //we caused this, ignore
+              abItem.changelogStatus = "";
+              return;
+            }
+
+            // update changelog based on old status
+            switch (aTopic) {
+              case "addrbook-list-created":
+              {               
+                if (abDirectory.primaryKeyField) {
+                  // Since we do not need to update a list, to make custom properties persistent, we do not need to use delayedUserCreation as with contacts.
+                  abItem.setProperty(abDirectory.primaryKeyField, folderData.targetData.generatePrimaryKey());
+                }
+                
+                switch (itemStatus) {
+                  case "added_by_user": 
+                    // double notification, which is probably impossible, keep status
+                    break;
+
+                  case "modified_by_user": 
+                    // late create notification
+                    abItem.changelogStatus = "added_by_user";
+                    break;
+
+                  case "deleted_by_user":
+                    // unprocessed delete for this card, undo the delete (moved out and back in)
+                    abItem.changelogStatus = "modified_by_user";
+                    break;
+                  
+                  default:
+                    // new list
+                    abItem.changelogStatus = "added_by_user";
+                    break;
+                }
+              }
+              break;
+
+              case "addrbook-list-deleted":
+              {
+                switch (itemStatus) {
+                  case "added_by_user": 
+                    // unprocessed add for this card, revert
+                    abItem.changelogStatus = "";
+                    return;
+
+                  case "modified_by_user": 
+                    // unprocessed mod for this card
+                  case "deleted_by_user":
+                    // double notification
+                  default: 
+                    abItem.changelogStatus = "deleted_by_user";
+                    break;
+                }
+                //remove properties of this ML stored in changelog
+                TbSync.db.clearChangeLog(abDirectory.UID + "#" + abItem.UID);                
+              }
+              break;
+            }
+
+            if (abDirectory.logUserChanges) TbSync.core.setTargetModified(folderData);
+            folderData.targetData.listObserver(aTopic, abItem, null);
+          }
+        }
+        break;
+
+        case "addrbook-list-updated": 
+        {
+          // aSubject: nsIAbDirectory
+          aSubject.QueryInterface(Components.interfaces.nsIAbDirectory);
+          // get the card representation of this list, including its parent directory
+          let listInfo = await TbSync.addressbook.getListInfoFromListUID(aSubject.UID);
+          let bookUID = listInfo.directory.UID;
+
+          let folderData = TbSync.addressbook.getFolderFromDirectoryUID(bookUID);
+          if (folderData 
+            && folderData.targetData 
+            && folderData.targetData.isAdvancedAddressbookTargetData) {
+
+            let abDirectory = new TbSync.addressbook.AbDirectory(listInfo.directory, folderData);
+            let abItem = new TbSync.addressbook.AbItem(abDirectory, listInfo.listCard);
+
+            let itemStatus = abItem.changelogStatus;
+            if (itemStatus && itemStatus.endsWith("_by_server")) {
+              //we caused this, ignore
+              abItem.changelogStatus = "";
+              return;
+            }
+
+            // update changelog based on old status
+            switch (aTopic) {
+              case "addrbook-list-updated":
+              {
+                switch (itemStatus) {
+                  case "added_by_user": 
+                    // unprocessed add for this card, keep status
+                    break;
+
+                  case "modified_by_user": 
+                    // double notification, keep status
+                    break;
+
+                  case "deleted_by_user":
+                    // race? unprocessed delete for this card, moved out and back in and modified
+                  default: 
+                    abItem.changelogStatus = "modified_by_user";
+                    break;
+                }
+              }
+              break;
+            }
+            
+            if (abDirectory.logUserChanges) TbSync.core.setTargetModified(folderData);
+            folderData.targetData.listObserver(aTopic, abItem, null);
+          }
+        }
+        break;
+        
+        // unknown, if called for programmatically added members as well, probably not
+        case "addrbook-list-member-added": //exclude contact without Email - notification is wrongly send
+        case "addrbook-list-member-removed":
+        {
+          //aSubject: nsIAbCard of Member
+          aSubject.QueryInterface(Components.interfaces.nsIAbCard);
+          //aData: 128-bit unique identifier for the list
+          let listInfo = await TbSync.addressbook.getListInfoFromListUID(aData);
+          let bookUID = listInfo.directory.UID;
+
+          let folderData = TbSync.addressbook.getFolderFromDirectoryUID(bookUID);
+          if (folderData 
+            && folderData.targetData 
+            && folderData.targetData.isAdvancedAddressbookTargetData) {
+            
+            let abDirectory = new TbSync.addressbook.AbDirectory(listInfo.directory, folderData);
+            let abItem = new TbSync.addressbook.AbItem(abDirectory, listInfo.listCard);
+            let abMember = new TbSync.addressbook.AbItem(abDirectory, aSubject);
+
+            if (abDirectory.logUserChanges) TbSync.core.setTargetModified(folderData);
+            folderData.targetData.listObserver(aTopic, abItem, abMember);
+
+            // removed, added members cause the list to be changed
+            let mailListDirectory = MailServices.ab.getDirectory(listInfo.listCard.mailListURI);
+            TbSync.addressbook.addressbookObserver.observe(mailListDirectory, "addrbook-list-updated", null);
+            return;
+          }
+        }
+        break;
+
+      }
+    }
+  },
+  
+}
diff --git a/content/modules/core.js b/content/modules/core.js
new file mode 100644
index 0000000..6a82af3
--- /dev/null
+++ b/content/modules/core.js
@@ -0,0 +1,332 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var core = {
+
+  syncDataObj : null,
+
+  load: async function () {
+    this.syncDataObj = {};
+  },
+
+  unload: async function () {
+  },
+
+  isSyncing: function (accountID) {
+    let status = TbSync.db.getAccountProperty(accountID, "status"); //global status of the account
+    return (status == "syncing");
+  },
+  
+  isEnabled: function (accountID) {
+    let status = TbSync.db.getAccountProperty(accountID, "status");
+    return  (status != "disabled");
+  },
+
+  isConnected: function (accountID) {
+    let status = TbSync.db.getAccountProperty(accountID, "status");
+    let validFolders = TbSync.db.findFolders({"cached": false}, {"accountID": accountID});
+    return (status != "disabled" && validFolders.length > 0);
+  },
+  
+  resetSyncDataObj: function (accountID) {
+    this.syncDataObj[accountID] = new TbSync.SyncData(accountID);          
+  },
+  
+  getSyncDataObject: function (accountID) {
+    if (!this.syncDataObj.hasOwnProperty(accountID)) {
+      this.resetSyncDataObj(accountID);
+    }
+    return this.syncDataObj[accountID];        
+  },
+  
+  getNextPendingFolder: function (syncData) {
+    let sortedFolders = TbSync.providers[syncData.accountData.getAccountProperty("provider")].Base.getSortedFolders(syncData.accountData);
+    for (let i=0; i < sortedFolders.length; i++) {
+      if (sortedFolders[i].getFolderProperty("status") != "pending") continue;
+      syncData._setCurrentFolderData(sortedFolders[i]);
+      return true;
+    }
+    syncData._clearCurrentFolderData();
+    return false;
+  },
+  
+
+  syncAllAccounts: function () {
+    //get info of all accounts
+    let accounts = TbSync.db.getAccounts();
+
+    for (let i=0; i < accounts.IDs.length; i++) {
+      // core async sync function, but we do not wait until it has finished,
+      // but return right away and initiate sync of all accounts parallel
+      this.syncAccount(accounts.IDs[i]);
+    }
+  },
+
+  syncAccount: async function (accountID, aSyncDescription = {}) {
+    let syncDescription = {};
+    Object.assign(syncDescription, aSyncDescription);
+    
+    if (!syncDescription.hasOwnProperty("maxAccountReruns")) syncDescription.maxAccountReruns = 2;
+    if (!syncDescription.hasOwnProperty("maxFolderReruns")) syncDescription.maxFolderReruns = 2;
+    if (!syncDescription.hasOwnProperty("syncList")) syncDescription.syncList = true;
+    if (!syncDescription.hasOwnProperty("syncFolders")) syncDescription.syncFolders = null; // null ( = default = sync selected folders) or (empty) Array with folderData obj to be synced
+    if (!syncDescription.hasOwnProperty("syncJob")) syncDescription.syncJob = "sync";
+
+    //do not init sync if there is a sync running or account is not enabled
+    if (!this.isEnabled(accountID) || this.isSyncing(accountID)) return;
+
+    //create syncData object for each account (to be able to have parallel XHR)
+    this.resetSyncDataObj(accountID);
+    let syncData = this.getSyncDataObject(accountID);
+    
+    //send GUI into lock mode (status == syncing)
+    TbSync.db.setAccountProperty(accountID, "status", "syncing");
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.updateAccountSettingsGui", accountID);
+    
+    let overallStatusData = new TbSync.StatusData();
+    let accountRerun;
+    let accountRuns = 0;
+    
+    do {
+      accountRerun = false;
+
+      if (accountRuns > syncDescription.maxAccountReruns) {
+        overallStatusData = new TbSync.StatusData(TbSync.StatusData.ERROR, "resync-loop");
+        break;
+      }      
+      accountRuns++;
+      
+      if (syncDescription.syncList) {
+        let listStatusData;
+        try {
+          listStatusData = await TbSync.providers[syncData.accountData.getAccountProperty("provider")].Base.syncFolderList(syncData, syncDescription.syncJob, accountRuns);
+        } catch (e) {
+          listStatusData = new TbSync.StatusData(TbSync.StatusData.WARNING, "JavaScriptError", e.message + "\n\n" + e.stack);
+        }
+          
+        if (!(listStatusData instanceof TbSync.StatusData)) {
+          overallStatusData = new TbSync.StatusData(TbSync.StatusData.ERROR, "apiError", "TbSync/"+syncData.accountData.getAccountProperty("provider")+": Base.syncFolderList() must return a StatusData object");
+          break;
+        }
+        
+        //if we have an error during folderList sync, there is no need to go on
+        if (listStatusData.type != TbSync.StatusData.SUCCESS) {
+          overallStatusData = listStatusData;
+          accountRerun = (listStatusData.type == TbSync.StatusData.ACCOUNT_RERUN)
+          TbSync.eventlog.add(listStatusData.type, syncData.eventLogInfo, listStatusData.message, listStatusData.details);
+          continue; //jumps to the while condition check
+        }
+        
+        // Removes all leftover cached folders and sets all other folders to a well defined cached = "0"
+        // which will set this account as connected (if at least one non-cached folder is present).
+        this.removeCachedFolders(syncData);
+
+        // update folder list in GUI
+        Services.obs.notifyObservers(null, "tbsync.observer.manager.updateFolderList", syncData.accountData.accountID);
+      }
+      
+      // syncDescription.syncFolders is either null ( = default = sync selected folders) or an Array.
+      // Skip folder sync if Array is empty.
+      if (!Array.isArray(syncDescription.syncFolders) || syncDescription.syncFolders.length > 0) {
+        this.prepareFoldersForSync(syncData, syncDescription);
+
+        // update folder list in GUI
+        Services.obs.notifyObservers(null, "tbsync.observer.manager.updateFolderList", syncData.accountData.accountID);
+
+        // if any folder was found, sync
+        if (syncData.accountData.isConnected()) {
+          let folderRuns = 1;
+          do {
+            if (folderRuns > syncDescription.maxFolderReruns) {
+              overallStatusData = new TbSync.StatusData(TbSync.StatusData.ERROR, "resync-loop");
+              break;
+            }
+            
+            // getNextPendingFolder will set or clear currentFolderData of syncData
+            if (!this.getNextPendingFolder(syncData)) {
+              break;
+            }
+            
+            let folderStatusData;
+            try {
+              folderStatusData = await TbSync.providers[syncData.accountData.getAccountProperty("provider")].Base.syncFolder(syncData, syncDescription.syncJob, folderRuns);
+            } catch (e) {
+              folderStatusData = new TbSync.StatusData(TbSync.StatusData.WARNING, "JavaScriptError", e.message + "\n\n" + e.stack);
+            }
+            
+            if (!(folderStatusData instanceof TbSync.StatusData)) {
+              folderStatusData = new TbSync.StatusData(TbSync.StatusData.ERROR, "apiError", "TbSync/"+syncData.accountData.getAccountProperty("provider")+": Base.syncFolder() must return a StatusData object");
+            }
+
+            // if one of the folders indicated a FOLDER_RERUN, do not finish this
+            // folder but do it again
+            if (folderStatusData.type == TbSync.StatusData.FOLDER_RERUN) {
+              TbSync.eventlog.add(folderStatusData.type, syncData.eventLogInfo, folderStatusData.message, folderStatusData.details);
+              folderRuns++;
+              continue;
+            } else {
+              folderRuns = 1;
+            }
+            
+            this.finishFolderSync(syncData, folderStatusData);
+
+            //if one of the folders indicated an ERROR, abort sync
+            if (folderStatusData.type == TbSync.StatusData.ERROR) {
+              break;
+            }
+            
+            //if the folder has send an ACCOUNT_RERUN, abort sync and rerun the entire account
+            if (folderStatusData.type == TbSync.StatusData.ACCOUNT_RERUN) {
+              syncDescription.syncList = true;
+              accountRerun = true;
+              break;
+            }
+            
+          } while (true);
+        } else {
+          overallStatusData = new TbSync.StatusData(TbSync.StatusData.ERROR, "no-folders-found-on-server");
+        }
+      }
+    
+    } while (accountRerun);
+    
+    this.finishAccountSync(syncData, overallStatusData);
+  },
+  
+  // this could be added to AccountData, but I do not want that in public
+  setTargetModified: function (folderData) {
+    if (!folderData.accountData.isSyncing() && folderData.accountData.isEnabled()) {
+      folderData.accountData.setAccountProperty("status", "notsyncronized");
+      folderData.setFolderProperty("status", "modified");
+      //notify settings gui to update status
+       Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folderData.accountID);
+    }
+  },
+  
+  enableAccount: function(accountID) {
+    let accountData = new TbSync.AccountData(accountID);
+    TbSync.providers[accountData.getAccountProperty("provider")].Base.onEnableAccount(accountData);
+    accountData.setAccountProperty("status", "notsyncronized");
+    accountData.resetAccountProperty("lastsynctime");        
+  },
+
+  disableAccount: function(accountID) {
+    let accountData = new TbSync.AccountData(accountID);
+    TbSync.providers[accountData.getAccountProperty("provider")].Base.onDisableAccount(accountData);
+    accountData.setAccountProperty("status", "disabled");
+    
+    let folders = accountData.getAllFolders();
+    for (let folder of folders) {
+      if (folder.getFolderProperty("selected")) {
+        folder.targetData.removeTarget(); 
+        folder.setFolderProperty("selected", false);
+      }
+      folder.setFolderProperty("cached", true);
+    }
+  },
+
+  //removes all leftover cached folders and sets all other folders to a well defined cached = "0"
+  //which will set this account as connected (if at least one non-cached folder is present)
+  removeCachedFolders: function(syncData) {
+    let folders = syncData.accountData.getAllFoldersIncludingCache();
+    for (let folder of folders) {
+      //delete all leftover cached folders
+      if (folder.getFolderProperty("cached")) {
+        TbSync.db.deleteFolder(folder.accountID, folder.folderID);
+        continue;
+      } else {
+        //set well defined cache state
+        folder.setFolderProperty("cached", false);
+      }
+    }
+  },
+  
+  //set allrequested folders to "pending", so they are marked for syncing 
+  prepareFoldersForSync: function(syncData, syncDescription) {
+    let folders = syncData.accountData.getAllFolders();
+    for (let folder of folders) {
+      let requested = (Array.isArray(syncDescription.syncFolders) && syncDescription.syncFolders.filter(f => f.folderID == folder.folderID).length > 0);
+      let selected = (!Array.isArray(syncDescription.syncFolders) && folder.getFolderProperty("selected"));
+
+      //set folders to pending, so they get synced
+      if (requested || selected) {
+         folder.setFolderProperty("status", "pending");
+      }
+    }
+  },
+  
+  finishFolderSync: function(syncData, statusData) {        
+    if (statusData.type != TbSync.StatusData.SUCCESS) {
+      //report error
+      TbSync.eventlog.add(statusData.type, syncData.eventLogInfo, statusData.message, statusData.details);
+    }
+    
+    //if this is a success, prepend success to the status message, 
+    //otherwise just set the message
+    let status;
+    if (statusData.type == TbSync.StatusData.SUCCESS || statusData.message == "") {
+      status = statusData.type;
+      if (statusData.message) status = status + "." + statusData.message;
+    } else {
+      status = statusData.message;
+    }
+    
+    if (syncData.currentFolderData) {
+      syncData.currentFolderData.setFolderProperty("status", status);
+      syncData.currentFolderData.setFolderProperty("lastsynctime", Date.now());
+      //clear folderID to fall back to account-only-mode (folder is done!)
+      syncData._clearCurrentFolderData();
+    } 
+
+     syncData.setSyncState("done");        
+  },
+
+  finishAccountSync: function(syncData, statusData) {
+    // set each folder with PENDING status to ABORTED
+    let folders = TbSync.db.findFolders({"status": "pending"}, {"accountID": syncData.accountData.accountID});
+    for (let i=0; i < folders.length; i++) {
+      TbSync.db.setFolderProperty(folders[i].accountID, folders[i].folderID, "status", "aborted");
+    }
+    
+    //if this is a success, prepend success to the status message, 
+    //otherwise just set the message
+    let status;
+    if (statusData.type == TbSync.StatusData.SUCCESS || statusData.message == "") {
+      status = statusData.type;
+      if (statusData.message) status = status + "." + statusData.message;
+    } else {
+      status = statusData.message;
+    }
+
+    
+    if (statusData.type != TbSync.StatusData.SUCCESS) {
+      //report error
+      TbSync.eventlog.add("warning", syncData.eventLogInfo, statusData.message, statusData.details);
+    } else {
+      //account itself is ok, search for folders with error
+      folders = TbSync.db.findFolders({"selected": true, "cached": false}, {"accountID": syncData.accountData.accountID});
+      for (let i in folders) {
+        let folderstatus = folders[i].data.status.split(".")[0];
+        if (folderstatus != "" && folderstatus != TbSync.StatusData.SUCCESS && folderstatus != "aborted") {
+          status = "foldererror";
+          break;
+        }
+      }
+    }    
+    
+    //done
+    syncData.accountData.setAccountProperty("lastsynctime", Date.now());
+    syncData.accountData.setAccountProperty("status", status);
+    syncData.setSyncState("accountdone"); 
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.updateFolderList", syncData.accountData.accountID);
+    this.resetSyncDataObj(syncData.accountData.accountID);
+  }    
+  
+}
diff --git a/content/modules/db.js b/content/modules/db.js
new file mode 100644
index 0000000..730f19a
--- /dev/null
+++ b/content/modules/db.js
@@ -0,0 +1,460 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { DeferredTask } = ChromeUtils.import("resource://gre/modules/DeferredTask.jsm");
+
+var db = {
+
+  loaded: false,
+
+  files: {
+    accounts: {
+      name: "accounts68.json", 
+      default: JSON.stringify({ sequence: 0, data : {} })
+      //data[account] = {row}
+      },
+    folders: {
+      name: "folders68.json", 
+      default: JSON.stringify({})
+      //assoziative array of assoziative array : folders[<int>accountID][<string>folderID] = {row} 
+      },
+    changelog: {
+      name: "changelog68.json", 
+      default: JSON.stringify([]),
+      },
+  },
+    
+  load: async function ()  {
+    //DB Concept:
+    //-- on application start, data is read async from json file into object
+    //-- add-on only works on object
+    //-- each time data is changed, an async write job is initiated <writeDelay>ms in the future and is resceduled, if another request arrives within that time
+
+    for (let f in this.files) {
+      this.files[f].write = new DeferredTask(() => this.writeAsync(f), 6000);
+      
+      try {
+        this[f] = await IOUtils.readJSON(TbSync.io.getAbsolutePath(this.files[f].name));
+        this.files[f].found = true;
+      } catch (e) {
+        //if there is no file, there is no file...
+        this[f] = JSON.parse(this.files[f].default);
+        this.files[f].found = false;
+        Components.utils.reportError(e);
+      }
+    }
+
+    function getNewDeviceId4Migration() {
+        //taken from https://jsfiddle.net/briguy37/2MVFd/
+        let d = new Date().getTime();
+        let uuid = 'xxxxxxxxxxxxxxxxyxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            let r = (d + Math.random()*16)%16 | 0;
+            d = Math.floor(d/16);
+            return (c=='x' ? r : (r&0x3|0x8)).toString(16);
+        });
+        return "MZTB" + uuid;
+    }
+    
+    // try to migrate old accounts file from TB60
+    if (!this.files["accounts"].found) {
+      try {
+        let accounts = await IOUtils.readJSON(TbSync.io.getAbsolutePath("accounts.json"));
+        for (let d of Object.values(accounts.data)) {
+          console.log("Migrating: " + JSON.stringify(d));
+          
+          let settings = {};
+          settings.status = "disabled";
+          settings.provider = d.provider;
+          settings.https = (d.https == "1");
+          
+          switch (d.provider) {
+            case "dav":
+              settings.calDavHost = d.host ? d.host : "";
+              settings.cardDavHost = d.host2 ? d.host2 : "";
+              settings.serviceprovider = d.serviceprovider;
+              settings.user = d.user;
+              settings.syncGroups = (d.syncGroups == "1");
+              settings.useCalendarCache = (d.useCache == "1");
+            break;
+            
+            case "eas":
+              settings.useragent = d.useragent;
+              settings.devicetype = d.devicetype;
+              settings.deviceId = getNewDeviceId4Migration();
+              settings.asversionselected = d.asversionselected;
+              settings.asversion = d.asversion;
+              settings.host = d.host;
+              settings.user = d.user;
+              settings.servertype = d.servertype;
+              settings.seperator = d.seperator;
+              settings.provision = (d.provision == "1");
+              settings.displayoverride = (d.displayoverride == "1");
+              if (d.hasOwnProperty("galautocomplete")) settings.galautocomplete = (d.galautocomplete == "1");
+            break;
+          }
+          
+          this.addAccount(d.accountname, settings);
+        }
+      } catch (e) {
+        Components.utils.reportError(e);
+      }
+    }
+    
+    this.loaded = true;
+  },
+  
+  unload: async function ()  {
+    if (this.loaded) {
+      for (let f in this.files) {
+        try{ 
+          //abort write delay timers and write current file content to disk 
+          await this.files[f].write.finalize();
+        } catch (e) {
+          Components.utils.reportError(e);
+        }                
+      }
+    }
+  },
+  
+
+  saveFile: function (f) {
+    if (this.loaded) {
+      //cancel any pending write and schedule a new delayed write
+      this.files[f].write.disarm();
+      this.files[f].write.arm();
+    }
+  },
+
+  writeAsync: async function (f) {
+    // if this file was not found/read on load, do not write default content to prevent clearing of data in case of read-errors
+    if (!this.files[f].found && JSON.stringify(this[f]) == this.files[f].default) {
+      return;
+    }
+    
+    let filepath = TbSync.io.getAbsolutePath(this.files[f].name);
+    await IOUtils.writeJSON(filepath, this[f]);
+  },
+
+
+
+  // simple convenience wrapper
+  saveAccounts: function () {
+    this.saveFile("accounts");
+  },
+
+  saveFolders: function () {
+    this.saveFile("folders");
+  },
+
+  saveChangelog: function () {
+    this.saveFile("changelog");
+  },
+
+  
+
+  // CHANGELOG FUNCTIONS
+  getItemStatusFromChangeLog: function (parentId, itemId) {   
+    for (let i=0; i<this.changelog.length; i++) {
+      if (this.changelog[i].parentId == parentId && this.changelog[i].itemId == itemId) return this.changelog[i].status;
+    }
+    return null;
+  },
+
+  getItemDataFromChangeLog: function (parentId, itemId) {   
+    for (let i=0; i<this.changelog.length; i++) {
+      if (this.changelog[i].parentId == parentId && this.changelog[i].itemId == itemId) return this.changelog[i];
+    }
+    return null;
+  },
+  
+  addItemToChangeLog: function (parentId, itemId, status) {
+    this.removeItemFromChangeLog(parentId, itemId);
+
+    //ChangelogData object
+    let row = {
+      "parentId" : parentId,
+      "itemId" : itemId,
+      "timestamp": Date.now(),
+      "status" : status};
+    
+    this.changelog.push(row);
+    this.saveChangelog();
+  },
+
+  removeItemFromChangeLog: function (parentId, itemId, moveToEnd = false) {
+    for (let i=this.changelog.length-1; i>-1; i-- ) {
+      if (this.changelog[i].parentId == parentId && this.changelog[i].itemId == itemId) {
+        let row = this.changelog.splice(i,1);
+        if (moveToEnd) this.changelog.push(row[0]);
+        this.saveChangelog();
+        return;
+      }
+    }
+  },
+
+  removeAllItemsFromChangeLogWithStatus: function (parentId, status) {
+    for (let i=this.changelog.length-1; i>-1; i-- ) {
+      if (this.changelog[i].parentId == parentId && this.changelog[i].status == status) {
+        let row = this.changelog.splice(i,1);
+      }
+    }
+    this.saveChangelog();
+  },
+
+  // Remove all cards of a parentId from ChangeLog
+  clearChangeLog: function (parentId) {
+    if (parentId) {
+      // we allow extra parameters added to a parentId, but still want to delete all items of that parent
+      // so we check for startsWith instead of equal
+      for (let i=this.changelog.length-1; i>-1; i-- ) {
+        if (this.changelog[i].parentId.startsWith(parentId)) this.changelog.splice(i,1);
+      }
+      this.saveChangelog();
+    }
+  },
+
+  getItemsFromChangeLog: function (parentId, maxnumbertosend, status = null) {        
+    //maxnumbertosend = 0 will return all results
+    let log = [];
+    let counts = 0;
+    for (let i=0; i<this.changelog.length && (log.length < maxnumbertosend || maxnumbertosend == 0); i++) {
+      if (this.changelog[i].parentId == parentId && (status === null || (typeof this.changelog[i].status == "string" && this.changelog[i].status.indexOf(status) != -1))) log.push(this.changelog[i]);
+    }
+    return log;
+  },
+
+
+
+
+
+  // ACCOUNT FUNCTIONS
+
+  addAccount: function (accountname, newAccountEntry) {
+    this.accounts.sequence++;
+    let id = this.accounts.sequence.toString();
+    newAccountEntry.accountID = id;
+    newAccountEntry.accountname = accountname;
+    
+    this.accounts.data[id] = newAccountEntry;
+    this.saveAccounts();
+    return id;
+  },
+
+  removeAccount: function (accountID) {
+    //check if accountID is known
+    if (this.accounts.data.hasOwnProperty(accountID) == false ) {
+      throw "Unknown accountID!" + "\nThrown by db.removeAccount("+accountID+ ")";
+    } else {
+      delete (this.accounts.data[accountID]);
+      delete (this.folders[accountID]);
+      this.saveAccounts();
+      this.saveFolders();
+    }
+  },
+
+  getAccounts: function () {
+    let accounts = {};
+    accounts.IDs = Object.keys(this.accounts.data).filter(accountID => TbSync.providers.loadedProviders.hasOwnProperty(this.accounts.data[accountID].provider)).sort((a, b) => a - b);
+    accounts.allIDs =  Object.keys(this.accounts.data).sort((a, b) => a - b)
+    accounts.data = this.accounts.data;
+    return accounts;
+  },
+
+  getAccount: function (accountID) {
+    //check if accountID is known
+    if (this.accounts.data.hasOwnProperty(accountID) == false ) {
+      throw "Unknown accountID!" + "\nThrown by db.getAccount("+accountID+ ")";
+    } else {
+      return this.accounts.data[accountID];
+    }
+  }, 
+
+  isValidAccountProperty: function (provider, name) {
+    if (["provider"].includes(name)) //internal properties, do not need to be defined by user/provider
+      return true;
+
+    //check if provider is installed
+    if (!TbSync.providers.loadedProviders.hasOwnProperty(provider)) {
+      TbSync.dump("Error @ isValidAccountProperty", "Unknown provider <"+provider+">!");
+      return false;
+    }
+    
+    if (TbSync.providers.getDefaultAccountEntries(provider).hasOwnProperty(name)) {
+      return true;
+    } else {
+      TbSync.dump("Error @ isValidAccountProperty", "Unknown account setting <"+name+">!");
+      return false;
+    }            
+  },
+
+  getAccountProperty: function (accountID, name) {
+    // if the requested accountID does not exist, getAccount() will fail
+    let data = this.getAccount(accountID);
+    
+    //check if field is allowed and get value or default value if setting is not set
+    if (this.isValidAccountProperty(data.provider, name)) {
+      if (data.hasOwnProperty(name)) return data[name];
+      else return TbSync.providers.getDefaultAccountEntries(data.provider)[name];
+    }
+  }, 
+
+  setAccountProperty: function (accountID , name, value) {
+    // if the requested accountID does not exist, getAccount() will fail
+    let data = this.getAccount(accountID);
+
+    //check if field is allowed, and set given value 
+    if (this.isValidAccountProperty(data.provider, name)) {
+      this.accounts.data[accountID][name] = value;
+    }
+    this.saveAccounts();
+  },
+
+  resetAccountProperty: function (accountID , name) {
+    // if the requested accountID does not exist, getAccount() will fail
+    let data = this.getAccount(accountID);
+    let defaults = TbSync.providers.getDefaultAccountEntries(data.provider);        
+
+    //check if field is allowed, and set given value 
+    if (this.isValidAccountProperty(data.provider, name)) {
+      this.accounts.data[accountID][name] = defaults[name];
+    }
+    this.saveAccounts();
+  },
+
+
+
+
+  // FOLDER FUNCTIONS
+
+  addFolder: function(accountID) {
+    let folderID = TbSync.generateUUID();
+    let provider = this.getAccountProperty(accountID, "provider");        
+    
+    if (!this.folders.hasOwnProperty(accountID)) this.folders[accountID] = {};                        
+    
+    //create folder with default settings
+    this.folders[accountID][folderID] = TbSync.providers.getDefaultFolderEntries(accountID);
+    this.saveFolders();
+    return folderID;
+  },
+
+  deleteFolder: function(accountID, folderID) {
+    delete (this.folders[accountID][folderID]);
+    //if there are no more folders, delete entire account entry
+    if (Object.keys(this.folders[accountID]).length === 0) delete (this.folders[accountID]);
+    this.saveFolders();
+  },
+
+  isValidFolderProperty: function (accountID, field) {
+    if (["cached"].includes(field)) //internal properties, do not need to be defined by user/provider
+      return true;
+    
+    //check if provider is installed
+    let provider = this.getAccountProperty(accountID, "provider");
+    if (!TbSync.providers.loadedProviders.hasOwnProperty(provider)) {
+      TbSync.dump("Error @ isValidFolderProperty", "Unknown provider <"+provider+"> for accountID <"+accountID+">!");
+      return false;
+    }
+
+    if (TbSync.providers.getDefaultFolderEntries(accountID).hasOwnProperty(field)) {
+      return true;
+    } else {
+      TbSync.dump("Error @ isValidFolderProperty", "Unknown folder setting <"+field+"> for accountID <"+accountID+">!");
+      return false;
+    }
+  },
+
+  getFolderProperty: function(accountID, folderID, field) {
+    //does the field exist?
+    let folder = (this.folders.hasOwnProperty(accountID) && this.folders[accountID].hasOwnProperty(folderID)) ? this.folders[accountID][folderID] : null;
+    
+    if (folder === null) {
+      throw "Unknown folder <"+folderID+">!";
+    }
+    
+    if (this.isValidFolderProperty(accountID, field)) {
+      if (folder.hasOwnProperty(field)) {
+        return folder[field];
+      } else {
+        let provider = this.getAccountProperty(accountID, "provider");
+        let defaultFolder = TbSync.providers.getDefaultFolderEntries(accountID);
+        //handle internal fields, that do not have a default value (see isValidFolderProperty)
+        return (defaultFolder[field] ? defaultFolder[field] : "");
+      }
+    }
+  },
+
+  setFolderProperty: function (accountID, folderID, field, value) {
+    if (this.isValidFolderProperty(accountID, field)) {
+      this.folders[accountID][folderID][field] = value;
+      this.saveFolders();
+    }
+  },
+  
+  resetFolderProperty: function (accountID, folderID, field) {
+    let provider = this.getAccountProperty(accountID, "provider");
+    let defaults = TbSync.providers.getDefaultFolderEntries(accountID);        
+    if (this.isValidFolderProperty(accountID, field)) {
+      //handle internal fields, that do not have a default value (see isValidFolderProperty)
+      this.folders[accountID][folderID][field] = defaults[field] ? defaults[field] : "";
+      this.saveFolders();
+    }
+  },
+
+  findFolders: function (folderQuery = {}, accountQuery = {}) {
+    // folderQuery is an object with one or more key:value pairs (logical AND) ::
+    // {key1: value1, key2: value2} 
+    // the value itself may be an array (logical OR)
+    let data = [];
+    let folderQueryEntries = Object.entries(folderQuery);
+    let folderFields = folderQueryEntries.map(pair => pair[0]);
+    let folderValues = folderQueryEntries.map(pair => Array.isArray(pair[1]) ? pair[1] : [pair[1]]);
+    
+    let accountQueryEntries = Object.entries(accountQuery);
+    let accountFields = accountQueryEntries.map(pair => pair[0]);
+    let accountValues = accountQueryEntries.map(pair => Array.isArray(pair[1]) ? pair[1] : [pair[1]]);
+    
+    for (let aID in this.folders) {
+      //is this a leftover folder of an account, which no longer there?
+      if (!this.accounts.data.hasOwnProperty(aID)) {
+        delete (this.folders[aID]);
+        this.saveFolders();
+        continue;
+      }
+    
+      //skip this folder, if it belongs to an account currently not supported (provider not loaded)
+      if (!TbSync.providers.loadedProviders.hasOwnProperty(this.getAccountProperty(aID, "provider"))) {
+        continue;
+      }
+
+      //does this account match account search options?
+      let accountmatch = true;
+      for (let a = 0; a < accountFields.length && accountmatch; a++) {
+        accountmatch = accountValues[a].some(item => item === this.getAccountProperty(aID, accountFields[a]));
+        //Services.console.logStringMessage("   " + accountFields[a] + ":" + this.getAccountProperty(aID, accountFields[a]) + " in " + JSON.stringify(accountValues[a]) + " ? " + accountmatch);
+      }
+      
+      if (accountmatch) {
+        for (let fID in this.folders[aID]) {
+          //does this folder match folder search options?                
+          let foldermatch = true;
+          for (let f = 0; f < folderFields.length && foldermatch; f++) {
+            foldermatch = folderValues[f].some(item => item === this.getFolderProperty(aID, fID, folderFields[f]));
+            //Services.console.logStringMessage("   " + folderFields[f] + ":" + this.getFolderProperty(aID, fID, folderFields[f]) + " in " + JSON.stringify(folderValues[f]) + " ? " + foldermatch);
+          }
+          if (foldermatch) data.push({accountID: aID, folderID: fID, data: this.folders[aID][fID]});
+        }
+      }
+    }
+
+    //still a reference to the original data
+    return data;
+  }
+};
diff --git a/content/modules/eventlog.js b/content/modules/eventlog.js
new file mode 100644
index 0000000..ef8f1e8
--- /dev/null
+++ b/content/modules/eventlog.js
@@ -0,0 +1,153 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+/**
+ *
+ */
+var EventLogInfo = class {
+  /**
+   * An EventLogInfo instance is used when adding entries to the
+   * :ref:`TbSyncEventLog`. The information given here will be added as a
+   * header to the actual event.
+   *
+   * @param {string} provider     ``Optional`` A provider ID (also used as
+   *                              provider namespace). 
+   * @param {string} accountname  ``Optional`` An account name. Can be
+   *                              arbitrary but should match the accountID
+   *                              (if provided).
+   * @param {string} accountID    ``Optional`` An account ID. Used to filter
+   *                              events for a given account.
+   * @param {string} foldername   ``Optional`` A folder name.
+   *
+   */
+  constructor(provider, accountname = "", accountID = "", foldername = "") {
+    this._provider = provider;
+    this._accountname = accountname;
+    this._accountID = accountID;
+    this._foldername = foldername;
+  }
+  
+  /**
+   * Getter/Setter for the provider ID of this EventLogInfo.
+   */
+  get provider() {return this._provider};
+  /**
+   * Getter/Setter for the account ID of this EventLogInfo.
+   */
+  get accountname() {return this._accountname};
+  /**
+   * Getter/Setter for the account name of this EventLogInfo.
+   */
+  get accountID() {return this._accountID};
+  /**
+   * Getter/Setter for the folder name of this EventLogInfo.
+   */
+  get foldername() {return this._foldername};
+
+  set provider(v) {this._provider = v};
+  set accountname(v) {this._accountname = v};
+  set accountID(v) {this._accountID = v};
+  set foldername(v) {this._foldername = v};
+}
+
+
+  
+/**
+ * The TbSync event log 
+ */
+var eventlog = {
+  /**
+   * Adds an entry to the TbSync event log
+   *
+   * @param {StatusDataType}  type       One of the types defined in
+   *                                      :class:`StatusData`
+   * @param {EventLogInfo}    eventInfo  EventLogInfo for this event.
+   * @param {string}          message    The event message.
+   * @param {string}          details    ``Optional`` The event details.
+   *  
+   */
+  add: function (type, eventInfo, message, details = null) {
+    let entry = {
+      timestamp: Date.now(),
+      message: message, 
+      type: type,
+      link: null, 
+      //some details are just true, which is not a useful detail, ignore
+      details: details === true ? null : details,
+      provider: "",
+      accountname: "",
+      foldername: "",
+    };
+  
+    if (eventInfo) {
+      if (eventInfo.accountID) entry.accountID = eventInfo.accountID;
+      if (eventInfo.provider) entry.provider = eventInfo.provider;
+      if (eventInfo.accountname) entry.accountname = eventInfo.accountname;
+      if (eventInfo.foldername) entry.foldername = eventInfo.foldername;
+    }
+
+    let localized = "";
+    let link = "";        
+    if (entry.provider) {
+      localized = TbSync.getString("status." + message, entry.provider);
+      link = TbSync.getString("helplink." + message, entry.provider);
+    } else {
+      //try to get localized string from message from TbSync
+      localized = TbSync.getString("status." + message);
+      link = TbSync.getString("helplink." + message);
+    }
+  
+    //can we provide a localized version of the event msg?
+    if (localized != "status."+message) {
+      entry.message = localized;
+    }
+
+    //is there a help link?
+    if (link != "helplink." + message) {
+      entry.link = link;
+    }
+
+    //dump the non-localized message into debug log
+    TbSync.dump("EventLog", message + (entry.details !== null ? "\n" + entry.details : ""));
+    this.events.push(entry);
+    if (this.events.length > 100) this.events.shift();
+    Services.obs.notifyObservers(null, "tbsync.observer.eventlog.update", null);
+  },
+
+  events: null,
+  eventLogWindow: null,
+  
+  load: async function () {
+    this.clear();
+  },
+
+  unload: async function () {
+    if (this.eventLogWindow) {
+      this.eventLogWindow.close();
+    }
+  },
+
+  get: function (accountID = null) {
+    if (accountID) {
+      return this.events.filter(e => e.accountID == accountID);
+    } else {
+      return this.events;
+    }
+  },
+  
+  clear: function () {
+    this.events = [];
+  },
+  
+  
+  open: function (accountID = null, folderID = null) {
+    this.eventLogWindow = TbSync.manager.prefWindowObj.open("chrome://tbsync/content/manager/eventlog/eventlog.xhtml", "TbSyncEventLog", "centerscreen,chrome,resizable");
+  },    
+}
diff --git a/content/modules/io.js b/content/modules/io.js
new file mode 100644
index 0000000..a4ecbdb
--- /dev/null
+++ b/content/modules/io.js
@@ -0,0 +1,41 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+ 
+var io = {
+
+  storageDirectory : PathUtils.join(PathUtils.profileDir, "TbSync"),
+
+  load: async function () {
+  },
+
+  unload: async function () {
+  },
+
+  getAbsolutePath: function(filename) {
+    return PathUtils.join(this.storageDirectory, filename);
+  },
+  
+  initFile: function (filename) {
+    let file = FileUtils.getFile("ProfD", ["TbSync",filename]);
+    //create a stream to write to that file
+    let foStream = Components.classes["@mozilla.org/network/file-output-stream;1"].createInstance(Components.interfaces.nsIFileOutputStream);
+    foStream.init(file, 0x02 | 0x08 | 0x20, parseInt("0666", 8), 0); // write, create, truncate
+    foStream.close();
+  },
+
+  appendToFile: function (filename, data) {
+    let file = FileUtils.getFile("ProfD", ["TbSync",filename]);
+    //create a strem to write to that file
+    let foStream = Components.classes["@mozilla.org/network/file-output-stream;1"].createInstance(Components.interfaces.nsIFileOutputStream);
+    foStream.init(file, 0x02 | 0x08 | 0x10, parseInt("0666", 8), 0); // write, create, append
+    foStream.write(data, data.length);
+    foStream.close();
+  },    
+}
diff --git a/content/modules/lightning.js b/content/modules/lightning.js
new file mode 100644
index 0000000..cd9a383
--- /dev/null
+++ b/content/modules/lightning.js
@@ -0,0 +1,774 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+ var { XPCOMUtils } = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
+ 
+ XPCOMUtils.defineLazyModuleGetters(this, {
+  CalAlarm: "resource:///modules/CalAlarm.jsm",
+  CalAttachment: "resource:///modules/CalAttachment.jsm",
+  CalAttendee: "resource:///modules/CalAttendee.jsm",
+  CalEvent: "resource:///modules/CalEvent.jsm",
+  CalTodo: "resource:///modules/CalTodo.jsm",
+}); 
+  
+var lightning = {
+
+  cal: null,
+  ICAL: null,
+   
+  load: async function () {
+    try {
+      TbSync.lightning.cal = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm").cal;
+      TbSync.lightning.ICAL = ChromeUtils.import("resource:///modules/calendar/Ical.jsm").ICAL;
+      let manager = TbSync.lightning.cal.manager;
+      manager.addCalendarObserver(this.calendarObserver);
+      manager.addObserver(this.calendarManagerObserver);
+    } catch (e) {
+      TbSync.dump("Check4Lightning","Error during lightning module import: " + e.toString() + "\n" + e.stack);
+      Components.utils.reportError(e);
+    }
+  },
+
+  unload: async function () {
+    //removing global observer
+    let manager = TbSync.lightning.cal.manager;
+    manager.removeCalendarObserver(this.calendarObserver);
+    manager.removeObserver(this.calendarManagerObserver);
+
+    //remove listeners on global sync buttons
+    if (TbSync.window.document.getElementById("calendar-synchronize-button")) {
+      TbSync.window.document.getElementById("calendar-synchronize-button").removeEventListener("click", function(event){Services.obs.notifyObservers(null, 'tbsync.observer.sync', null);}, false);
+    }
+    if (TbSync.window.document.getElementById("task-synchronize-button")) {
+      TbSync.window.document.getElementById("task-synchronize-button").removeEventListener("click", function(event){Services.obs.notifyObservers(null, 'tbsync.observer.sync', null);}, false);
+    }
+  },
+
+
+
+
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * AdvancedTargetData, an extended TargetData implementation, providers
+  // * can use this as their own TargetData by extending it and just
+  // * defining the extra methods
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  
+  AdvancedTargetData : class {
+    constructor(folderData) {            
+      this._folderData = folderData;
+      this._targetObj = null;           
+    }
+    
+    // Check, if the target exists and return true/false.
+    hasTarget() {
+      let calManager = TbSync.lightning.cal.manager;
+      let target = this._folderData.getFolderProperty("target");
+      let calendar = calManager.getCalendarById(target);
+      
+      return calendar ? true : false;
+    }
+
+    // Returns the target obj, which TbSync should return as the target. It can
+    // be whatever you want and is returned by FolderData.targetData.getTarget().
+    // If the target does not exist, it should be created. Throw a simple Error, if that
+    // failed.
+    async getTarget() {
+      let calManager = TbSync.lightning.cal.manager;
+      let target = this._folderData.getFolderProperty("target");
+      let calendar = calManager.getCalendarById(target);
+      
+      if (!calendar) {
+        calendar = await TbSync.lightning.prepareAndCreateCalendar(this._folderData);
+        if (!calendar)
+          throw new Error("notargets");
+      }
+
+      if (!this._targetObj || this._targetObj.id != calendar.id)
+        this._targetObj = new TbSync.lightning.TbCalendar(calendar, this._folderData);
+
+      return this._targetObj;
+    }
+    
+    /**
+     * Removes the target from the local storage. If it does not exist, return
+     * silently. A call to ``hasTarget()`` should return false, after this has
+     * been executed.
+     *
+     */
+    removeTarget() {
+      let calManager = TbSync.lightning.cal.manager;
+      let target = this._folderData.getFolderProperty("target");
+      let calendar = calManager.getCalendarById(target);
+
+      try {
+        if (calendar) {
+          calManager.removeCalendar(calendar);
+        }
+      } catch (e) {}
+      TbSync.db.clearChangeLog(target);
+      this._folderData.resetFolderProperty("target");             
+    }
+
+
+    /**
+     * Disconnects the target in the local storage from this TargetData, but
+     * does not delete it, so it becomes a stale "left over" . A call
+     * to ``hasTarget()`` should return false, after this has been executed.
+     * 
+     */
+    disconnectTarget() {
+      let calManager = TbSync.lightning.cal.manager;
+      let target = this._folderData.getFolderProperty("target");
+      let calendar = calManager.getCalendarById(target);
+
+      if (calendar) {
+        let changes = TbSync.db.getItemsFromChangeLog(target, 0, "_by_user");        
+        if (changes.length > 0) {
+          this.targetName = this.targetName + " (*)";
+        }
+        calendar.setProperty("disabled", true);
+        calendar.setProperty("tbSyncProvider", "orphaned");
+        calendar.setProperty("tbSyncAccountID", "");
+      }
+      TbSync.db.clearChangeLog(target);
+      this._folderData.resetFolderProperty("target");        
+    } 
+    
+    set targetName(newName) {
+      let calManager = TbSync.lightning.cal.manager;
+      let target = this._folderData.getFolderProperty("target");
+      let calendar = calManager.getCalendarById(target);
+
+      if (calendar) {
+        calendar.name = newName;
+      } else {
+        throw new Error("notargets");
+      }
+    }
+  
+    get targetName() {
+      let calManager = TbSync.lightning.cal.manager;
+      let target = this._folderData.getFolderProperty("target");
+      let calendar = calManager.getCalendarById(target);
+
+      if (calendar) {
+        return calendar.name;
+      } else {
+        throw new Error("notargets");
+      }
+    }
+
+    setReadOnly(value) {
+      // hasTarget() can throw an error, ignore that here
+      try {
+        if (this.hasTarget()) {
+          this.getTarget().then(target => target.calendar.setProperty("readOnly", value));
+        }
+      } catch (e) {
+        Components.utils.reportError(e);
+      }
+    }
+
+    
+    // * * * * * * * * * * * * * * * * *
+    // * AdvancedTargetData extension  * 
+    // * * * * * * * * * * * * * * * * *
+    
+    get isAdvancedCalendarTargetData() {
+      return true;
+    }
+    
+    get folderData() {
+      return this._folderData;
+    }
+    
+    // The calendar target does not support a custom primaryKeyField, because
+    // the lightning implementation only allows to search for items via UID.
+    // Like the addressbook target, the calendar target item element has a
+    // primaryKey getter/setter which - however - only works on the UID.
+    
+    // enable or disable changelog
+    get logUserChanges(){
+      return true;
+    }
+
+    calendarObserver(aTopic, tbCalendar, aPropertyName, aPropertyValue, aOldPropertyValue) {
+      switch (aTopic) {
+        case "onCalendarPropertyChanged":
+          //Services.console.logStringMessage("["+ aTopic + "] " + tbCalendar.calendar.name + " : " + aPropertyName);
+          break;
+
+        case "onCalendarDeleted":
+        case "onCalendarPropertyDeleted":
+          //Services.console.logStringMessage("["+ aTopic + "] " +tbCalendar.calendar.name);
+          break;
+      }
+    }
+
+    itemObserver(aTopic, tbItem, tbOldItem) {
+      switch (aTopic) {
+        case "onAddItem":
+        case "onModifyItem":
+        case "onDeleteItem":
+          //Services.console.logStringMessage("["+ aTopic + "] " + tbItem.nativeItem.title);
+          break;
+      }
+    }
+
+    // replace this with your own implementation to create the actual addressbook,
+    // when this class is extended
+    async createCalendar(newname) {
+      let calManager = TbSync.lightning.cal.manager;
+      let newCalendar = calManager.createCalendar("storage", Services.io.newURI("moz-storage-calendar://"));
+      newCalendar.id = TbSync.lightning.cal.getUUID();
+      newCalendar.name = newname;
+      return newCalendar
+    }      
+    
+  },
+
+
+
+
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * TbItem and TbCalendar Classes
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  
+  TbItem : class {
+    constructor(TbCalendar, item) {
+      if (!TbCalendar)
+        throw new Error("TbItem::constructor is missing its first parameter!");
+
+      if (!item)
+        throw new Error("TbItem::constructor is missing its second parameter!");
+
+      this._tbCalendar = TbCalendar;
+      this._item = item;
+      
+      this._isTodo = (item instanceof Ci.calITodo);
+      this._isEvent = (item instanceof Ci.calIEvent);
+    }
+    
+    get tbCalendar() {
+      return this._tbCalendar;
+    }
+
+    get isTodo() {
+      return this._isTodo;
+    }
+    
+    get isEvent() {
+      return this._isEvent;
+    }
+
+
+
+
+    
+    get nativeItem() {
+      return this._item;
+    }
+
+    get UID() {
+      return this._item.id;
+    }
+    
+    get primaryKey() {
+      // no custom key possible with lightning, must use the UID
+      return this._item.id;
+    }
+
+    set primaryKey(value) {
+      // no custom key possible with lightning, must use the UID
+      this._item.id = value;   
+    }
+
+    clone() {
+      return new TbSync.lightning.TbItem(this._tbCalendar, this._item.clone());
+    }
+
+    toString() {
+      return this._item.icalString;
+    }
+
+    getProperty(property, fallback = "") {
+      return this._item.hasProperty(property) ? this._item.getProperty(property) : fallback;
+    }
+
+    setProperty(property, value) {
+      this._item.setProperty(property, value);
+    }
+    
+    deleteProperty(property) {
+      this._item.deleteProperty(property);
+    }
+        
+    get changelogData() {         
+      return TbSync.db.getItemDataFromChangeLog(this._tbCalendar.UID, this.primaryKey);
+    }
+
+    get changelogStatus() {
+      return TbSync.db.getItemStatusFromChangeLog(this._tbCalendar.UID, this.primaryKey);
+    }
+
+    set changelogStatus(status) {
+      let value = this.primaryKey;
+      
+      if (value) {
+        if (!status) {
+          TbSync.db.removeItemFromChangeLog(this._tbCalendar.UID, value);
+          return;
+        }
+
+        if (this._tbCalendar.logUserChanges || status.endsWith("_by_server")) {
+          TbSync.db.addItemToChangeLog(this._tbCalendar.UID, value, status);
+        }
+      }
+    }
+  },
+
+
+  TbCalendar : class {
+    constructor(calendar, folderData) {
+      this._calendar = calendar;
+      this._folderData = folderData;
+     }
+
+    get calendar() {
+      return this._calendar;
+    }
+    
+    get promisifyCalendar() {
+      return this._calendar;
+    }
+
+    get logUserChanges() {
+      return this._folderData.targetData.logUserChanges;
+    }
+    
+    get primaryKeyField() {
+      // Not supported by lightning. We let the implementation sit here, it may get changed in the future.
+      // In order to support this, lightning needs to implement a proper getItemfromProperty() method.
+      return null;
+    }
+    
+    get UID() {
+      return this._calendar.id;
+    }
+
+    createNewEvent() {
+      let event = new CalEvent();
+      return new TbSync.lightning.TbItem(this, event);
+    }
+    
+    createNewTodo() {
+      let todo = new CalTodo();
+      return new TbSync.lightning.TbItem(this, todo);
+    }
+
+    
+    
+    
+    async addItem(tbItem, pretagChangelogWithByServerEntry = true) {
+      if (this.primaryKeyField && !tbItem.getProperty(this.primaryKeyField)) {
+        tbItem.setProperty(this.primaryKeyField, this._folderData.targetData.generatePrimaryKey());
+        //Services.console.logStringMessage("[TbCalendar::addItem] Generated primary key!");
+      }
+      
+      if (pretagChangelogWithByServerEntry) {
+        tbItem.changelogStatus = "added_by_server";
+      }
+      return await this._calendar.addItem(tbItem._item);
+    }
+    
+    async modifyItem(tbNewItem, tbOldItem, pretagChangelogWithByServerEntry = true) {
+      // only add entry if the current entry does not start with _by_user
+      let status = tbNewItem.changelogStatus ? tbNewItem.changelogStatus : "";
+      if (pretagChangelogWithByServerEntry && !status.endsWith("_by_user")) {
+        tbNewItem.changelogStatus = "modified_by_server";
+      }
+      
+      return await this._calendar.modifyItem(tbNewItem._item, tbOldItem._item); 
+    }        
+    
+    async deleteItem(tbItem, pretagChangelogWithByServerEntry = true) {
+      if (pretagChangelogWithByServerEntry) {
+        tbItem.changelogStatus = "deleted_by_server";
+      }
+      return await this._calendar.deleteItem(tbItem._item); 
+    }
+    
+    // searchId is interpreted as the primaryKeyField, which is the UID for this target
+    async getItem (searchId) {
+      let item = await this._calendar.getItem(searchId); 
+      if (item) {
+        return new TbSync.lightning.TbItem(this, item);
+      }
+      return null;
+    }
+
+    async getItemFromProperty(property, value) {
+      if (property == "UID") return await this.getItem(value);
+      else throw ("TbSync.lightning.getItemFromProperty: Currently onle the UID property can be used to search for items.");
+    }
+
+    async getAllItems() {
+      return await this._calendar.getItems(Ci.calICalendar.ITEM_FILTER_ALL_ITEMS, 0, null, null);
+    }
+  
+    getAddedItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this.calendar.id, maxitems, "added_by_user").map(item => item.itemId);
+    }
+
+    getModifiedItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this.calendar.id, maxitems, "modified_by_user").map(item => item.itemId);
+    }
+    
+    getDeletedItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this.calendar.id, maxitems, "deleted_by_user").map(item => item.itemId);
+    }
+    
+    getItemsFromChangeLog(maxitems = 0) {             
+      return TbSync.db.getItemsFromChangeLog(this.calendar.id, maxitems, "_by_user");
+    }
+
+    removeItemFromChangeLog(id, moveToEndInsteadOfDelete = false) {             
+      TbSync.db.removeItemFromChangeLog(this.calendar.id, id, moveToEndInsteadOfDelete);
+    }
+    
+    clearChangelog() {
+      TbSync.db.clearChangeLog(this.calendar.id);
+    }
+  },
+  
+
+
+
+  
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  // * Internal Functions
+  // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  
+  getFolderFromCalendarUID: function(calUID) {
+    let folders = TbSync.db.findFolders({"target": calUID});
+    if (folders.length == 1) {
+      let accountData = new TbSync.AccountData(folders[0].accountID);
+      return new TbSync.FolderData(accountData, folders[0].folderID);
+    }
+    return null;
+  },
+  
+  getFolderFromCalendarURL: function(calURL) {
+    let folders = TbSync.db.findFolders({"url": calURL});
+    if (folders.length == 1) {
+      let accountData = new TbSync.AccountData(folders[0].accountID);
+      return new TbSync.FolderData(accountData, folders[0].folderID);
+    }
+    return null;
+  },  
+  
+  calendarObserver : { 
+    onStartBatch : function () {},
+    onEndBatch : function () {},
+    onLoad : function (aCalendar) {},
+    onError : function (aCalendar, aErrNo, aMessage) {},
+
+    onAddItem : function (aAddedItem) { 
+      if (!(aAddedItem && aAddedItem.calendar))
+        return;
+
+      let folderData = TbSync.lightning.getFolderFromCalendarUID(aAddedItem.calendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        let tbCalendar = new TbSync.lightning.TbCalendar(aAddedItem.calendar, folderData);
+        let tbItem = new TbSync.lightning.TbItem(tbCalendar, aAddedItem);          
+        let itemStatus = tbItem.changelogStatus;
+
+        // if this card was created by us, it will be in the log
+        if (itemStatus && itemStatus.endsWith("_by_server")) {
+          let age = Date.now() - tbItem.changelogData.timestamp;
+          if (age < 1500) {
+            // during freeze, local modifications are not possible
+            return;
+          } else {
+            // remove blocking entry from changelog after freeze time is over (1.5s),
+            // and continue evaluating this event
+            abItem.changelogStatus = "";
+          }
+        } 
+
+        if (itemStatus == "deleted_by_user")  {
+          // deleted ?  user moved item out and back in -> modified
+          tbItem.changelogStatus = "modified_by_user";
+        } else {
+          tbItem.changelogStatus = "added_by_user";
+        }
+        
+        if (tbCalendar.logUserChanges) TbSync.core.setTargetModified(folderData);
+        folderData.targetData.itemObserver("onAddItem", tbItem, null);                                        
+      }
+    },
+
+    onModifyItem : function (aNewItem, aOldItem) {
+      //check, if it is a pure modification within the same calendar
+      if (!(aNewItem && aNewItem.calendar && aOldItem && aOldItem.calendar && aNewItem.calendar.id == aOldItem.calendar.id))
+        return;
+
+      let folderData = TbSync.lightning.getFolderFromCalendarUID(aNewItem.calendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        let tbCalendar = new TbSync.lightning.TbCalendar(aNewItem.calendar, folderData);
+        let tbNewItem = new TbSync.lightning.TbItem(tbCalendar, aNewItem);          
+        let tbOldItem = new TbSync.lightning.TbItem(tbCalendar, aOldItem);          
+        let itemStatus = tbNewItem.changelogStatus;
+          
+        // if this card was created by us, it will be in the log
+        if (itemStatus && itemStatus.endsWith("_by_server")) {
+          let age = Date.now() - tbNewItem.changelogData.timestamp;
+          if (age < 1500) {
+            // during freeze, local modifications are not possible
+            return;
+          } else {
+            // remove blocking entry from changelog after freeze time is over (1.5s),
+            // and continue evaluating this event
+            tbNewItem.changelogStatus = "";
+          }
+        } 
+
+        if (itemStatus != "added_by_user") {
+          //added_by_user -> it is a local unprocessed add do not re-add it to changelog
+          tbNewItem.changelogStatus = "modified_by_user";
+        }
+
+        if (tbCalendar.logUserChanges) TbSync.core.setTargetModified(folderData);
+        folderData.targetData.itemObserver("onModifyItem", tbNewItem, tbOldItem);                                        
+      }
+    },
+
+    onDeleteItem : function (aDeletedItem) {
+      if (!(aDeletedItem && aDeletedItem.calendar))
+        return;
+
+      let folderData = TbSync.lightning.getFolderFromCalendarUID(aDeletedItem.calendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        let tbCalendar = new TbSync.lightning.TbCalendar(aDeletedItem.calendar, folderData);
+        let tbItem = new TbSync.lightning.TbItem(tbCalendar, aDeletedItem);
+        let itemStatus = tbItem.changelogStatus;
+
+        // if this card was created by us, it will be in the log
+        if (itemStatus && itemStatus.endsWith("_by_server")) {
+          let age = Date.now() - tbItem.changelogData.timestamp;
+          if (age < 1500) {
+            // during freeze, local modifications are not possible
+            return;
+          } else {
+            // remove blocking entry from changelog after freeze time is over (1.5s),
+            // and continue evaluating this event
+            tbItem.changelogStatus = "";
+          }
+        } 
+
+        if (itemStatus == "added_by_user") {
+          //a local add, which has not yet been processed (synced) is deleted -> remove all traces
+          tbItem.changelogStatus = "";
+        } else {
+          tbItem.changelogStatus = "deleted_by_user";
+        }
+
+        if (tbCalendar.logUserChanges) TbSync.core.setTargetModified(folderData);
+        folderData.targetData.itemObserver("onDeleteItem", tbItem, null);
+      }
+    },
+
+    //Changed properties of the calendar itself (name, color etc.)
+    onPropertyChanged : function (aCalendar, aName, aValue, aOldValue) {
+      let folderData = TbSync.lightning.getFolderFromCalendarUID(aCalendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        let tbCalendar = new TbSync.lightning.TbCalendar(aCalendar, folderData);
+          
+        switch (aName) {
+          case "color":
+            // update stored color to recover after disable
+            folderData.setFolderProperty("targetColor", aValue); 
+            break;
+          case "name":
+            // update stored name to recover after disable
+            folderData.setFolderProperty("targetName", aValue);                         
+            // update settings window, if open
+            Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folderData.accountID);                    
+            break;
+        }
+        
+        folderData.targetData.calendarObserver("onCalendarPropertyChanged", tbCalendar, aName, aValue, aOldValue);                
+      }
+    },
+
+    //Deleted properties of the calendar itself (name, color etc.)
+    onPropertyDeleting : function (aCalendar, aName) {
+      let folderData = TbSync.lightning.getFolderFromCalendarUID(aCalendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        let tbCalendar = new TbSync.lightning.TbCalendar(aCalendar, folderData);
+          
+        switch (aName) {
+          case "color":
+          case "name":
+            //update settings window, if open
+            Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folderData.accountID);                    
+          break;
+        }
+
+        folderData.targetData.calendarObserver("onCalendarPropertyDeleted", tbCalendar, aName);                
+      }
+    }
+  },
+
+  calendarManagerObserver : {
+    onCalendarRegistered : function (aCalendar) {              
+    },
+    
+    onCalendarUnregistering : function (aCalendar) {
+      /*let folderData = TbSync.lightning.getFolderFromCalendarUID(aCalendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        folderData.targetData.calendarObserver("onCalendarUnregistered", aCalendar);                
+      }*/
+    },
+      
+    onCalendarDeleting : async function (aCalendar) {
+      let folderData = TbSync.lightning.getFolderFromCalendarUID(aCalendar.id);                    
+      if (folderData 
+        && folderData.targetData 
+        && folderData.targetData.isAdvancedCalendarTargetData) {
+
+        // If the user switches "offline support", the calendar is deleted and recreated. Thus,
+        // we wait a bit and check, if the calendar is back again and ignore the delete event.
+        if (aCalendar.type == "caldav") {
+          await TbSync.tools.sleep(1500);
+          let calManager = TbSync.lightning.cal.manager;
+          for (let calendar of calManager.getCalendars({})) {
+            if (calendar.uri.spec == aCalendar.uri.spec) {
+              // update the target
+              folderData.setFolderProperty("target", calendar.id)
+              return;
+            }
+          }
+        }
+        
+        //delete any pending changelog of the deleted calendar
+        TbSync.db.clearChangeLog(aCalendar.id);			
+
+        let tbCalendar = new TbSync.lightning.TbCalendar(aCalendar, folderData);
+          
+        //unselect calendar if deleted by user and update settings window, if open
+        if (folderData.getFolderProperty("selected")) {
+          folderData.setFolderProperty("selected", false);
+          //update settings window, if open
+          Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folderData.accountID);
+        }
+        
+        folderData.resetFolderProperty("target");
+        folderData.targetData.calendarObserver("onCalendarDeleted", tbCalendar);                
+
+      }
+    },
+  },
+
+  
+  
+  //this function actually creates a calendar if missing
+  prepareAndCreateCalendar: async function (folderData) {       
+    let calManager = TbSync.lightning.cal.manager;
+    let provider = folderData.accountData.getAccountProperty("provider");
+
+    //check if  there is a known/cached name, and use that as starting point to generate unique name for new calendar 
+    let cachedName = folderData.getFolderProperty("targetName");                         
+    let newname = cachedName == "" ? folderData.accountData.getAccountProperty("accountname") + " (" + folderData.getFolderProperty("foldername") + ")" : cachedName;
+
+    //check if there is a cached or preloaded color - if not, chose one
+    if (!folderData.getFolderProperty("targetColor")) {
+      //define color set
+      let allColors = [
+        "#3366CC",
+        "#DC3912",
+        "#FF9900",
+        "#109618",
+        "#990099",
+        "#3B3EAC",
+        "#0099C6",
+        "#DD4477",
+        "#66AA00",
+        "#B82E2E",
+        "#316395",
+        "#994499",
+        "#22AA99",
+        "#AAAA11",
+        "#6633CC",
+        "#E67300",
+        "#8B0707",
+        "#329262",
+        "#5574A6",
+        "#3B3EAC"];
+      
+      //find all used colors
+      let usedColors = [];
+      for (let calendar of calManager.getCalendars({})) {
+        if (calendar && calendar.getProperty("color")) {
+          usedColors.push(calendar.getProperty("color").toUpperCase());
+        }
+      }
+
+      //we do not want to change order of colors, we want to FILTER by counts, so we need to find the least count, filter by that and then take the first one
+      let minCount = null;
+      let statColors = [];
+      for (let i=0; i< allColors.length; i++) {
+        let count = usedColors.filter(item => item == allColors[i]).length;
+        if (minCount === null) minCount = count;
+        else if (count < minCount) minCount = count;
+
+        let obj = {};
+        obj.color = allColors[i];
+        obj.count = count;
+        statColors.push(obj);
+      }
+      
+      //filter by minCount
+      let freeColors = statColors.filter(item => (minCount == null || item.count == minCount));
+      folderData.setFolderProperty("targetColor", freeColors[0].color);        
+    }
+    
+    //create and register new calendar
+    let newCalendar = await folderData.targetData.createCalendar(newname);
+    newCalendar.setProperty("tbSyncProvider", provider);
+    newCalendar.setProperty("tbSyncAccountID", folderData.accountData.accountID);
+
+    //store id of calendar as target in DB
+    folderData.setFolderProperty("target", newCalendar.id); 
+    folderData.setFolderProperty("targetName", newCalendar.name);
+    folderData.setFolderProperty("targetColor",  newCalendar.getProperty("color"));
+    return newCalendar;        
+  }
+}
diff --git a/content/modules/manager.js b/content/modules/manager.js
new file mode 100644
index 0000000..12ef4b2
--- /dev/null
+++ b/content/modules/manager.js
@@ -0,0 +1,392 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+ 
+var manager = {
+
+  prefWindowObj: null,
+  
+  load: async function () {
+  },
+
+  unload: async function () {
+    //close window (if open)
+    if (this.prefWindowObj !== null) this.prefWindowObj.close();
+  },
+
+
+
+
+
+  openManagerWindow: function(event) {
+    if (!event.button) { //catches zero or undefined
+      if (TbSync.enabled) {
+        // check, if a window is already open and just put it in focus
+        if (this.prefWindowObj === null) {
+          this.prefWindowObj = TbSync.window.open("chrome://tbsync/content/manager/accountManager.xhtml", "TbSyncAccountManagerWindow", "chrome,centerscreen");
+        }
+        this.prefWindowObj.focus();
+      } else {
+        //this.popupNotEnabled();
+      }
+    }
+  },
+
+  popupNotEnabled: function () {
+    TbSync.dump("Oops", "Trying to open account manager, but init sequence not yet finished");
+    let msg = TbSync.getString("OopsMessage") + "\n\n";
+    let v = Services.appinfo.platformVersion; 
+    if (TbSync.prefs.getIntPref("log.userdatalevel") == 0) {
+      if (TbSync.window.confirm(msg + TbSync.getString("UnableToTraceError"))) {
+        TbSync.prefs.setIntPref("log.userdatalevel", 1);
+        TbSync.window.alert(TbSync.getString("RestartThunderbirdAndTryAgain"));
+      }
+    } else {
+      if (TbSync.window.confirm(msg + TbSync.getString("HelpFixStartupError"))) {
+        this.createBugReport("john.bieling@gmx.de", msg, "");
+      }
+    }
+  },
+  
+  openTBtab: function (url) {
+    let tabmail = TbSync.window.document.getElementById("tabmail");
+    if (TbSync.window && tabmail) {
+      TbSync.window.focus();
+      return tabmail.openTab("contentTab", {
+        url
+      });
+    }
+    return null;
+  },
+
+  openTranslatedLink: function (url) {
+    let googleCode = TbSync.getString("google.translate.code");
+    if (googleCode != "en" && googleCode != "google.translate.code") {
+      this.openLink("https://translate.google.com/translate?hl=en&sl=en&tl="+TbSync.getString("google.translate.code")+"&u="+url);
+    } else {
+      this.openLink(url);
+    }
+  },
+
+  openLink: function (url) {
+    let ioservice = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
+    let uriToOpen = ioservice.newURI(url, null, null);
+    let extps = Components.classes["@mozilla.org/uriloader/external-protocol-service;1"].getService(Components.interfaces.nsIExternalProtocolService);
+    extps.loadURI(uriToOpen, null);    
+  },
+  
+  openBugReportWizard: function () {
+    if (!TbSync.debugMode) {
+      this.prefWindowObj.alert(TbSync.getString("NoDebugLog"));
+    } else {
+      this.prefWindowObj.openDialog("chrome://tbsync/content/manager/support-wizard/support-wizard.xhtml", "support-wizard", "dialog,centerscreen,chrome,resizable=no");
+    }
+  },
+  
+  createBugReport: function (email, subject, description) {
+    let fields = Components.classes["@mozilla.org/messengercompose/composefields;1"].createInstance(Components.interfaces.nsIMsgCompFields); 
+    let params = Components.classes["@mozilla.org/messengercompose/composeparams;1"].createInstance(Components.interfaces.nsIMsgComposeParams); 
+
+    fields.to = email; 
+    fields.subject = "TbSync " + TbSync.addon.version.toString() + " bug report: " + subject; 
+    fields.body = "Hi,\n\n" +
+      "attached you find my debug.log for the following error:\n\n" + 
+      description; 
+
+    params.composeFields = fields; 
+    params.format = Components.interfaces.nsIMsgCompFormat.PlainText; 
+
+    let attachment = Components.classes["@mozilla.org/messengercompose/attachment;1"].createInstance(Components.interfaces.nsIMsgAttachment);
+    attachment.contentType = "text/plain";
+    attachment.url =  'file://' + TbSync.io.getAbsolutePath("debug.log");
+    attachment.name = "debug.log";
+    attachment.temporary = false;
+
+    params.composeFields.addAttachment(attachment);        
+    MailServices.compose.OpenComposeWindowWithParams (null, params);    
+  },
+
+  viewDebugLog: function() {
+
+    if (this.debugLogWindow && this.debugLogWindow.tabNode) {
+      let tabmail = TbSync.window.document.getElementById("tabmail");
+      try {
+        tabmail.closeTab(this.debugLogWindow);
+      } catch (e) {
+        // nope
+      }
+      this.debugLogWindow = null;
+    } 
+    this.debugLogWindow = this.openTBtab('file://' + TbSync.io.getAbsolutePath("debug.log"));
+  },
+}
+
+
+
+/**
+ * Functions used by the folderlist in the main account settings tab
+ */
+manager.FolderList = class {
+  /**
+   * @param {string}  provider  Identifier for the provider this FolderListView is created for.
+   */
+  constructor(provider) {
+    this.provider = provider
+  }
+  
+  /**
+   * Is called before the context menu of the folderlist is shown, allows to
+   * show/hide custom menu options based on selected folder
+   *
+   * @param document       [in] document object of the account settings window - element.ownerDocument - menuentry?
+   * @param folderData         [in] FolderData of the selected folder
+   */
+  onContextMenuShowing(window, folderData) {
+    return TbSync.providers[this.provider].StandardFolderList.onContextMenuShowing(window, folderData);
+  }
+
+
+  /**
+   * Returns an array of attribute objects, which define the number of columns 
+   * and the look of the header
+   */
+  getHeader() {
+    return [
+      {style: "font-weight:bold;", label: "", width: "93"},
+      {style: "font-weight:bold;", label: TbSync.getString("manager.resource"), width:"150"},
+      {style: "font-weight:bold;", label: TbSync.getString("manager.status"), flex :"1"},
+    ]
+  }
+
+
+  /**
+   * Is called to add a row to the folderlist. After this call, updateRow is called as well.
+   *
+   * @param document        [in] document object of the account settings window
+   * @param folderData         [in] FolderData of the folder in the row
+   */        
+  getRow(document, folderData) {
+    //create checkBox for select state
+    let itemSelCheckbox = document.createXULElement("checkbox");
+    itemSelCheckbox.setAttribute("updatefield", "selectbox");
+    itemSelCheckbox.setAttribute("style", "margin: 0px 0px 0px 3px;");
+    itemSelCheckbox.addEventListener("command", this.toggleFolder);
+
+    //icon
+    let itemType = document.createXULElement("image");
+    itemType.setAttribute("src", TbSync.providers[this.provider].StandardFolderList.getTypeImage(folderData));
+    itemType.setAttribute("style", "margin: 0px 9px 0px 3px;");
+
+    //ACL
+    let roAttributes = TbSync.providers[this.provider].StandardFolderList.getAttributesRoAcl(folderData);
+    let rwAttributes = TbSync.providers[this.provider].StandardFolderList.getAttributesRwAcl(folderData);
+    let itemACL = document.createXULElement("button");
+    itemACL.setAttribute("image", "chrome://tbsync/content/skin/acl_" + (folderData.getFolderProperty("downloadonly") ? "ro" : "rw") + ".png");
+    itemACL.setAttribute("class", "plain");
+    itemACL.setAttribute("style", "width: 35px; min-width: 35px; margin: 0; height:26px");
+    itemACL.setAttribute("updatefield", "acl");
+    if (roAttributes && rwAttributes) {
+      itemACL.setAttribute("type", "menu");
+      let menupopup = document.createXULElement("menupopup");
+      {
+        let menuitem = document.createXULElement("menuitem");
+        menuitem.downloadonly = false;
+        menuitem.setAttribute("class", "menuitem-iconic");
+        menuitem.setAttribute("image", "chrome://tbsync/content/skin/acl_rw2.png");
+        menuitem.addEventListener("command", this.updateReadOnly);
+        for (const [attr, value] of Object.entries(rwAttributes)) {
+          menuitem.setAttribute(attr, value);
+        }                    
+        menupopup.appendChild(menuitem);
+      }
+      
+      {
+        let menuitem = document.createXULElement("menuitem");
+        menuitem.downloadonly = true;
+        menuitem.setAttribute("class", "menuitem-iconic");
+        menuitem.setAttribute("image", "chrome://tbsync/content/skin/acl_ro2.png");
+        menuitem.addEventListener("command", this.updateReadOnly);
+        for (const [attr, value] of Object.entries(roAttributes)) {
+          menuitem.setAttribute(attr, value);
+        }                    
+        menupopup.appendChild(menuitem);
+      }
+      itemACL.appendChild(menupopup);
+    }
+    
+    //folder name
+    let itemLabel = document.createXULElement("description");
+    itemLabel.setAttribute("updatefield", "foldername");
+
+    //status
+    let itemStatus = document.createXULElement("description");
+    itemStatus.setAttribute("updatefield", "status");
+    
+    //group1
+    let itemHGroup1 = document.createXULElement("hbox");
+    itemHGroup1.setAttribute("align", "center");
+    itemHGroup1.appendChild(itemSelCheckbox);
+    itemHGroup1.appendChild(itemType);
+    if (itemACL) itemHGroup1.appendChild(itemACL);
+
+    let itemVGroup1 = document.createXULElement("vbox");
+    //itemVGroup1.setAttribute("width", "93");
+    itemVGroup1.setAttribute("style", "width: 93px");
+    itemVGroup1.appendChild(itemHGroup1);
+
+    //group2
+    let itemHGroup2 = document.createXULElement("hbox");
+    itemHGroup2.setAttribute("align", "center");
+    itemHGroup2.setAttribute("style", "border: 1px center");
+    itemHGroup2.appendChild(itemLabel);
+
+    let itemVGroup2 = document.createXULElement("vbox");
+    //itemVGroup2.setAttribute("width", "150");
+    itemVGroup2.setAttribute("style", "padding: 3px; width: 150px");
+    itemVGroup2.appendChild(itemHGroup2);
+
+    //group3
+    let itemHGroup3 = document.createXULElement("hbox");
+    itemHGroup3.setAttribute("align", "center");
+    itemHGroup3.appendChild(itemStatus);
+
+    let itemVGroup3 = document.createXULElement("vbox");
+    //itemVGroup3.setAttribute("width", "250");
+    itemVGroup3.setAttribute("style", "padding: 3px; width: 250px");
+    itemVGroup3.appendChild(itemHGroup3);
+
+    //final row
+    let row = document.createXULElement("hbox");
+    row.setAttribute("style", "min-height: 24px;");
+    row.appendChild(itemVGroup1);
+    row.appendChild(itemVGroup2);            
+    row.appendChild(itemVGroup3);            
+    return row;               
+  }
+
+
+  /**
+   * ToggleFolder event
+   */
+  toggleFolder(event) {
+    let element = event.target;
+    let folderList = element.ownerDocument.getElementById("tbsync.accountsettings.folderlist");
+    if (folderList.selectedItem !== null && !folderList.disabled) {
+      // the folderData obj of the selected folder is attached to its row entry
+      let folder = folderList.selectedItem.folderData;
+
+      if (!folder.accountData.isEnabled())
+        return;
+    
+      if (folder.getFolderProperty("selected")) {
+        // hasTarget() can throw an error, ignore that here
+        try {
+          if (!folder.targetData.hasTarget() || element.ownerDocument.defaultView.confirm(TbSync.getString("prompt.Unsubscribe"))) {
+            folder.targetData.removeTarget();           
+            folder.setFolderProperty("selected", false);          
+          } else {
+            if (element) {
+              //undo users action
+              element.setAttribute("checked", true);
+            }
+          }
+        } catch (e) {
+          folder.setFolderProperty("selected", false);
+          Components.utils.reportError(e);
+        }
+      } else {
+        //select and update status
+        folder.setFolderProperty("selected", true);
+        folder.setFolderProperty("status", "aborted");
+        folder.accountData.setAccountProperty("status", "notsyncronized");
+      }
+      Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", folder.accountID);
+    }
+  }
+  
+  /**
+   * updateReadOnly event
+   */
+  updateReadOnly(event) {
+    let element = event.target;
+    let folderList = element.ownerDocument.getElementById("tbsync.accountsettings.folderlist");
+    if (folderList.selectedItem !== null && !folderList.disabled) {
+      //the folderData obj of the selected folder is attached to its row entry
+      let  folder = folderList.selectedItem.folderData;
+
+      //update value
+      let value = element.downloadonly;
+      folder.setFolderProperty("downloadonly", value);
+
+      //update icon
+      let button = element.parentNode.parentNode;
+      if (value) {
+        button.setAttribute('image','chrome://tbsync/content/skin/acl_ro.png');
+      } else {
+        button.setAttribute('image','chrome://tbsync/content/skin/acl_rw.png');
+      }
+        
+      folder.targetData.setReadOnly(value);
+    }
+  }
+
+  /**
+   * Is called to update a row of the folderlist (the first cell is a select checkbox inserted by TbSync)
+   *
+   * @param document       [in] document object of the account settings window
+   * @param listItem       [in] the listitem of the row, which needs to be updated
+   * @param folderData        [in] FolderData for that row
+   */        
+  updateRow(document, listItem, folderData) {
+    let foldername = TbSync.providers[this.provider].StandardFolderList.getFolderDisplayName(folderData);
+    let status = folderData.getFolderStatus();
+    let selected = folderData.getFolderProperty("selected");
+    
+    // get updatefields
+    let fields = {}
+    for (let f of listItem.querySelectorAll("[updatefield]")) {
+      fields[f.getAttribute("updatefield")] = f;
+    }
+    
+    // update fields
+    fields.foldername.setAttribute("disabled", !selected);
+    fields.foldername.setAttribute("style", selected ? "" : "font-style:italic");
+    if (fields.foldername.textContent != foldername) {
+      fields.foldername.textContent = foldername;
+      fields.foldername.flex = "1";
+    }
+    
+    fields.status.setAttribute("style", selected ? "" : "font-style:italic");
+    if (fields.status.textContent != status) {
+      fields.status.textContent = status;
+      fields.status.flex = "1";
+    }
+    
+    if (fields.hasOwnProperty("acl")) {
+      fields.acl.setAttribute("image", "chrome://tbsync/content/skin/acl_" + (folderData.getFolderProperty("downloadonly") ? "ro" : "rw") + ".png");
+      fields.acl.setAttribute("disabled", folderData.accountData.isSyncing());
+    }
+    
+    // update selectbox
+    let selbox = fields.selectbox;
+    if (selbox) {
+      if (folderData.getFolderProperty("selected")) {
+        selbox.setAttribute("checked", true);
+      } else {
+        selbox.removeAttribute("checked");
+      }
+      
+      if (folderData.accountData.isSyncing()) {
+        selbox.setAttribute("disabled", true);
+      } else {
+        selbox.removeAttribute("disabled");
+      }
+    }
+  }
+}    
diff --git a/content/modules/messenger.js b/content/modules/messenger.js
new file mode 100644
index 0000000..eb986c7
--- /dev/null
+++ b/content/modules/messenger.js
@@ -0,0 +1,99 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+var messenger = {
+
+  overlayManager : null,
+  
+  load: async function () {
+    this.overlayManager = new OverlayManager(TbSync.extension, {verbose: 0});
+    await this.overlayManager.registerOverlay("chrome://messenger/content/messenger.xhtml", "chrome://tbsync/content/overlays/messenger.xhtml");
+    Services.obs.addObserver(this.initSyncObserver, "tbsync.observer.sync", false);
+    Services.obs.addObserver(this.syncstateObserver, "tbsync.observer.manager.updateSyncstate", false);
+
+    //inject overlays
+    this.overlayManager.startObserving();
+
+  },
+
+  unload: async function () {
+    //unload overlays
+    this.overlayManager.stopObserving();
+
+    Services.obs.removeObserver(this.initSyncObserver, "tbsync.observer.sync");
+    Services.obs.removeObserver(this.syncstateObserver, "tbsync.observer.manager.updateSyncstate");
+  },
+
+  // observer to catch changing syncstate and to update the status bar.
+  syncstateObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      //update status bar in all main windows
+      let windows = Services.wm.getEnumerator("mail:3pane");
+      while (windows.hasMoreElements()) {
+        let domWindow = windows.getNext();
+        if (TbSync) {
+          let status = domWindow.document.getElementById("tbsync.status");
+          if (status) {
+            let label = "TbSync: ";
+            
+            if (TbSync.enabled) {
+
+              //check if any account is syncing, if not switch to idle
+              let accounts = TbSync.db.getAccounts();
+              let idle = true;
+              let err = false;
+          
+              for (let i=0; i<accounts.allIDs.length && idle; i++) {
+                if (!accounts.IDs.includes(accounts.allIDs[i])) {
+                  err = true;
+                  continue;
+                }
+          
+                //set idle to false, if at least one account is syncing
+                if (TbSync.core.isSyncing(accounts.allIDs[i])) idle = false;
+            
+                //check for errors
+                switch (TbSync.db.getAccountProperty(accounts.allIDs[i], "status")) {
+                  case "success":
+                  case "disabled":
+                  case "notsyncronized":
+                  case "syncing":
+                    break;
+                  default:
+                    err = true;
+                }
+              }
+
+              if (idle) {
+                if (err) label += TbSync.getString("info.error");   
+                else label += TbSync.getString("info.idle");   
+              } else {
+                label += TbSync.getString("status.syncing");
+              }
+            } else {
+              label += "Loading";
+            }
+            status.value = label;
+          }
+        }
+      }
+    }
+  },
+  
+  // observer to init sync
+  initSyncObserver: {
+    observe: function (aSubject, aTopic, aData) {
+      if (TbSync.enabled) {
+        TbSync.core.syncAllAccounts();
+      } else {
+        //TbSync.manager.popupNotEnabled();
+      }
+    }
+  },    
+}
diff --git a/content/modules/network.js b/content/modules/network.js
new file mode 100644
index 0000000..f5e81d3
--- /dev/null
+++ b/content/modules/network.js
@@ -0,0 +1,114 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+ 
+var network = {
+
+  load: async function () {
+  },
+
+  unload: async function () {
+  },
+  
+  getContainerIdForUser: function(username) {
+    //define the allowed range of container ids to be used
+    let min = 10000;
+    let max = 19999;
+    
+    //we need to store the container map in the main window, so it is persistent and survives a restart of this bootstrapped addon
+    //TODO: is there a better way to store this container map globally? Can there be TWO main windows?
+    let mainWindow = Services.wm.getMostRecentWindow("mail:3pane");
+
+    //init
+    if (!(mainWindow._containers)) {
+      mainWindow._containers = [];
+    }
+    
+    //reset if adding an entry will exceed allowed range
+    if (mainWindow._containers.length > (max-min) && mainWindow._containers.indexOf(username) == -1) {
+      for (let i=0; i < mainWindow._containers.length; i++) {
+        //Services.clearData.deleteDataFromOriginAttributesPattern({ userContextId: i + min });
+        Services.obs.notifyObservers(null, "clear-origin-attributes-data", JSON.stringify({ userContextId: i + min }));
+      }
+      mainWindow._containers = [];
+    }
+    
+    let idx = mainWindow._containers.indexOf(username);
+    return (idx == -1) ? mainWindow._containers.push(username) - 1 + min : (idx + min);
+  },
+  
+  resetContainerForUser: function(username) {
+    let id = this.getContainerIdForUser(username);
+    Services.obs.notifyObservers(null, "clear-origin-attributes-data", JSON.stringify({ userContextId: id }));
+  },
+
+  createTCPErrorFromFailedXHR: function (xhr) {
+    return this.createTCPErrorFromFailedRequest(xhr.channel.QueryInterface(Components.interfaces.nsIRequest));
+  },
+  
+  createTCPErrorFromFailedRequest: function (request) {
+    //adapted from :
+    //https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/How_to_check_the_secruity_state_of_an_XMLHTTPRequest_over_SSL		
+    //codes: https://developer.mozilla.org/en-US/docs/Mozilla/Errors
+    let status = request.status;
+
+    if ((status & 0xff0000) === 0x5a0000) { // Security module
+      const nsINSSErrorsService = Components.interfaces.nsINSSErrorsService;
+      let nssErrorsService = Components.classes['@mozilla.org/nss_errors_service;1'].getService(nsINSSErrorsService);
+      
+      // NSS_SEC errors (happen below the base value because of negative vals)
+      if ((status & 0xffff) < Math.abs(nsINSSErrorsService.NSS_SEC_ERROR_BASE)) {
+
+        // The bases are actually negative, so in our positive numeric space, we
+        // need to subtract the base off our value.
+        let nssErr = Math.abs(nsINSSErrorsService.NSS_SEC_ERROR_BASE) - (status & 0xffff);
+        switch (nssErr) {
+          case 11: return 'security::SEC_ERROR_EXPIRED_CERTIFICATE';
+          case 12: return 'security::SEC_ERROR_REVOKED_CERTIFICATE';
+          case 13: return 'security::SEC_ERROR_UNKNOWN_ISSUER';
+          case 20: return 'security::SEC_ERROR_UNTRUSTED_ISSUER';
+          case 21: return 'security::SEC_ERROR_UNTRUSTED_CERT';
+          case 36: return 'security::SEC_ERROR_CA_CERT_INVALID';
+          case 90: return 'security::SEC_ERROR_INADEQUATE_KEY_USAGE';
+          case 176: return 'security::SEC_ERROR_CERT_SIGNATURE_ALGORITHM_DISABLED';
+        }
+        return 'security::UNKNOWN_SECURITY_ERROR';
+        
+      } else {
+
+        // Calculating the difference 		  
+        let sslErr = Math.abs(nsINSSErrorsService.NSS_SSL_ERROR_BASE) - (status & 0xffff);		
+        switch (sslErr) {
+          case 3: return 'security::SSL_ERROR_NO_CERTIFICATE';
+          case 4: return 'security::SSL_ERROR_BAD_CERTIFICATE';
+          case 8: return 'security::SSL_ERROR_UNSUPPORTED_CERTIFICATE_TYPE';
+          case 9: return 'security::SSL_ERROR_UNSUPPORTED_VERSION';
+          case 12: return 'security::SSL_ERROR_BAD_CERT_DOMAIN';
+        }
+        return 'security::UNKOWN_SSL_ERROR';
+        
+      }
+
+    } else { //not the security module
+      
+      switch (status) {
+        case 0x804B000C: return 'network::NS_ERROR_CONNECTION_REFUSED';
+        case 0x804B000E: return 'network::NS_ERROR_NET_TIMEOUT';
+        case 0x804B001E: return 'network::NS_ERROR_UNKNOWN_HOST';
+        case 0x804B0047: return 'network::NS_ERROR_NET_INTERRUPT';
+        case 0x805303F4: return 'network::NS_ERROR_DOM_BAD_URI';
+        // Custom error
+        case 0x804B002F: return 'network::REJECTED_REDIRECT_FROM_HTTPS_TO_HTTP';
+      }
+      return 'network::UNKNOWN_NETWORK_ERROR';
+
+    }
+    return null;	 
+  },
+}
diff --git a/content/modules/passwordManager.js b/content/modules/passwordManager.js
new file mode 100644
index 0000000..0145cd1
--- /dev/null
+++ b/content/modules/passwordManager.js
@@ -0,0 +1,78 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var passwordManager = {
+
+  load: async function () {
+  },
+
+  unload: async function () {
+  },
+
+  removeLoginInfos: function(origin, realm, users = null) {
+    let nsLoginInfo = new Components.Constructor("@mozilla.org/login-manager/loginInfo;1", Components.interfaces.nsILoginInfo, "init");
+
+    let logins = Services.logins.findLogins(origin, null, realm);
+    for (let i = 0; i < logins.length; i++) {
+      if (!users || users.includes(logins[i].username)) {
+        let currentLoginInfo = new nsLoginInfo(origin, null, realm, logins[i].username, logins[i].password, "", "");
+        try {
+          Services.logins.removeLogin(currentLoginInfo);
+        } catch (e) {
+          TbSync.dump("Error removing loginInfo", e);
+        }
+      }
+    }
+  },
+
+  updateLoginInfo: function(origin, realm, oldUser, newUser, newPassword) {
+    let nsLoginInfo = new Components.Constructor("@mozilla.org/login-manager/loginInfo;1", Components.interfaces.nsILoginInfo, "init");
+    
+    this.removeLoginInfos(origin, realm, [oldUser, newUser]);
+    
+    let newLoginInfo = new nsLoginInfo(origin, null, realm, newUser, newPassword, "", "");
+    try {
+      Services.logins.addLogin(newLoginInfo);
+    } catch (e) {
+      TbSync.dump("Error adding loginInfo", e);
+    }
+  },
+  
+  getLoginInfo: function(origin, realm, user) {
+    let logins = Services.logins.findLogins(origin, null, realm);
+    for (let i = 0; i < logins.length; i++) {
+      if (logins[i].username == user) {
+        return logins[i].password;
+      }
+    }
+    return null;
+  },
+
+  
+  /** data obj
+    windowID
+    accountName
+    userName
+    userNameLocked
+  
+  reference is an object in which an entry with windowID will be placed to hold a reference to the prompt window (so it can be closed externaly)
+  */
+  asyncPasswordPrompt: async function(data, reference) {
+    if (data.windowID) {
+      let url = "chrome://tbsync/content/passwordPrompt/passwordPrompt.xhtml";
+  
+      return await new Promise(function(resolve, reject) {
+       reference[data.windowID] = TbSync.window.openDialog(url, "TbSyncPasswordPrompt:" + data.windowID, "centerscreen,chrome,resizable=no", data, resolve);
+      });
+    }
+    
+    return false;
+  }
+}
diff --git a/content/modules/providers.js b/content/modules/providers.js
new file mode 100644
index 0000000..562b763
--- /dev/null
+++ b/content/modules/providers.js
@@ -0,0 +1,184 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+ 
+var providers = {
+
+  //list of default providers (available in add menu, even if not installed)
+  defaultProviders: {
+    "google" : {
+      name: "Google's People API", 
+      homepageUrl: "https://addons.thunderbird.net/addon/google-4-tbsync/"},
+    "dav" : {
+      name: "CalDAV & CardDAV", 
+      homepageUrl: "https://addons.thunderbird.net/addon/dav-4-tbsync/"},
+    "eas" : {
+      name: "Exchange ActiveSync", 
+      homepageUrl: "https://addons.thunderbird.net/addon/eas-4-tbsync/"},
+  },
+  
+  loadedProviders: null,    
+  
+  load: async function () {
+    this.loadedProviders = {};
+  },
+
+  unload: async function () {
+    for (let provider in this.loadedProviders) {
+      await this.unloadProvider(provider);
+    }
+  },
+
+
+
+  
+  
+  loadProvider:  async function (extension, provider, js) {
+    //only load, if not yet loaded and if the provider name does not shadow a fuction inside provider.js
+    if (!this.loadedProviders.hasOwnProperty(provider) && !this.hasOwnProperty(provider) && js.startsWith("chrome://")) {
+      try {
+        let addon = await AddonManager.getAddonByID(extension.id);
+
+        //load provider subscripts into TbSync
+        this[provider] = {};
+        Services.scriptloader.loadSubScript(js, this[provider], "UTF-8");
+        if (TbSync.apiVersion != this[provider].Base.getApiVersion()) {
+          throw new Error("API version mismatch, TbSync@"+TbSync.apiVersion+" vs " + provider + "@" + this[provider].Base.getApiVersion());
+        }
+        
+        this.loadedProviders[provider] = {
+          addon, extension, 
+          addonId: extension.id, 
+          version: addon.version.toString(),
+          createAccountWindow: null
+        };
+
+        addon.contributorsURL = this[provider].Base.getContributorsUrl();
+
+        // check if provider has its own implementation of folderList
+        if (!this[provider].hasOwnProperty("folderList")) this[provider].folderList = new TbSync.manager.FolderList(provider);
+        
+        //load provider
+        await this[provider].Base.load();
+
+        await TbSync.messenger.overlayManager.registerOverlay("chrome://tbsync/content/manager/editAccount.xhtml?provider=" + provider, this[provider].Base.getEditAccountOverlayUrl());        
+        TbSync.dump("Loaded provider", provider + "::" + this[provider].Base.getProviderName() + " ("+this.loadedProviders[provider].version+")");
+        
+        // reset all accounts of this provider
+        let providerData = new TbSync.ProviderData(provider);
+        let accounts = providerData.getAllAccounts();
+        for (let accountData of accounts) {
+          // reset sync objects
+          TbSync.core.resetSyncDataObj(accountData.accountID);
+          
+          // set all accounts which are syncing to notsyncronized 
+          if (accountData.getAccountProperty("status") == "syncing") accountData.setAccountProperty("status", "notsyncronized");
+
+          // set each folder with PENDING status to ABORTED
+          let folders = TbSync.db.findFolders({"status": "pending"}, {"accountID": accountData.accountID});
+
+          for (let f=0; f < folders.length; f++) {
+            TbSync.db.setFolderProperty(folders[f].accountID, folders[f].folderID, "status", "aborted");
+          }
+        }
+        
+        Services.obs.notifyObservers(null, "tbsync.observer.manager.updateProviderList", provider);
+        Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", null);
+
+        // TB60 -> TB68 migration - remove icon and rename target if stale
+        for (let addressBook of MailServices.ab.directories) {
+          if (addressBook instanceof Components.interfaces.nsIAbDirectory) {
+            let storedProvider = TbSync.addressbook.getStringValue(addressBook, "tbSyncProvider", "");
+            if (provider == storedProvider && providerData.getFolders({"target": addressBook.UID}).length == 0) {
+              let name = addressBook.dirName;
+              addressBook.dirName = TbSync.getString("target.orphaned") + ": " + name;              
+              addressBook.setStringValue("tbSyncIcon", "orphaned");
+              addressBook.setStringValue("tbSyncProvider", "orphaned");
+              addressBook.setStringValue("tbSyncAccountID", "");
+            }
+          }
+        }
+        
+        let calManager = TbSync.lightning.cal.manager;
+        for (let calendar of calManager.getCalendars({})) {
+          let storedProvider = calendar.getProperty("tbSyncProvider");
+          if (provider == storedProvider && calendar.type == "storage" && providerData.getFolders({"target": calendar.id}).length == 0) {
+            let name = calendar.name;
+            calendar.name = TbSync.getString("target.orphaned") + ": " + name;
+            calendar.setProperty("disabled", true);
+            calendar.setProperty("tbSyncProvider", "orphaned");
+            calendar.setProperty("tbSyncAccountID", "");        
+          }
+        }
+        
+      } catch (e) {
+        delete this.loadedProviders[provider];
+        delete this[provider];
+        let info = new EventLogInfo(provider);
+        TbSync.eventlog.add("error", info, "FAILED to load provider <"+provider+">", e.message);
+        Components.utils.reportError(e);        
+      }
+
+    }
+  },
+  
+  unloadProvider: async function (provider) {        
+    if (this.loadedProviders.hasOwnProperty(provider)) {
+      TbSync.dump("Unloading provider", provider);
+      
+       if (this.loadedProviders[provider].createAccountWindow) {
+         this.loadedProviders[provider].createAccountWindow.close();
+       }
+
+      await this[provider].Base.unload();
+      delete this.loadedProviders[provider];
+      delete this[provider];            
+      Services.obs.notifyObservers(null, "tbsync.observer.manager.updateProviderList", provider);
+      Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", null);
+    }
+  },
+  
+  getDefaultAccountEntries: function (provider) {
+    let defaults = TbSync.providers[provider].Base.getDefaultAccountEntries();
+    
+    // List of default system account properties. 
+    // Do not remove search marker for doc. 
+    // DefaultAccountPropsStart
+    defaults.provider = provider;
+    defaults.accountID = "";
+    defaults.lastsynctime = 0;
+    defaults.status = "disabled";
+    defaults.autosync = 0;
+    defaults.noAutosyncUntil = 0;
+    defaults.accountname = "";
+    // DefaultAccountPropsEnd
+
+    return defaults;
+  },
+  
+  getDefaultFolderEntries: function (accountID) {
+    let provider = TbSync.db.getAccountProperty(accountID, "provider");
+    let defaults = TbSync.providers[provider].Base.getDefaultFolderEntries();
+    
+    // List of default system folder properties.
+    // Do not remove search marker for doc. 
+    // DefaultFolderPropsStart
+    defaults.accountID = accountID;
+    defaults.targetType = "";
+    defaults.cached = false;
+    defaults.selected = false;
+    defaults.lastsynctime = 0;
+    defaults.status = "";
+    defaults.foldername = "";
+    defaults.downloadonly = false;
+    // DefaultFolderPropsEnd
+    
+    return defaults;
+  },
+}
diff --git a/content/modules/public.js b/content/modules/public.js
new file mode 100644
index 0000000..afd4f03
--- /dev/null
+++ b/content/modules/public.js
@@ -0,0 +1,757 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+/**
+ *
+ */
+ var StatusData = class {
+  /**
+   * A StatusData instance must be used as return value by 
+   * :class:`Base.syncFolderList` and :class:`Base.syncFolder`.
+   * 
+   * StatusData also defines the possible StatusDataTypes used by the
+   * :ref:`TbSyncEventLog`.
+   *
+   * @param {StatusDataType} type  Status type (see const definitions below)
+   * @param {string} message  ``Optional`` A message, which will be used as
+   *                          sync status. If this is not a success, it will be
+   *                          used also in the :ref:`TbSyncEventLog` as well.
+   * @param {string} details  ``Optional``  If this is not a success, it will
+   *                          be used as description in the
+   *                          :ref:`TbSyncEventLog`.
+   *
+   */
+  constructor(type = "success", message = "", details = "") {
+    this.type = type; //success, info, warning, error
+    this.message = message;
+    this.details = details;
+  }
+  /**
+   * Successfull sync. 
+   */
+  static get SUCCESS() {return "success"};
+  /**
+   * Sync of the entire account will be aborted.
+   */
+  static get ERROR() {return "error"};
+  /**
+   * Sync of this resource will be aborted and continued with next resource.
+   */
+  static get WARNING() {return "warning"};
+  /**
+   * Successfull sync, but message and details
+   * provided will be added to the event log.
+   */
+  static get INFO() {return "info"};
+  /**
+   * Sync of the entire account will be aborted and restarted completely.
+   */
+  static get ACCOUNT_RERUN() {return "account_rerun"}; 
+  /**
+   * Sync of the current folder/resource will be restarted.
+   */
+  static get FOLDER_RERUN() {return "folder_rerun"}; 
+}
+
+
+
+/**
+ * ProgressData to manage a ``done`` and a ``todo`` counter. 
+ *
+ * Each :class:`SyncData` instance has an associated ProgressData instance. See
+ * :class:`SyncData.progressData`. The information of that ProgressData
+ * instance is used, when the current syncstate is prefixed by ``send.``,
+ * ``eval.`` or ``prepare.``. See :class:`SyncData.setSyncState`.
+ *
+ */
+var ProgressData = class {
+  /**
+   *
+   */
+  constructor() {
+    this._todo = 0;
+    this._done = 0;
+   }
+   
+  /**
+   * Reset ``done`` and ``todo`` counter.
+   *
+   * @param {integer} done  ``Optional`` Set a value for the ``done`` counter.
+   * @param {integer} todo  ``Optional`` Set a value for the ``todo`` counter.
+   *
+   */
+   reset(done = 0, todo = 0) {
+    this._todo = todo;
+    this._done = done;
+   }
+   
+  /**
+   * Increment the ``done`` counter.
+   *
+   * @param {integer} value  ``Optional`` Set incrementation value.
+   *
+   */
+   inc(value = 1) {
+     this._done += value;
+   }
+   
+  /**
+   * Getter for the ``todo`` counter.
+   *
+   */
+   get todo() {
+     return this._todo;
+   }
+   
+  /**
+   * Getter for the ``done`` counter.
+   *
+   */
+   get done() {
+     return this._done;
+   }
+}
+
+
+
+/**
+ * ProviderData
+ *
+ */
+var ProviderData = class {
+  /**
+   * Constructor
+   *
+   * @param {FolderData} folderData    FolderData of the folder for which the
+   *                                   display name is requested.
+   *
+   */
+  constructor(provider) {
+    if (!TbSync.providers.hasOwnProperty(provider)) {
+      throw new Error("Provider <" + provider + "> has not been loaded. Failed to create ProviderData.");
+    }
+    this.provider = provider;
+  }
+  
+  /**
+   * Getter for an :class:`EventLogInfo` instance with all the information
+   * regarding this ProviderData instance.
+   *
+   */
+  get eventLogInfo() {
+    return new EventLogInfo(
+      this.getAccountProperty("provider"));
+  }
+
+  getVersion() {
+    return TbSync.providers.loadedProviders[this.provider].version;
+  }
+  
+  get extension() {
+    return TbSync.providers.loadedProviders[this.provider].extension;
+  }
+  
+  getAllAccounts() {
+    let accounts = TbSync.db.getAccounts();
+    let allAccounts = [];
+    for (let i=0; i<accounts.IDs.length; i++) {
+      let accountID = accounts.IDs[i];
+      if (accounts.data[accountID].provider == this.provider) {
+        allAccounts.push(new TbSync.AccountData(accountID));
+      }
+    }
+    return allAccounts;
+  }
+  
+  getFolders(aFolderSearchCriteria = {}) {
+    let allFolders = [];
+    let folderSearchCriteria = {};
+    Object.assign(folderSearchCriteria, aFolderSearchCriteria);
+    folderSearchCriteria.cached = false;
+    
+    let folders = TbSync.db.findFolders(folderSearchCriteria, {"provider": this.provider});
+    for (let i=0; i < folders.length; i++) {          
+      allFolders.push(new TbSync.FolderData(new TbSync.AccountData(folders[i].accountID), folders[i].folderID));
+    }
+    return allFolders;
+  }
+  
+  getDefaultAccountEntries() {
+    return  TbSync.providers.getDefaultAccountEntries(this.provider)
+  }
+  
+  addAccount(accountName, accountOptions) {
+    let newAccountID = TbSync.db.addAccount(accountName, accountOptions);
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.updateAccountsList", newAccountID);
+    return new TbSync.AccountData(newAccountID);        
+  }
+}
+
+
+
+/**
+ * AccountData
+ *
+ */
+var AccountData = class {
+  /**
+   *
+   */
+  constructor(accountID) {
+    this._accountID = accountID;
+
+    if (!TbSync.db.accounts.data.hasOwnProperty(accountID)) {
+      throw new Error("An account with ID <" + accountID + "> does not exist. Failed to create AccountData.");
+    }
+  }
+
+  /**
+   * Getter for an :class:`EventLogInfo` instance with all the information
+   * regarding this AccountData instance.
+   *
+   */
+  get eventLogInfo() {
+    return new EventLogInfo(
+      this.getAccountProperty("provider"),
+      this.getAccountProperty("accountname"),
+      this.accountID);
+  }
+
+  get accountID() {
+    return this._accountID;
+  }
+  
+  getAllFolders() {
+    let allFolders = [];
+    let folders = TbSync.db.findFolders({"cached": false}, {"accountID": this.accountID});
+    for (let i=0; i < folders.length; i++) {          
+      allFolders.push(new TbSync.FolderData(this, folders[i].folderID));
+    }
+    return allFolders;
+  }
+
+  getAllFoldersIncludingCache() {
+    let allFolders = [];
+    let folders = TbSync.db.findFolders({}, {"accountID": this.accountID});
+    for (let i=0; i < folders.length; i++) {          
+      allFolders.push(new TbSync.FolderData(this, folders[i].folderID));
+    }
+    return allFolders;
+  }
+  
+  getFolder(setting, value) {
+    // ES6 supports variable keys by putting it into brackets
+    let folders = TbSync.db.findFolders({[setting]: value, "cached": false}, {"accountID": this.accountID});
+    if (folders.length > 0) return new TbSync.FolderData(this, folders[0].folderID);
+    return null;
+  }
+
+  getFolderFromCache(setting, value) {
+    // ES6 supports variable keys by putting it into brackets
+    let folders = TbSync.db.findFolders({[setting]: value, "cached": true}, {"accountID": this.accountID});
+    if (folders.length > 0) return new TbSync.FolderData(this, folders[0].folderID);
+    return null;
+  }
+  
+  createNewFolder() {
+    return new TbSync.FolderData(this, TbSync.db.addFolder(this.accountID));
+  }
+  
+  // get data objects
+  get providerData() {
+    return new TbSync.ProviderData(
+      this.getAccountProperty("provider"),
+    );
+  }    
+
+  get syncData() {
+    return TbSync.core.getSyncDataObject(this.accountID);
+  }
+
+
+  /**
+   * Initiate a sync of this entire account by calling
+   * :class:`Base.syncFolderList`. If that succeeded, :class:`Base.syncFolder`
+   * will be called for each available folder / resource found on the server.
+   *
+   * @param {Object} syncDescription  ``Optional``
+   */
+  sync(syncDescription = {}) {
+    TbSync.core.syncAccount(this.accountID, syncDescription);
+  }
+
+  isSyncing() {
+    return TbSync.core.isSyncing(this.accountID);
+  }
+  
+  isEnabled() {
+    return TbSync.core.isEnabled(this.accountID);
+  }
+
+  isConnected() {
+    return TbSync.core.isConnected(this.accountID);
+  }
+  
+
+  getAccountProperty(field) {
+    return TbSync.db.getAccountProperty(this.accountID, field);
+  }
+
+  setAccountProperty(field, value) {
+    TbSync.db.setAccountProperty(this.accountID, field, value);
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.reloadAccountSetting", JSON.stringify({accountID: this.accountID, setting: field}));
+  }
+  
+  resetAccountProperty(field) {
+    TbSync.db.resetAccountProperty(this.accountID, field);
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.reloadAccountSetting", JSON.stringify({accountID: this.accountID, setting: field}));
+  }
+}
+
+
+
+/**
+ * FolderData
+ *
+ */
+var FolderData = class {
+  /**
+   *
+   */
+  constructor(accountData, folderID) {
+    this._accountData = accountData;
+    this._folderID = folderID;
+    this._target = null;
+    
+    if (!TbSync.db.folders[accountData.accountID].hasOwnProperty(folderID)) {
+      throw new Error("A folder with ID <" + folderID + "> does not exist for the given account. Failed to create FolderData.");
+    }
+  }
+  
+  /**
+   * Getter for an :class:`EventLogInfo` instance with all the information 
+   * regarding this FolderData instance.
+   *
+   */
+  get eventLogInfo() {
+    return new EventLogInfo(
+      this.accountData.getAccountProperty("provider"),
+      this.accountData.getAccountProperty("accountname"),
+      this.accountData.accountID,
+      this.getFolderProperty("foldername"),
+    );
+  }
+
+  get folderID() {
+    return this._folderID;
+  }
+
+  get accountID() {
+    return this._accountData.accountID;
+  }
+  
+  getDefaultFolderEntries() { // remove
+    return TbSync.providers.getDefaultFolderEntries(this.accountID);
+  }
+  
+  getFolderProperty(field) {
+    return TbSync.db.getFolderProperty(this.accountID, this.folderID, field);
+  }
+  
+  setFolderProperty(field, value) {
+    TbSync.db.setFolderProperty(this.accountID, this.folderID, field, value);
+  }
+
+  resetFolderProperty(field) {
+    TbSync.db.resetFolderProperty(this.accountID, this.folderID, field);
+  }
+
+  /**
+   * Initiate a sync of this folder only by calling
+   * :class:`Base.syncFolderList` and than :class:`Base.syncFolder` for this
+   * folder / resource only.
+   *
+   * @param {Object} syncDescription  ``Optional``
+   */
+  sync(aSyncDescription = {}) {
+    let syncDescription = {};
+    Object.assign(syncDescription, aSyncDescription);
+
+    syncDescription.syncFolders = [this];
+    this.accountData.sync(syncDescription);
+  }
+  
+  isSyncing() {
+    let syncdata = this.accountData.syncData;
+    return (syncdata.currentFolderData && syncdata.currentFolderData.folderID == this.folderID);
+  }
+    
+  getFolderStatus() {
+    let status = "";
+    
+    if (this.getFolderProperty("selected")) {
+      //default
+      status = TbSync.getString("status." + this.getFolderProperty("status"), this.accountData.getAccountProperty("provider")).split("||")[0];
+
+      switch (this.getFolderProperty("status").split(".")[0]) { //the status may have a sub-decleration
+        case "modified":
+          //trigger periodic sync (TbSync.syncTimer, tbsync.jsm)
+          if (!this.isSyncing()) {
+            this.accountData.setAccountProperty("lastsynctime", 0);
+          }
+        case "success":
+          try {
+            status = status + ": " + this.targetData.targetName;
+          } catch (e) {
+            this.resetFolderProperty("target");
+            this.setFolderProperty("status","notsyncronized");
+            return TbSync.getString("status.notsyncronized");
+          }
+          break;
+          
+        case "pending":
+          //add extra info if this folder is beeing synced
+          if (this.isSyncing()) {
+            let syncdata = this.accountData.syncData;
+            status = TbSync.getString("status.syncing", this.accountData.getAccountProperty("provider"));
+            if (["send","eval","prepare"].includes(syncdata.getSyncState().state.split(".")[0]) && (syncdata.progressData.todo + syncdata.progressData.done) > 0) {
+              //add progress information
+              status = status + " (" + syncdata.progressData.done + (syncdata.progressData.todo > 0 ? "/" + syncdata.progressData.todo : "") + ")"; 
+            }
+          }
+          break;            
+      }
+    } else {
+      //remain empty if not selected
+    }        
+    return status;
+  }
+  
+  // get data objects
+  get accountData() {
+    return this._accountData;
+  }
+
+  /**
+   * Getter for the :class:`TargetData` instance associated with this
+   * FolderData. See :ref:`TbSyncTargets` for more details.
+   *
+   * @returns {TargetData}
+   *
+   */
+  get targetData() {
+    // targetData is created on demand
+    if (!this._target) {
+      let provider = this.accountData.getAccountProperty("provider");
+      let targetType = this.getFolderProperty("targetType");
+      
+      if (!targetType)
+        throw new Error("Provider <"+provider+"> has not set a proper target type for this folder.");
+      
+      if (!TbSync.providers[provider].hasOwnProperty("TargetData_" + targetType))
+        throw new Error("Provider <"+provider+"> is missing a TargetData implementation for <"+targetType+">.");
+      
+      this._target = new TbSync.providers[provider]["TargetData_" + targetType](this);
+      
+      if (!this._target)
+        throw new Error("notargets");
+    }
+    
+    return this._target;
+  }
+  
+  // Removes the folder and its target. If the target should be 
+  // kept  as a stale/unconnected item, provide a suffix, which
+  // will be added to its name, to indicate, that it is no longer
+  // managed by TbSync.
+  remove(keepStaleTargetSuffix = "") {
+    // hasTarget() can throw an error, ignore that here
+    try {
+      if (this.targetData.hasTarget()) {
+        if (keepStaleTargetSuffix) {
+          let oldName =  this.targetData.targetName;
+          this.targetData.targetName = TbSync.getString("target.orphaned") + ": " + oldName + " " + keepStaleTargetSuffix;
+          this.targetData.disconnectTarget();
+        } else {
+          this.targetData.removeTarget();
+        }
+      }
+    } catch (e) {
+        Components.utils.reportError(e);
+    }
+    this.setFolderProperty("cached", true);
+  }
+}
+
+
+
+/**
+ * There is only one SyncData instance per account which contains all
+ * relevant information regarding an ongoing sync. 
+ *
+ */
+var SyncData = class {
+  /**
+   *
+   */
+  constructor(accountID) {
+    
+    //internal (private, not to be touched by provider)
+    this._syncstate = {
+      state: "accountdone",
+      timestamp: Date.now(),
+    }
+    this._accountData = new TbSync.AccountData(accountID);
+    this._progressData = new TbSync.ProgressData();
+    this._currentFolderData = null;
+  }
+
+  //all functions provider should use should be in here
+  //providers should not modify properties directly
+  //when getSyncDataObj is used never change the folder id as a sync may be going on!
+
+  _setCurrentFolderData(folderData) {
+    this._currentFolderData = folderData;
+  }
+  _clearCurrentFolderData() {
+    this._currentFolderData = null;
+  }
+
+  /**
+   * Getter for an :class:`EventLogInfo` instance with all the information
+   * regarding this SyncData instance.
+   *
+   */  
+  get eventLogInfo() {
+    return new EventLogInfo(
+      this.accountData.getAccountProperty("provider"),
+      this.accountData.getAccountProperty("accountname"),
+      this.accountData.accountID,
+      this.currentFolderData ? this.currentFolderData.getFolderProperty("foldername") : "",
+    );
+  }
+  
+  /**
+   * Getter for the :class:`FolderData` instance of the folder being currently
+   * synced. Can be ``null`` if no folder is being synced.
+   *
+   */  
+  get currentFolderData() {
+    return this._currentFolderData;
+  }
+
+  /**
+   * Getter for the :class:`AccountData` instance of the account being
+   * currently synced.
+   *
+   */  
+  get accountData() {
+    return this._accountData;
+  }
+
+  /**
+   * Getter for the :class:`ProgressData` instance of the ongoing sync.
+   *
+   */
+  get progressData() {
+    return this._progressData;
+  }
+
+  /**
+   * Sets the syncstate of the ongoing sync, to provide feedback to the user.
+   * The selected state can trigger special UI features, if it starts with one
+   * of the following prefixes:
+   *
+   *   * ``send.``, ``eval.``, ``prepare.`` :
+   *     The status message in the UI will be appended with the current progress
+   *     stored in the :class:`ProgressData` associated with this SyncData
+   *     instance. See :class:`SyncData.progressData`. 
+   * 
+   *   * ``send.`` : 
+   *     The status message in the UI will be appended by a timeout countdown
+   *     with the timeout being defined by :class:`Base.getConnectionTimeout`.
+   *
+   * @param {string} state      A short syncstate identifier. The actual
+   *                            message to be displayed in the UI will be
+   *                            looked up in the locales of the provider
+   *                            by looking for ``syncstate.<state>``. 
+   *                            The lookup is done via :func:`getString`,
+   *                            so the same fallback rules apply. 
+   *
+   */  
+  setSyncState(state) {
+    //set new syncstate
+    let msg = "State: " + state + ", Account: " + this.accountData.getAccountProperty("accountname");
+    if (this.currentFolderData) msg += ", Folder: " + this.currentFolderData.getFolderProperty("foldername");
+
+    let syncstate = {};
+    syncstate.state = state;
+    syncstate.timestamp = Date.now();
+
+    this._syncstate = syncstate;
+    TbSync.dump("setSyncState", msg);
+
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", this.accountData.accountID);
+  }
+  
+  /**
+   * Gets the current syncstate and its timestamp of the ongoing sync. The
+   * returned Object has the following attributes:
+   *
+   *   * ``state`` : the current syncstate
+   *   * ``timestamp`` : its timestamp
+   *
+   * @returns {Object}  The syncstate and its timestamp.
+   *
+   */
+  getSyncState() {
+    return this._syncstate;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+// Simple dumper, who can dump to file or console
+// It is suggested to use the event log instead of dumping directly.
+var dump = function (what, aMessage) {
+  if (TbSync.prefs.getBoolPref("log.toconsole")) {
+    Services.console.logStringMessage("[TbSync] " + what + " : " + aMessage);
+  }
+  
+  if (TbSync.prefs.getIntPref("log.userdatalevel") > 0) {
+    let now = new Date();
+    TbSync.io.appendToFile("debug.log", "** " + now.toString() + " **\n[" + what + "] : " + aMessage + "\n\n");
+  }
+}
+  
+
+
+/**
+ * Get a localized string.
+ *
+ * TODO: Explain placeholder and :: notation.
+ *
+ * @param {string} key       The key of the message to look up
+ * @param {string} provider  ``Optional`` The provider the key belongs to.
+ *
+ * @returns {string} The message belonging to the key of the specified provider.
+ *                   If that key is not found in the in the specified provider
+ *                   or if no provider has been specified, the messages of
+ *                   TbSync itself we be used as fallback. If the key could not
+ *                   be found there as well, the key itself is returned.
+ *
+ */
+var getString = function (key, provider) {
+  let localized = null;
+  
+  //spezial treatment of strings with :: like status.httperror::403
+  let parts = key.split("::");
+
+  // if a provider is given, try to get the string from the provider  
+  if (provider && TbSync.providers.loadedProviders.hasOwnProperty(provider)) {
+    let localeData = TbSync.providers.loadedProviders[provider].extension.localeData;
+    if (localeData.messages.get(localeData.selectedLocale).has(parts[0].toLowerCase())) {
+      localized = TbSync.providers.loadedProviders[provider].extension.localeData.localizeMessage(parts[0]);
+    }
+  }
+
+  // if we did not yet succeed, check the locales of tbsync itself
+  if (!localized) {
+    localized = TbSync.extension.localeData.localizeMessage(parts[0]);
+  }
+  
+  if (!localized) {
+    localized = key;
+  } else {
+    //replace placeholders in returned string
+    for (let i = 0; i<parts.length; i++) {
+      let regex = new RegExp( "##replace\."+i+"##", "g");
+      localized = localized.replace(regex, parts[i]);
+    }
+  }
+
+  return localized;
+}
+
+
+var localizeNow = function (window, provider) {
+  let document = window.document;
+  let keyPrefix = "__" + (provider ? provider.toUpperCase() + "4" : "") + "TBSYNCMSG_";
+  
+  let localization = {
+    i18n: null,
+    
+    updateString(string) {
+      let re = new RegExp(keyPrefix + "(.+?)__", "g");
+      return string.replace(re, matched => {
+        const key = matched.slice(keyPrefix.length, -2);
+        return TbSync.getString(key, provider) || matched;
+      });
+    },
+    
+    updateDocument(node) {
+      const texts = document.evaluate(
+        'descendant::text()[contains(self::text(), "' + keyPrefix + '")]',
+        node,
+        null,
+        XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
+        null
+      );
+      for (let i = 0, maxi = texts.snapshotLength; i < maxi; i++) {
+        const text = texts.snapshotItem(i);
+        if (text.nodeValue.includes(keyPrefix)) text.nodeValue = this.updateString(text.nodeValue);
+      }
+      
+      const attributes = document.evaluate(
+        'descendant::*/attribute::*[contains(., "' + keyPrefix + '")]',
+        node,
+        null,
+        XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
+        null
+      );
+      for (let i = 0, maxi = attributes.snapshotLength; i < maxi; i++) {
+        const attribute = attributes.snapshotItem(i);
+        if (attribute.value.includes(keyPrefix)) attribute.value = this.updateString(attribute.value);
+      }
+    }		
+  };
+
+  localization.updateDocument(document);
+}
+
+var localizeOnLoad = function (window, provider) {
+  // standard event if loaded by a standard window
+  window.document.addEventListener('DOMContentLoaded', () => {
+    this.localizeNow(window, provider);
+  }, { once: true });
+
+  // custom event, fired by the overlay loader after it has finished loading
+    // the editAccount dialog is never called as a provider, but from tbsync itself
+  let eventId = "DOMOverlayLoaded_"
+      + (!provider || window.location.href.startsWith("chrome://tbsync/content/manager/editAccount.") ? "" : provider + "4")
+      + "tbsync@jobisoft.de";
+  window.document.addEventListener(eventId, () => {
+    TbSync.localizeNow(window, provider);
+  }, { once: true });
+}
+
+
+
+var generateUUID = function () {
+  const uuidGenerator  = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator);
+  return uuidGenerator.generateUUID().toString().replace(/[{}]/g, '');
+}
diff --git a/content/modules/tools.js b/content/modules/tools.js
new file mode 100644
index 0000000..fe406b9
--- /dev/null
+++ b/content/modules/tools.js
@@ -0,0 +1,80 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+ 
+var tools = {
+
+  load: async function () {
+  },
+
+  unload: async function () {
+  },
+
+  // async sleep function using Promise to postpone actions to keep UI responsive
+  sleep : function (_delay, useRequestIdleCallback = false) {
+    let useIdleCallback = false;
+    let delay = 5;//_delay;
+    if (TbSync.window.requestIdleCallback && useRequestIdleCallback) {
+      useIdleCallback = true;
+      delay= 2;
+    }
+    let timer =  Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer);
+    
+    return new Promise(function(resolve, reject) {
+      let event = {
+        notify: function(timer) {
+          if (useIdleCallback) {
+            TbSync.window.requestIdleCallback(resolve);                        
+          } else {
+            resolve();
+          }
+        }
+      }            
+      timer.initWithCallback(event, delay, Components.interfaces.nsITimer.TYPE_ONE_SHOT);
+    });
+  },
+
+  // this is derived from: http://jonisalonen.com/2012/from-utf-16-to-utf-8-in-javascript/
+  // javascript strings are utf16, btoa needs utf8 , so we need to encode
+  toUTF8: function (str) {
+    var utf8 = "";
+    for (var i=0; i < str.length; i++) {
+      var charcode = str.charCodeAt(i);
+      if (charcode < 0x80) utf8 += String.fromCharCode(charcode);
+      else if (charcode < 0x800) {
+        utf8 += String.fromCharCode(0xc0 | (charcode >> 6), 
+              0x80 | (charcode & 0x3f));
+      }
+      else if (charcode < 0xd800 || charcode >= 0xe000) {
+        utf8 += String.fromCharCode(0xe0 | (charcode >> 12), 
+              0x80 | ((charcode>>6) & 0x3f), 
+              0x80 | (charcode & 0x3f));
+      }
+
+      // surrogate pair
+      else {
+        i++;
+        // UTF-16 encodes 0x10000-0x10FFFF by
+        // subtracting 0x10000 and splitting the
+        // 20 bits of 0x0-0xFFFFF into two halves
+        charcode = 0x10000 + (((charcode & 0x3ff)<<10)
+              | (str.charCodeAt(i) & 0x3ff))
+        utf8 += String.fromCharCode(0xf0 | (charcode >>18), 
+              0x80 | ((charcode>>12) & 0x3f), 
+              0x80 | ((charcode>>6) & 0x3f), 
+              0x80 | (charcode & 0x3f));
+      }
+    }
+    return utf8;
+  },
+  
+  b64encode: function (str) {
+    return btoa(this.toUTF8(str));
+  }
+}
diff --git a/content/overlays/messenger.js b/content/overlays/messenger.js
new file mode 100644
index 0000000..b6d0a97
--- /dev/null
+++ b/content/overlays/messenger.js
@@ -0,0 +1,22 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+var tbSyncMessenger = {
+
+  onInject: function (window) {
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", null);
+  },
+
+  onRemove: function (window) {
+  },
+
+};
diff --git a/content/overlays/messenger.xhtml b/content/overlays/messenger.xhtml
new file mode 100644
index 0000000..37d07ca
--- /dev/null
+++ b/content/overlays/messenger.xhtml
@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+
+<overlay 
+    id="TbSyncMessengerOverlay"
+    omscope="tbSyncMessenger"
+    xmlns:html="http://www.w3.org/1999/xhtml">
+
+    <script type="application/javascript" src="chrome://tbsync/content/overlays/messenger.js" />
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+
+    <menupopup id="tbsync.statusmenu">
+        <menuitem label="__TBSYNCMSG_popup.opensettings__" oncommand="TbSync.manager.openManagerWindow(event);" />
+    </menupopup>
+    
+    <label  id="tbsync.status" class="statusbarpanel" value="TbSync" onclick="TbSync.manager.openManagerWindow(event);" appendto="status-bar"/>
+
+    <!--menuitem id="tbsync.taskPopupEntry" label="__TBSYNCMSG_menu.settingslabel__" appendto="taskPopup" onclick="TbSync.manager.openManagerWindow(event);" / -->
+    <menuitem id="tbsync.accountmgrEntry" label="__TBSYNCMSG_menu.settingslabel__" insertbefore="menu_accountmgr" oncommand="TbSync.manager.openManagerWindow(event);" />
+
+</overlay>        
diff --git a/content/passwordPrompt/passwordPrompt.css b/content/passwordPrompt/passwordPrompt.css
new file mode 100644
index 0000000..4527ac3
--- /dev/null
+++ b/content/passwordPrompt/passwordPrompt.css
@@ -0,0 +1,13 @@
+  .grid-container {
+    display: grid;
+    grid-template-columns: auto 1fr;
+    grid-template-rows: auto auto auto;
+    gap: 1px;
+    width: 250px;
+    margin: 2ex auto;
+  }
+
+  .grid-item {
+    padding: 2px;
+    text-align: left;
+  }
diff --git a/content/passwordPrompt/passwordPrompt.js b/content/passwordPrompt/passwordPrompt.js
new file mode 100644
index 0000000..8af40d9
--- /dev/null
+++ b/content/passwordPrompt/passwordPrompt.js
@@ -0,0 +1,47 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var tbSyncPassword = {
+  
+  onload: function () {
+    let data = window.arguments[0];
+    this.resolve = window.arguments[1];
+    this.resolved = false;
+
+    this.namefield =  document.getElementById("tbsync.account");
+    this.passfield = document.getElementById("tbsync.password");
+    this.userfield = document.getElementById("tbsync.user");
+
+    this.namefield.value = data.accountname;
+    this.userfield.value = data.username;
+    this.userfield.disabled = data.usernameLocked;
+
+    window.addEventListener("unload", tbSyncPassword.doCANCEL.bind(this));
+    document.getElementById("tbsync.password").focus();
+    document.getElementById("tbsync.password.ok").addEventListener("click", tbSyncPassword.doOK.bind(this));
+    document.getElementById("tbsync.password.cancel").addEventListener("click", () => window.close());
+  },
+
+  doOK: function (event) {
+    if (!this.resolved) {
+      this.resolved = true
+      this.resolve({username: this.userfield.value, password: this.passfield.value});
+      window.close();
+    }
+  },
+  
+  doCANCEL: function (event) {
+    if (!this.resolved) {
+      this.resolved = true
+      this.resolve(false);
+    }
+  },
+  
+};
diff --git a/content/passwordPrompt/passwordPrompt.xhtml b/content/passwordPrompt/passwordPrompt.xhtml
new file mode 100644
index 0000000..fc554b5
--- /dev/null
+++ b/content/passwordPrompt/passwordPrompt.xhtml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://tbsync/content/passwordPrompt/passwordPrompt.css" type="text/css"?>
+
+<window
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+    xmlns:html="http://www.w3.org/1999/xhtml"
+    title="__TBSYNCMSG_password.title__"
+    onload="tbSyncPassword.onload();">
+
+    <script type="application/javascript" src="chrome://tbsync/content/passwordPrompt/passwordPrompt.js"/>
+    <script type="text/javascript" src="chrome://tbsync/content/scripts/locales.js" /> 
+
+    <vbox flex="1">
+        <description style="padding: 5px; width: 350px;">__TBSYNCMSG_password.description__</description>
+
+        <html:div class="grid-container">
+            <html:div class="grid-item"><label value="__TBSYNCMSG_password.account__"/></html:div>
+            <html:div class="grid-item"><label class="header"  id="tbsync.account" /></html:div>
+            <html:div class="grid-item"><label value="__TBSYNCMSG_password.user__"/></html:div>
+            <html:div class="grid-item"><html:input id="tbsync.user" /></html:div>
+            <html:div class="grid-item"><label value="__TBSYNCMSG_password.password__"/></html:div>
+            <html:div class="grid-item"><html:input type="password" id="tbsync.password"/></html:div>
+        </html:div>
+        <hbox style="padding: 5px">
+            <vbox flex="1"></vbox>
+            <button id="tbsync.password.ok" label="__TBSYNCMSG_password.ok__" />
+            <button id="tbsync.password.cancel" label="__TBSYNCMSG_password.cancel__" />
+        </hbox>
+    </vbox>
+
+</window>
diff --git a/content/scripts/bootstrap.js b/content/scripts/bootstrap.js
new file mode 100644
index 0000000..706946f
--- /dev/null
+++ b/content/scripts/bootstrap.js
@@ -0,0 +1,89 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+function startup(data, reason) {
+  // possible reasons: APP_STARTUP, ADDON_ENABLE, ADDON_INSTALL, ADDON_UPGRADE, or ADDON_DOWNGRADE.
+
+  // set default prefs
+  let defaults = Services.prefs.getDefaultBranch("extensions.tbsync.");
+  defaults.setBoolPref("debug.testoptions", false);
+  defaults.setBoolPref("log.toconsole", false);
+  defaults.setIntPref("log.userdatalevel", 0); //0 - off   1 - userdata only on errors   2 - including full userdata,  3 - extra infos
+
+  // Check if at least one main window has finished loading
+  let windows = Services.wm.getEnumerator("mail:3pane");
+  if (windows.hasMoreElements()) {
+    let domWindow = windows.getNext();
+    WindowListener.loadIntoWindow(domWindow);
+  }
+
+  // Wait for any new windows to open.
+  Services.wm.addListener(WindowListener);
+  
+  //DO NOT ADD ANYTHING HERE!
+}
+
+function shutdown(data, reason) {
+  //possible reasons: APP_SHUTDOWN, ADDON_DISABLE, ADDON_UNINSTALL, ADDON_UPGRADE, or ADDON_DOWNGRADE
+
+  // Stop listening for any new windows to open.
+  Services.wm.removeListener(WindowListener);
+
+  var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+  TbSync.enabled = false;
+  TbSync.unload().then(function() {
+    Cu.unload("chrome://tbsync/content/tbsync.jsm");
+    Cu.unload("chrome://tbsync/content/HttpRequest.jsm");
+    Cu.unload("chrome://tbsync/content/OverlayManager.jsm");
+    // HACK WARNING:
+    //  - the Addon Manager does not properly clear all addon related caches on update;
+    //  - in order to fully update images and locales, their caches need clearing here
+    Services.obs.notifyObservers(null, "startupcache-invalidate");
+    Services.obs.notifyObservers(null, "chrome-flush-caches"); 
+  });
+}
+
+
+var WindowListener = {
+
+  async loadIntoWindow(window) {
+    if (window.document.readyState != "complete") {
+      // Make sure the window load has completed.
+      await new Promise(resolve => {
+        window.addEventListener("load", resolve, { once: true });
+      });
+    }
+
+    // Check if the opened window is the one we want to modify.
+    if (window.document.documentElement.getAttribute("windowtype") === "mail:3pane") {
+      // the main window has loaded, continue with init
+      var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+      if (!TbSync.enabled) TbSync.load(window, addon, extension);
+    }
+  },
+
+
+  unloadFromWindow(window) {
+  },
+
+  // nsIWindowMediatorListener functions
+  onOpenWindow(xulWindow) {
+    // A new window has opened.
+    let domWindow = xulWindow.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindow);
+    // The domWindow.document.documentElement.getAttribute("windowtype") is not set before the load, so we cannot check it here
+    this.loadIntoWindow(domWindow);
+  },
+
+  onCloseWindow(xulWindow) {
+  },
+
+  onWindowTitleChange(xulWindow, newTitle) {
+  },
+};
diff --git a/content/scripts/locales.js b/content/scripts/locales.js
new file mode 100644
index 0000000..806c4f2
--- /dev/null
+++ b/content/scripts/locales.js
@@ -0,0 +1,3 @@
+var { TbSync } = ChromeUtils.import("chrome://tbsync/content/tbsync.jsm");
+
+TbSync.localizeOnLoad(window);
diff --git a/content/skin/ab.css b/content/skin/ab.css
new file mode 100644
index 0000000..5c8169b
--- /dev/null
+++ b/content/skin/ab.css
@@ -0,0 +1,8 @@
+treechildren::-moz-tree-image(DirCol, orphaned) {
+  margin-inline-end: 2px;
+  list-style-image: url("chrome://tbsync/content/skin/error16.png");
+}
+
+.abMenuItem[AddrBook="true"][TbSyncIcon="orphaned"] {
+  list-style-image: url("chrome://tbsync/content/skin/error16.png");
+}
diff --git a/content/skin/acl_ro.png b/content/skin/acl_ro.png
new file mode 100644
index 0000000..ee806fc
--- /dev/null
+++ b/content/skin/acl_ro.png
diff --git a/content/skin/acl_ro2.png b/content/skin/acl_ro2.png
new file mode 100644
index 0000000..f3f1de9
--- /dev/null
+++ b/content/skin/acl_ro2.png
diff --git a/content/skin/acl_rw.png b/content/skin/acl_rw.png
new file mode 100644
index 0000000..109fb45
--- /dev/null
+++ b/content/skin/acl_rw.png
diff --git a/content/skin/acl_rw2.png b/content/skin/acl_rw2.png
new file mode 100644
index 0000000..1b799fd
--- /dev/null
+++ b/content/skin/acl_rw2.png
diff --git a/content/skin/add16.png b/content/skin/add16.png
new file mode 100644
index 0000000..b366b96
--- /dev/null
+++ b/content/skin/add16.png
diff --git a/content/skin/browserOverlay.css b/content/skin/browserOverlay.css
new file mode 100644
index 0000000..3c09214
--- /dev/null
+++ b/content/skin/browserOverlay.css
@@ -0,0 +1,10 @@
+/*  skin/toolbar-button.css  */
+
+#tbsync-toolbarbutton {
+  list-style-image: url("chrome://tbsync/content/skin/sync.png");
+}
+
+toolbar[iconsize="small"] #tbsync-toolbarbutton {
+  list-style-image: url("chrome://tbsync/content/skin/syncsmall.png");
+}
+
diff --git a/content/skin/calendar16.png b/content/skin/calendar16.png
new file mode 100644
index 0000000..2f7f575
--- /dev/null
+++ b/content/skin/calendar16.png
diff --git a/content/skin/calendar16_shared.png b/content/skin/calendar16_shared.png
new file mode 100644
index 0000000..c496c40
--- /dev/null
+++ b/content/skin/calendar16_shared.png
diff --git a/content/skin/catman32.png b/content/skin/catman32.png
new file mode 100644
index 0000000..f87b71e
--- /dev/null
+++ b/content/skin/catman32.png
diff --git a/content/skin/connect16.png b/content/skin/connect16.png
new file mode 100644
index 0000000..7af930e
--- /dev/null
+++ b/content/skin/connect16.png
diff --git a/content/skin/contacts16.png b/content/skin/contacts16.png
new file mode 100644
index 0000000..101a9d3
--- /dev/null
+++ b/content/skin/contacts16.png
diff --git a/content/skin/contacts16_shared.png b/content/skin/contacts16_shared.png
new file mode 100644
index 0000000..4a5d049
--- /dev/null
+++ b/content/skin/contacts16_shared.png
diff --git a/content/skin/del16.png b/content/skin/del16.png
new file mode 100644
index 0000000..8db349f
--- /dev/null
+++ b/content/skin/del16.png
diff --git a/content/skin/disabled16.png b/content/skin/disabled16.png
new file mode 100644
index 0000000..ee10cd0
--- /dev/null
+++ b/content/skin/disabled16.png
diff --git a/content/skin/eas16.png b/content/skin/eas16.png
new file mode 100644
index 0000000..072d5f0
--- /dev/null
+++ b/content/skin/eas16.png
diff --git a/content/skin/error16.png b/content/skin/error16.png
new file mode 100644
index 0000000..5177258
--- /dev/null
+++ b/content/skin/error16.png
diff --git a/content/skin/fix_dropdown_1534697.css b/content/skin/fix_dropdown_1534697.css
new file mode 100644
index 0000000..c5e7606
--- /dev/null
+++ b/content/skin/fix_dropdown_1534697.css
@@ -0,0 +1,4 @@
+button.plain .button-menu-dropmarker {
+  -moz-appearance: toolbarbutton-dropdown;
+  display: block;
+}
diff --git a/content/skin/group32.png b/content/skin/group32.png
new file mode 100644
index 0000000..a58f920
--- /dev/null
+++ b/content/skin/group32.png
diff --git a/content/skin/help32.png b/content/skin/help32.png
new file mode 100644
index 0000000..db2141a
--- /dev/null
+++ b/content/skin/help32.png
diff --git a/content/skin/info16.png b/content/skin/info16.png
new file mode 100644
index 0000000..eabaf75
--- /dev/null
+++ b/content/skin/info16.png
diff --git a/content/skin/lock24.png b/content/skin/lock24.png
new file mode 100644
index 0000000..d0e07ab
--- /dev/null
+++ b/content/skin/lock24.png
diff --git a/content/skin/provider16.png b/content/skin/provider16.png
new file mode 100644
index 0000000..d7ddcb8
--- /dev/null
+++ b/content/skin/provider16.png
diff --git a/content/skin/provider32.png b/content/skin/provider32.png
new file mode 100644
index 0000000..4a1d0a9
--- /dev/null
+++ b/content/skin/provider32.png
diff --git a/content/skin/report_open.png b/content/skin/report_open.png
new file mode 100644
index 0000000..5c0f4cb
--- /dev/null
+++ b/content/skin/report_open.png
diff --git a/content/skin/report_send.png b/content/skin/report_send.png
new file mode 100644
index 0000000..8dcc893
--- /dev/null
+++ b/content/skin/report_send.png
diff --git a/content/skin/settings32.png b/content/skin/settings32.png
new file mode 100644
index 0000000..9c6a889
--- /dev/null
+++ b/content/skin/settings32.png
diff --git a/content/skin/slider-off.png b/content/skin/slider-off.png
new file mode 100644
index 0000000..8243d81
--- /dev/null
+++ b/content/skin/slider-off.png
diff --git a/content/skin/slider-on.png b/content/skin/slider-on.png
new file mode 100644
index 0000000..c9dd28e
--- /dev/null
+++ b/content/skin/slider-on.png
diff --git a/content/skin/spinner.gif b/content/skin/spinner.gif
new file mode 100644
index 0000000..5b33f7e
--- /dev/null
+++ b/content/skin/spinner.gif
diff --git a/content/skin/src/LICENSE b/content/skin/src/LICENSE
new file mode 100644
index 0000000..f8ad367
--- /dev/null
+++ b/content/skin/src/LICENSE
@@ -0,0 +1,131 @@
+The following files are released into PUBLIC DOMAIN.
+
+slider.xcf
+slider-on.png
+slider-off.png
+
+The png files are based on the xcf file.
+
+
+
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.
\ No newline at end of file
diff --git a/content/skin/src/slider-off.png b/content/skin/src/slider-off.png
new file mode 100644
index 0000000..8243d81
--- /dev/null
+++ b/content/skin/src/slider-off.png
diff --git a/content/skin/src/slider-on.png b/content/skin/src/slider-on.png
new file mode 100644
index 0000000..c9dd28e
--- /dev/null
+++ b/content/skin/src/slider-on.png
diff --git a/content/skin/src/slider.xcf b/content/skin/src/slider.xcf
new file mode 100644
index 0000000..cca28cd
--- /dev/null
+++ b/content/skin/src/slider.xcf
diff --git a/content/skin/sync16.png b/content/skin/sync16.png
new file mode 100644
index 0000000..87e3ee7
--- /dev/null
+++ b/content/skin/sync16.png
diff --git a/content/skin/sync16_1.png b/content/skin/sync16_1.png
new file mode 100644
index 0000000..679d5d0
--- /dev/null
+++ b/content/skin/sync16_1.png
diff --git a/content/skin/sync16_2.png b/content/skin/sync16_2.png
new file mode 100644
index 0000000..49fe7c8
--- /dev/null
+++ b/content/skin/sync16_2.png
diff --git a/content/skin/sync16_3.png b/content/skin/sync16_3.png
new file mode 100644
index 0000000..87e3ee7
--- /dev/null
+++ b/content/skin/sync16_3.png
diff --git a/content/skin/sync16_4.png b/content/skin/sync16_4.png
new file mode 100644
index 0000000..94cd442
--- /dev/null
+++ b/content/skin/sync16_4.png
diff --git a/content/skin/tbsync.png b/content/skin/tbsync.png
new file mode 100644
index 0000000..be77a1f
--- /dev/null
+++ b/content/skin/tbsync.png
diff --git a/content/skin/tbsync64.png b/content/skin/tbsync64.png
new file mode 100644
index 0000000..0877be0
--- /dev/null
+++ b/content/skin/tbsync64.png
diff --git a/content/skin/tick16.png b/content/skin/tick16.png
new file mode 100644
index 0000000..db93138
--- /dev/null
+++ b/content/skin/tick16.png
diff --git a/content/skin/todo16.png b/content/skin/todo16.png
new file mode 100644
index 0000000..0023b3a
--- /dev/null
+++ b/content/skin/todo16.png
diff --git a/content/skin/todo16_share.png b/content/skin/todo16_share.png
new file mode 100644
index 0000000..46849be
--- /dev/null
+++ b/content/skin/todo16_share.png
diff --git a/content/skin/trash16.png b/content/skin/trash16.png
new file mode 100644
index 0000000..b8c10d3
--- /dev/null
+++ b/content/skin/trash16.png
diff --git a/content/skin/update32.png b/content/skin/update32.png
new file mode 100644
index 0000000..f9621e8
--- /dev/null
+++ b/content/skin/update32.png
diff --git a/content/skin/user48.png b/content/skin/user48.png
new file mode 100644
index 0000000..51bf808
--- /dev/null
+++ b/content/skin/user48.png
diff --git a/content/skin/warning16.png b/content/skin/warning16.png
new file mode 100644
index 0000000..3f04b67
--- /dev/null
+++ b/content/skin/warning16.png
diff --git a/content/tbsync.jsm b/content/tbsync.jsm
new file mode 100644
index 0000000..e31931d
--- /dev/null
+++ b/content/tbsync.jsm
@@ -0,0 +1,163 @@
+/*
+ * This file is part of TbSync.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. 
+ */
+ 
+ "use strict";
+
+var EXPORTED_SYMBOLS = ["TbSync"];
+
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+var { FileUtils } = ChromeUtils.import("resource://gre/modules/FileUtils.jsm");
+var { AddonManager } = ChromeUtils.import("resource://gre/modules/AddonManager.jsm");
+var { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+var { MailServices } = ChromeUtils.import("resource:///modules/MailServices.jsm");
+var { OverlayManager } = ChromeUtils.import("chrome://tbsync/content/OverlayManager.jsm");
+
+var TbSync = {
+
+  enabled: false,
+  shutdown: false,
+  
+  window: null,
+  addon: null,
+  version: 0,
+  debugMode: false,
+  apiVersion: "2.5",
+
+  prefs: Services.prefs.getBranch("extensions.tbsync."),
+  
+  decoder: new TextDecoder(),
+  encoder: new TextEncoder(),
+
+  modules : [],
+  extension : null,
+  
+  // global load
+  load: async function (window, addon, extension) {
+	  //public module and IO module needs to be loaded beforehand
+    Services.scriptloader.loadSubScript("chrome://tbsync/content/modules/public.js", this, "UTF-8");
+    Services.scriptloader.loadSubScript("chrome://tbsync/content/modules/io.js", this, "UTF-8");
+
+    //clear debug log on start
+    this.io.initFile("debug.log");
+
+    this.window = window;
+    this.addon = addon;
+    this.addon.contributorsURL = "https://github.com/jobisoft/TbSync/blob/master/CONTRIBUTORS.md";
+    this.extension = extension;
+    this.dump("TbSync init","Start (" + this.addon.version.toString() + ")");
+
+    //print information about Thunderbird version and OS
+    this.dump(Services.appinfo.name, Services.appinfo.version + " on " + Services.appinfo.OS);
+
+    // register modules to be used by TbSync
+    this.modules.push({name: "db", state: 0});
+    this.modules.push({name: "addressbook", state: 0});
+    this.modules.push({name: "lightning", state: 0});
+    this.modules.push({name: "eventlog", state: 0});
+    this.modules.push({name: "core", state: 0});
+    this.modules.push({name: "passwordManager", state: 0});
+    this.modules.push({name: "network", state: 0});
+    this.modules.push({name: "tools", state: 0});
+    this.modules.push({name: "manager", state: 0});
+    this.modules.push({name: "providers", state: 0});
+    this.modules.push({name: "messenger", state: 0});
+
+    //load modules
+    for (let module of this.modules) {
+      try {
+        Services.scriptloader.loadSubScript("chrome://tbsync/content/modules/" + module.name + ".js", this, "UTF-8");
+        module.state = 1;
+        this.dump("Loading module <" + module.name + ">", "OK");
+      } catch (e) {
+        this.dump("Loading module <" + module.name + ">", "FAILED!");
+        Components.utils.reportError(e);
+      }
+    }
+
+    //call init function of loaded modules
+    for (let module of this.modules) {
+      if (module.state == 1) {
+        try {
+          this.dump("Initializing module", "<" + module.name + ">");
+          await this[module.name].load();
+          module.state = 2;
+        } catch (e) {
+          this.dump("Initialization of module <" + module.name + "> FAILED", e.message + "\n" + e.stack);
+          Components.utils.reportError(e);
+        }
+      }
+    }
+    
+    //was debug mode enabled during startup?
+    this.debugMode = (this.prefs.getIntPref("log.userdatalevel") > 0);
+
+    //enable TbSync
+    this.enabled = true;
+
+    //notify about finished init of TbSync
+    Services.obs.notifyObservers(null, "tbsync.observer.manager.updateSyncstate", null);
+    Services.obs.notifyObservers(null, 'tbsync.observer.initialized', null);
+
+    //activate sync timer
+    this.syncTimer.start();
+
+    this.dump("TbSync init","Done");
+  },
+  
+  // global unload
+  unload: async function() {
+    //cancel sync timer
+    this.syncTimer.cancel();
+    
+    //unload modules in reverse order
+    this.modules.reverse();
+    for (let module of this.modules) {
+      if (module.state == 2) {
+        try {
+          await this[module.name].unload();
+          this.dump("Unloading module <" + module.name + ">", "OK");
+        } catch (e) {
+          this.dump("Unloading module <" + module.name + ">", "FAILED!");
+          Components.utils.reportError(e);
+        }
+      }
+    }
+  },
+
+  // timer for periodic sync
+  syncTimer: {
+    timer: Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer),
+
+    start: function () {
+      this.timer.cancel();
+      this.timer.initWithCallback(this.event, 60000, 3); //run timer every 60s
+    },
+
+    cancel: function () {
+      this.timer.cancel();
+    },
+
+    event: {
+      notify: function (timer) {
+        if (TbSync.enabled) {
+          //get all accounts and check, which one needs sync
+          let accounts = TbSync.db.getAccounts();
+          for (let i=0; i<accounts.IDs.length; i++) {
+            let now = Date.now();
+            let syncInterval = accounts.data[accounts.IDs[i]].autosync * 60 * 1000;
+            let lastsynctime = accounts.data[accounts.IDs[i]].lastsynctime;
+            let noAutosyncUntil = accounts.data[accounts.IDs[i]].noAutosyncUntil || 0;
+            if (TbSync.core.isEnabled(accounts.IDs[i]) && (syncInterval > 0) && (now > (lastsynctime + syncInterval)) && (now > noAutosyncUntil)) {
+                TbSync.core.syncAccount(accounts.IDs[i]);
+            }
+          }
+        }
+      }
+    }
+  }
+};