zotero/chrome/content/zotero/xpcom/sync/syncRunner.js

/*
    ***** BEGIN LICENSE BLOCK *****
    
    Copyright © 2009 Center for History and New Media
                     George Mason University, Fairfax, Virginia, USA
                     http://zotero.org
    
    This file is part of Zotero.
    
    Zotero is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    Zotero is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.
    
    You should have received a copy of the GNU Affero General Public License
    along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
    
    ***** END LICENSE BLOCK *****
*/

"use strict";

if (!Zotero.Sync) {
	Zotero.Sync = {};
}

// Initialized as Zotero.Sync.Runner in zotero.js
Zotero.Sync.Runner_Module = function (options = {}) {
	const stopOnError = false;
	const HTML_NS = 'http://www.w3.org/1999/xhtml';
	
	Zotero.defineProperty(this, 'enabled', {
		get: () => {
			return _apiKey || Zotero.Sync.Data.Local.hasCredentials();
		}
	});
	Zotero.defineProperty(this, 'syncInProgress', { get: () => _syncInProgress });
	Zotero.defineProperty(this, 'lastSyncStatus', { get: () => _lastSyncStatus });
	
	Zotero.defineProperty(this, 'RESET_MODE_FROM_SERVER', { value: 1 });
	Zotero.defineProperty(this, 'RESET_MODE_TO_SERVER', { value: 2 });
	
	Zotero.defineProperty(this, 'baseURL', {
		get: () => {
			let url = options.baseURL || Zotero.Prefs.get("api.url") || ZOTERO_CONFIG.API_URL;
			if (!url.endsWith('/')) {
				url += '/';
			}
			return url;
		}
	});
	this.apiVersion = options.apiVersion || ZOTERO_CONFIG.API_VERSION;
	
	// Allows tests to set apiKey in options or as property, overriding login manager
	var _apiKey = options.apiKey;
	Zotero.defineProperty(this, 'apiKey', { set: val => _apiKey = val });
	
	Components.utils.import("resource://zotero/concurrentCaller.js");
	this.caller = new ConcurrentCaller({
		numConcurrent: 4,
		stopOnError,
		logger: msg => Zotero.debug(msg),
		onError: e => Zotero.logError(e),
		Promise: Zotero.Promise
	});
	
	var _enabled = false;
	var _autoSyncTimer;
	var _delaySyncUntil;
	var _delayPromises = [];
	var _firstInSession = true;
	var _syncInProgress = false;
	var _queuedSyncOptions = [];
	var _stopping = false;
	var _canceller;
	var _manualSyncRequired = false; // TODO: make public?
	
	var _currentEngine = null;
	var _storageControllers = {};
	
	var _lastSyncStatus;
	var _currentSyncStatusLabel;
	var _currentLastSyncLabel;
	var _currentTooltipMessages;
	var _errors = [];
	var _tooltipMessages = [];
	
	Zotero.addShutdownListener(() => this.stop());
	
	this.getAPIClient = function (options = {}) {
		return new Zotero.Sync.APIClient({
			baseURL: this.baseURL,
			apiVersion: this.apiVersion,
			schemaVersion: this.globalSchemaVersion,
			apiKey: options.apiKey,
			caller: this.caller,
			cancellerReceiver: _cancellerReceiver,
		});
	}
	
	
	/**
	 * Begin a sync session
	 *
	 * @param {Object}    [options]
	 * @param {Boolean}   [options.background=false]  Whether this is a background request, which
	 *                                                prevents some alerts from being shown
	 * @param {Integer[]} [options.libraries]         IDs of libraries to sync; skipped libraries must
	 *     be removed if unwanted
	 * @param {Function}  [options.onError]           Function to pass errors to instead of
	 *                                                handling internally (used for testing)
	 */
	this.sync = Zotero.serial(function (options = {}) {
		return this._sync(options);
	});
	
	
	this._sync = Zotero.Promise.coroutine(function* (options) {
		// Clear message list
		_errors = [];
		_tooltipMessages = [];
		
		// Shouldn't be possible because of serial()
		if (_syncInProgress) {
			let msg = Zotero.getString('sync.error.syncInProgress');
			let e = new Zotero.Error(msg, 0, { dialogButtonText: null, frontWindowOnly: true });
			this.updateIcons(e);
			return false;
		}
		_syncInProgress = true;
		_stopping = false;
		
		try {
			yield Zotero.Notifier.trigger('start', 'sync', []);
			
			let apiKey = yield _getAPIKey();
			if (!apiKey) {
				throw new Zotero.Error("API key not set", Zotero.Error.ERROR_API_KEY_NOT_SET);
			}
			
			if (_firstInSession) {
				options.firstInSession = true;
				_firstInSession = false;
			}
			
			this.updateIcons('animate');
			
			// If a delay is set (e.g., from the connector target selector), wait to sync
			while (_delaySyncUntil && new Date() < _delaySyncUntil) {
				this.setSyncStatus(Zotero.getString('sync.status.waiting'));
				let delay = _delaySyncUntil - new Date();
				Zotero.debug(`Waiting ${delay} ms to sync`);
				yield Zotero.Promise.delay(delay);
			}
			
			// If paused, wait until we're done
			while (true) {
				if (_delayPromises.some(p => p.isPending())) {
					this.setSyncStatus(Zotero.getString('sync.status.waiting'));
					Zotero.debug("Syncing is paused -- waiting to sync");
					yield Zotero.Promise.all(_delayPromises);
					// If more were added, continue
					if (_delayPromises.some(p => p.isPending())) {
						continue;
					}
					_delayPromises = [];
				}
				break;
			}
			
			// purgeDataObjects() starts a transaction, so if there's an active one then show a
			// nice message and wait until there's not. Another transaction could still start
			// before purgeDataObjects() and result in a wait timeout, but this should reduce the
			// frequency of that.
			while (Zotero.DB.inTransaction()) {
				this.setSyncStatus(Zotero.getString('sync.status.waiting'));
				Zotero.debug("Transaction in progress -- waiting to sync");
				yield Zotero.DB.waitForTransaction('sync');
				_stopCheck();
			}
			
			this.setSyncStatus(Zotero.getString('sync.status.preparing'));
			
			// Purge deleted objects so they don't cause sync errors (e.g., long tags)
			yield Zotero.purgeDataObjects(true);
			
			let client = this.getAPIClient({ apiKey });
			let keyInfo = yield this.checkAccess(client, options);
			
			_stopCheck();
			
			let emptyLibraryContinue = yield this.checkEmptyLibrary(keyInfo);
			if (!emptyLibraryContinue) {
				Zotero.debug("Syncing cancelled because user library is empty");
				return false;
			}
			
			let wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
				.getService(Components.interfaces.nsIWindowMediator);
			let lastWin = wm.getMostRecentWindow("navigator:browser");
			let ok = yield Zotero.Sync.Data.Local.checkUser(
				lastWin,
				keyInfo.userID,
				keyInfo.username,
				keyInfo.displayName
			);
			if (!ok) {
				Zotero.debug("User cancelled sync on username mismatch");
				return false;
			}
			
			let engineOptions = {
				userID: keyInfo.userID,
				apiClient: client,
				caller: this.caller,
				setStatus: this.setSyncStatus.bind(this),
				stopOnError,
				onError: function (e) {
					// Ignore cancelled requests
					if (e instanceof Zotero.HTTP.CancelledException) {
						Zotero.debug("Request was cancelled");
						return;
					}
					if (options.onError) {
						options.onError(e);
					}
					else {
						this.addError(e);
					}
				}.bind(this),
				background: !!options.background,
				firstInSession: _firstInSession,
				resetMode: options.resetMode
			};
			
			var librariesToSync = options.libraries = yield this.checkLibraries(
				client,
				options,
				keyInfo,
				options.libraries ? Array.from(options.libraries) : []
			);
			
			// If file and full-text libraries are specified, limit to libraries we're already
			// syncing
			var fileLibrariesToSync = new Set(
				options.fileLibraries
					? options.fileLibraries.filter(id => librariesToSync.includes(id))
					: librariesToSync
			);
			var fullTextLibrariesToSync = new Set(
				options.fullTextLibraries
					? options.fullTextLibraries.filter(id => librariesToSync.includes(id))
					: librariesToSync
			);
			
			_stopCheck();
			
			// If items not yet loaded for libraries we need, load them now
			for (let libraryID of librariesToSync) {
				let library = Zotero.Libraries.get(libraryID);
				if (!library.getDataLoaded('item')) {
					yield library.waitForDataLoad('item');
				}
			}
			
			_stopCheck();
			
			// Sync data and files, and then repeat if necessary
			let attempt = 1;
			let successfulLibraries = new Set(librariesToSync);
			while (librariesToSync.length) {
				_stopCheck();
				
				if (attempt > 3) {
					// TODO: Back off and/or nicer error
					throw new Error("Too many sync attempts -- stopping");
				}
				let nextLibraries = yield _doDataSync(librariesToSync, engineOptions);
				// Remove failed libraries from the successful set
				Zotero.Utilities.arrayDiff(librariesToSync, nextLibraries).forEach(libraryID => {
					successfulLibraries.delete(libraryID);
				});
				
				_stopCheck();
				
				// Run file sync on all allowed libraries that passed the last data sync
				librariesToSync = yield _doFileSync(
					nextLibraries.filter(libraryID => fileLibrariesToSync.has(libraryID)),
					engineOptions
				);
				if (librariesToSync.length) {
					attempt++;
					continue;
				}
				
				_stopCheck();
				
				// Run full-text sync on all allowed libraries that haven't failed a data sync
				librariesToSync = yield _doFullTextSync(
					[...successfulLibraries].filter(libraryID => fullTextLibrariesToSync.has(libraryID)),
					engineOptions
				);
				if (librariesToSync.length) {
					attempt++;
					continue;
				}
				break;
			}
		}
		catch (e) {
			if (e instanceof Zotero.HTTP.BrowserOfflineException) {
				let msg = Zotero.getString('general.browserIsOffline', Zotero.appName);
				e = new Zotero.Error(msg, 0, { dialogButtonText: null })
				Zotero.logError(e);
				_errors = [];
			}
			
			if (e instanceof Zotero.Sync.UserCancelledException
					|| e instanceof Zotero.HTTP.CancelledException) {
				Zotero.debug("Sync was cancelled");
			}
			else if (options.onError) {
				options.onError(e);
			}
			else {
				this.addError(e);
			}
		}
		finally {
			yield this.end(options);
			
			if (options.restartSync) {
				delete options.restartSync;
				Zotero.debug("Restarting sync");
				yield this._sync(options);
				return;
			}
			// If an auto-sync was queued while a sync was ongoing, start again with its options
			else if (_queuedSyncOptions.length) {
				Zotero.debug("Restarting sync");
				yield this._sync(JSON.parse(_queuedSyncOptions.shift()));
				return;
			}
			
			Zotero.debug("Done syncing");
			Zotero.Notifier.trigger('finish', 'sync', librariesToSync || []);
		}
	});
	
	
	/**
	 * Check key for current user info and return access info
	 */
	this.checkAccess = Zotero.Promise.coroutine(function* (client, options={}) {
		var json = yield client.getKeyInfo(options);
		Zotero.debug(json);
		if (!json) {
			throw new Zotero.Error("API key not set", Zotero.Error.ERROR_API_KEY_INVALID);
		}
		
		// Sanity check
		if (!json.userID) throw new Error("userID not found in key response");
		if (!json.username) throw new Error("username not found in key response");
		if (!json.access) throw new Error("'access' not found in key response");
		
		return json;
	});


	// Prompt if library empty and there is no userID stored
	this.checkEmptyLibrary = Zotero.Promise.coroutine(function* (keyInfo) {
		let library = Zotero.Libraries.userLibrary;
		let feeds = Zotero.Feeds.getAll();
		let userID = Zotero.Users.getCurrentUserID();

		if (!userID) {
			let hasItems = yield library.hasItems();
			if (!hasItems && feeds.length <= 0 && !Zotero.resetDataDir) {
				let ps = Services.prompt;
				let index = ps.confirmEx(
					null,
					Zotero.getString('general.warning'),
					Zotero.getString(
							'account.warning.emptyLibrary',
							[Zotero.clientName, OS.Path.basename(Zotero.DB.path)]
						) + "\n\n"
						+ Zotero.getString(
							'account.warning.emptyLibrary.dataWillBeDownloaded',
							keyInfo.username
						)
						+ "\n\n"
						+ Zotero.getString(
							'account.warning.existingDataElsewhere',
							Zotero.clientName
						)
						+ "\n\n"
						+ Zotero.getString('dataDir.location', Zotero.DataDirectory.dir),
					(ps.BUTTON_POS_0 * ps.BUTTON_TITLE_IS_STRING) 
						+ (ps.BUTTON_POS_1 * ps.BUTTON_TITLE_CANCEL)
						+ (ps.BUTTON_POS_2 * ps.BUTTON_TITLE_IS_STRING),
					Zotero.getString('sync.sync'),
					null, 
					Zotero.getString('general.moreInformation'),
					null, {}
				);
				if (index == 1) {
					return false;
				}
				else if (index == 2) {
					Zotero.launchURL('https://www.zotero.org/support/zotero_data#locating_missing_zotero_data');
					return false;
				}
			}
		}
		return true;
	});
	
	
	/**
	 * @return {Promise<Integer[]> - IDs of libraries to sync
	 */
	this.checkLibraries = Zotero.Promise.coroutine(function* (client, options, keyInfo, libraries = []) {
		var access = keyInfo.access;
		
		var syncAllLibraries = !libraries || !libraries.length;
		
		// TODO: Ability to remove or disable editing of user library?
		
		if (syncAllLibraries) {
			if (access.user && access.user.library) {
				libraries = [Zotero.Libraries.userLibraryID];
				let skippedLibraries = Zotero.Sync.Data.Local.getSkippedLibraries();
				
				// If syncing all libraries, remove skipped libraries
				if (skippedLibraries.length) {
					Zotero.debug("Skipped libraries:");
					Zotero.debug(skippedLibraries);
					libraries = Zotero.Utilities.arrayDiff(libraries, skippedLibraries);
				}
			}
		}
		else {
			// Check access to specified libraries
			for (let libraryID of libraries) {
				let type = Zotero.Libraries.get(libraryID).libraryType;
				if (type == 'user') {
					if (!access.user || !access.user.library) {
						// TODO: Alert
						throw new Error("Key does not have access to library " + libraryID);
					}
				}
			}
		}
		
		//
		// Check group access
		//
		let remotelyMissingGroups = [];
		let groupsToDownload = [];
		
		if (!Zotero.Utilities.isEmpty(access.groups)) {
			// TEMP: Require all-group access for now
			if (access.groups.all) {
				
			}
			else {
				throw new Error("Full group access is currently required");
			}
			
			let remoteGroupVersions = yield client.getGroupVersions(keyInfo.userID);
			let remoteGroupIDs = Object.keys(remoteGroupVersions).map(id => parseInt(id));
			let skippedGroups = Zotero.Sync.Data.Local.getSkippedGroups();
			
			// Remove skipped groups
			if (syncAllLibraries) {
				let newGroups = Zotero.Utilities.arrayDiff(remoteGroupIDs, skippedGroups);
				Zotero.Utilities.arrayDiff(remoteGroupIDs, newGroups)
					.forEach(id => { delete remoteGroupVersions[id] });
				remoteGroupIDs = newGroups;
			}
			
			for (let id in remoteGroupVersions) {
				id = parseInt(id);
				let group = Zotero.Groups.get(id);
				
				if (syncAllLibraries) {
					// If syncing all libraries, mark any that don't exist, are outdated, or are
					// archived locally for update. Group is added to the library list after downloading.
					if (!group || group.version < remoteGroupVersions[id] || group.archived) {
						Zotero.debug(`Marking group ${id} to download`);
						groupsToDownload.push(id);
					}
					// If not outdated, just add to library list
					else {
						Zotero.debug(`Adding group library ${group.libraryID} to sync`);
						libraries.push(group.libraryID);
					}
				}
				else {
					// If specific libraries were provided, ignore remote groups that don't
					// exist locally or aren't in the given list
					if (!group || libraries.indexOf(group.libraryID) == -1) {
						continue;
					}
					// If group metadata is outdated, mark for update
					if (group.version < remoteGroupVersions[id]) {
						groupsToDownload.push(id);
					}
				}
			}
			
			// Get local groups (all if syncing all libraries or just selected ones) that don't
			// exist remotely
			// TODO: Use explicit removals?
			let localGroups;
			if (syncAllLibraries) {
				localGroups = Zotero.Groups.getAll()
					.map(g => g.id)
					// Don't include skipped groups
					.filter(id => skippedGroups.indexOf(id) == -1);
			}
			else {
				localGroups = libraries
					.filter(id => Zotero.Libraries.get(id).libraryType == 'group')
					.map(id => Zotero.Groups.getGroupIDFromLibraryID(id))
			}
			Zotero.debug("Local groups:");
			Zotero.debug(localGroups);
			remotelyMissingGroups = Zotero.Utilities.arrayDiff(localGroups, remoteGroupIDs)
				.map(id => Zotero.Groups.get(id));
		}
		// No group access
		else {
			remotelyMissingGroups = Zotero.Groups.getAll();
		}
		
		if (remotelyMissingGroups.length) {
			// TODO: What about explicit deletions?
			
			let removedGroups = [];
			let keptGroups = [];
			
			let ps = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
				.getService(Components.interfaces.nsIPromptService);
			let buttonFlags = (ps.BUTTON_POS_0) * (ps.BUTTON_TITLE_IS_STRING)
				+ (ps.BUTTON_POS_1) * (ps.BUTTON_TITLE_IS_STRING)
				+ (ps.BUTTON_POS_2) * (ps.BUTTON_TITLE_IS_STRING)
				+ ps.BUTTON_DELAY_ENABLE;
			
			// Prompt for each group
			//
			// TODO: Localize
			for (let group of remotelyMissingGroups) {
				// Ignore remotely missing archived groups
				if (group.archived) {
					groupsToDownload = groupsToDownload.filter(groupID => groupID != group.id);
					continue;
				}
				
				let msg;
				// If all-groups access but group is missing, user left it
				if (access.groups && access.groups.all) {
					msg = "You are no longer a member of the group \u2018" + group.name + "\u2019.";
				}
				// If not all-groups access, key might just not have access
				else {
					msg = "You no longer have access to the group \u2018" + group.name + "\u2019.";
				}
				
				msg += "\n\n" + "Would you like to remove it from this computer or keep it "
					+ "as a read-only library?";
				
				let index = ps.confirmEx(
					null,
					"Group Not Found",
					msg,
					buttonFlags,
					"Remove Group",
					// TODO: Any way to have Esc trigger extra1 instead so it doesn't
					// have to be in this order?
					"Cancel Sync",
					"Keep Group",
					null, {}
				);
				
				if (index == 0) {
					removedGroups.push(group);
				}
				else if (index == 1) {
					Zotero.debug("Cancelling sync");
					return [];
				}
				else if (index == 2) {
					keptGroups.push(group);
				}
			}
			
			let removedLibraryIDs = [];
			for (let group of removedGroups) {
				removedLibraryIDs.push(group.libraryID);
				yield group.eraseTx();
			}
			libraries = Zotero.Utilities.arrayDiff(libraries, removedLibraryIDs);
			
			let keptLibraryIDs = [];
			for (let group of keptGroups) {
				keptLibraryIDs.push(group.libraryID);
				group.editable = false;
				group.archived = true;
				yield group.saveTx();
			}
			libraries = Zotero.Utilities.arrayDiff(libraries, keptLibraryIDs);
		}
		
		// Update metadata and permissions on missing or outdated groups
		for (let groupID of groupsToDownload) {
			let info = yield client.getGroup(groupID);
			if (!info) {
				throw new Error("Group " + groupID + " not found");
			}
			let group = Zotero.Groups.get(groupID);
			if (group) {
				// Check if the user's permissions for the group have changed, and prompt to reset
				// data if so
				let { editable, filesEditable } = Zotero.Groups.getPermissionsFromJSON(
					info.data, keyInfo.userID
				);
				let keepGoing = yield Zotero.Sync.Data.Local.checkLibraryForAccess(
					null, group.libraryID, editable, filesEditable
				);
				// User chose to skip library
				if (!keepGoing) {
					Zotero.debug("Skipping sync of group " + group.id);
					continue;
				}
			}
			else {
				group = new Zotero.Group;
				group.id = groupID;
			}
			group.version = info.version;
			group.archived = false;
			group.fromJSON(info.data, Zotero.Users.getCurrentUserID());
			yield group.saveTx();
			
			// Add group to library list
			libraries.push(group.libraryID);
		}
		
		// Note: If any non-group library types become archivable, they'll need to be unarchived here.
		Zotero.debug("Final libraries to sync:");
		Zotero.debug(libraries);
		
		return [...new Set(libraries)];
	});
	
	
	/**
	 * Run sync engine for passed libraries
	 *
	 * @param {Integer[]} libraries
	 * @param {Object} options
	 * @param {Boolean} skipUpdateLastSyncTime
	 * @return {Integer[]} - Array of libraryIDs that completed successfully
	 */
	var _doDataSync = Zotero.Promise.coroutine(function* (libraries, options, skipUpdateLastSyncTime) {
		var successfulLibraries = [];
		for (let libraryID of libraries) {
			_stopCheck();
			try {
				let opts = {};
				Object.assign(opts, options);
				opts.libraryID = libraryID;
				
				_currentEngine = new Zotero.Sync.Data.Engine(opts);
				yield _currentEngine.start();
				_currentEngine = null;
				successfulLibraries.push(libraryID);
			}
			catch (e) {
				if (e instanceof Zotero.Sync.UserCancelledException) {
					if (e.advanceToNextLibrary) {
						Zotero.debug("Sync cancelled for library " + libraryID + " -- "
							+ "advancing to next library");
						continue;
					}
					throw e;
				}
				
				Zotero.debug("Sync failed for library " + libraryID, 1);
				Zotero.logError(e);
				this.checkError(e);
				options.onError(e);
				if (stopOnError || e.fatal) {
					Zotero.debug("Stopping on error", 1);
					options.caller.stop();
					break;
				}
			}
		}
		// Update last-sync time if any libraries synced
		// TEMP: Do we want to show updated time if some libraries haven't synced?
		if (!libraries.length || successfulLibraries.length) {
			yield Zotero.Sync.Data.Local.updateLastSyncTime();
		}
		return successfulLibraries;
	}.bind(this));
	
	
	/**
	 * @return {Integer[]} - Array of libraries that need data syncing again
	 */
	var _doFileSync = Zotero.Promise.coroutine(function* (libraries, options) {
		Zotero.debug("Starting file syncing");
		var resyncLibraries = []
		for (let libraryID of libraries) {
			_stopCheck();
			let libraryName = Zotero.Libraries.get(libraryID).name;
			this.setSyncStatus(
				Zotero.getString('sync.status.syncingFilesInLibrary', libraryName)
			);
			try {
				let opts = {
					onProgress: (progress, progressMax) => {
						var remaining = progressMax - progress;
						this.setSyncStatus(
							Zotero.getString(
								'sync.status.syncingFilesInLibraryWithRemaining',
								[libraryName, remaining],
								remaining
							)
						);
					}
				};
				Object.assign(opts, options);
				opts.libraryID = libraryID;
				
				let mode = Zotero.Sync.Storage.Local.getModeForLibrary(libraryID);
				opts.controller = this.getStorageController(mode, opts);
				
				let tries = 3;
				while (true) {
					if (tries == 0) {
						throw new Error("Too many file sync attempts for library " + libraryID);
					}
					tries--;
					_currentEngine = new Zotero.Sync.Storage.Engine(opts);
					let results = yield _currentEngine.start();
					_currentEngine = null;
					if (results.syncRequired) {
						resyncLibraries.push(libraryID);
					}
					else if (results.fileSyncRequired) {
						Zotero.debug("Another file sync required -- restarting");
						continue;
					}
					break;
				}
			}
			catch (e) {
				if (e instanceof Zotero.Sync.UserCancelledException) {
					if (e.advanceToNextLibrary) {
						Zotero.debug("Storage sync cancelled for library " + libraryID + " -- "
							+ "advancing to next library");
						continue;
					}
					throw e;
				}
				
				Zotero.debug("File sync failed for library " + libraryID);
				Zotero.logError(e);
				this.checkError(e);
				options.onError(e);
				if (stopOnError || e.fatal) {
					options.caller.stop();
					break;
				}
			}
		}
		Zotero.debug("Done with file syncing");
		if (resyncLibraries.length) {
			Zotero.debug("Libraries to resync: " + resyncLibraries.join(", "));
		}
		return resyncLibraries;
	}.bind(this));
	
	
	/**
	 * @return {Integer[]} - Array of libraries that need data syncing again
	 */
	var _doFullTextSync = Zotero.Promise.coroutine(function* (libraries, options) {
		if (!Zotero.Prefs.get("sync.fulltext.enabled")) return [];
		
		Zotero.debug("Starting full-text syncing");
		this.setSyncStatus(Zotero.getString('sync.status.syncingFullText'));
		var resyncLibraries = [];
		for (let libraryID of libraries) {
			_stopCheck();
			try {
				let opts = {};
				Object.assign(opts, options);
				opts.libraryID = libraryID;
				
				_currentEngine = new Zotero.Sync.Data.FullTextEngine(opts);
				yield _currentEngine.start();
				_currentEngine = null;
			}
			catch (e) {
				if (e instanceof Zotero.Sync.UserCancelledException) {
					throw e;
				}
				
				if (e instanceof Zotero.HTTP.UnexpectedStatusException && e.status == 412) {
					resyncLibraries.push(libraryID);
					continue;
				}
				Zotero.debug("Full-text sync failed for library " + libraryID);
				Zotero.logError(e);
				this.checkError(e);
				options.onError(e);
				if (stopOnError || e.fatal) {
					options.caller.stop();
					break;
				}
			}
		}
		Zotero.debug("Done with full-text syncing");
		if (resyncLibraries.length) {
			Zotero.debug("Libraries to resync: " + resyncLibraries.join(", "));
		}
		return resyncLibraries;
	}.bind(this));
	
	
	/**
	 * Get a storage controller for a given mode ('zfs', 'webdav'),
	 * caching it if necessary
	 */
	this.getStorageController = function (mode, options) {
		if (_storageControllers[mode]) {
			return _storageControllers[mode];
		}
		var modeClass = Zotero.Sync.Storage.Utilities.getClassForMode(mode);
		return _storageControllers[mode] = new modeClass(options);
	},
	
	
	// TODO: Call on API key change
	this.resetStorageController = function (mode) {
		delete _storageControllers[mode];
	},
	
	
	/**
	 * Download a single file on demand (not within a sync process)
	 */
	this.downloadFile = Zotero.Promise.coroutine(function* (item, requestCallbacks) {
		if (Zotero.HTTP.browserIsOffline()) {
			Zotero.debug("Browser is offline", 2);
			return false;
		}
		
		var apiKey = yield _getAPIKey();
		if (!apiKey) {
			Zotero.debug("API key not set -- skipping download");
			return false;
		}
		
		// TEMP
		var options = {};
		
		var itemID = item.id;
		var modeClass = Zotero.Sync.Storage.Local.getClassForLibrary(item.libraryID);
		var controller = new modeClass({
			apiClient: this.getAPIClient({apiKey })
		});
		
		// TODO: verify WebDAV on-demand?
		if (!controller.verified) {
			Zotero.debug("File syncing is not active for item's library -- skipping download");
			return false;
		}
		
		if (!item.isStoredFileAttachment()) {
			throw new Error("Not a stored file attachment");
		}
		
		if (yield item.getFilePathAsync()) {
			Zotero.debug("File already exists -- replacing");
		}
		
		// TODO: start sync icon?
		// TODO: create queue for cancelling
		
		if (!requestCallbacks) {
			requestCallbacks = {};
		}
		var onStart = function (request) {
			return controller.downloadFile(request);
		};
		var request = new Zotero.Sync.Storage.Request({
			type: 'download',
			libraryID: item.libraryID,
			name: item.libraryKey,
			onStart: requestCallbacks.onStart
				? [onStart, requestCallbacks.onStart]
				: [onStart]
		});
		return request.start();
	});
	
	
	this.stop = function () {
		this.setSyncStatus(Zotero.getString('sync.stopping'));
		_stopping = true;
		if (_currentEngine) {
			_currentEngine.stop();
		}
		if (_canceller) {
			_canceller();
		}
	}
	
	
	this.end = Zotero.Promise.coroutine(function* (options) {
		_syncInProgress = false;
		yield this.checkErrors(_errors, options);
		if (!options.restartSync) {
			this.updateIcons(_errors);
		}
		_errors = [];
	});
	
	
	/**
	 * @param {Integer} timeout - Timeout in seconds
	 * @param {Boolean} [recurring=false]
	 * @param {Object} [options] - Sync options (e.g., 'libraries', 'fileLibraries', 'fullTextLibraries')
	 */
	this.setSyncTimeout = function (timeout, recurring, options = {}) {
		if (!Zotero.Prefs.get('sync.autoSync') || !this.enabled) {
			return;
		}
		
		if (!timeout) {
			throw new Error("Timeout not provided");
		}
		
		if (timeout != parseInt(timeout)) {
			throw new Error(`Timeout must be an integer (${timeout} given)`);
		}
		
		if (_autoSyncTimer) {
			Zotero.debug("Cancelling auto-sync timer");
			_autoSyncTimer.cancel();
		}
		else {
			_autoSyncTimer = Components.classes["@mozilla.org/timer;1"].
				createInstance(Components.interfaces.nsITimer);
		}
		
		var mergedOpts = {
			background: true
		};
		Object.assign(mergedOpts, options);
		
		// Implements nsITimerCallback
		var callback = {
			notify: async function (timer) {
				if (!_getAPIKey()) {
					return;
				}
				
				// If a delay is set (e.g., from the connector target selector), wait to sync.
				// We do this in sync() too for manual syncs, but no need to start spinning if
				// it's just an auto-sync.
				while (_delaySyncUntil && new Date() < _delaySyncUntil) {
					let delay = _delaySyncUntil - new Date();
					Zotero.debug(`Waiting ${delay} ms to start auto-sync`);
					await Zotero.Promise.delay(delay);
				}
				
				if (Zotero.locked) {
					Zotero.debug('Zotero is locked -- skipping auto-sync', 4);
					_queueSyncOptions(mergedOpts);
					return;
				}
				
				if (_syncInProgress) {
					Zotero.debug('Sync already in progress -- skipping auto-sync', 4);
					_queueSyncOptions(mergedOpts);
					return;
				}
				
				if (_manualSyncRequired) {
					Zotero.debug('Manual sync required -- skipping auto-sync', 4);
					return;
				}
				
				this.sync(mergedOpts);
			}.bind(this)
		}
		
		if (recurring) {
			Zotero.debug('Setting auto-sync interval to ' + timeout + ' seconds');
			_autoSyncTimer.initWithCallback(
				callback, timeout * 1000, Components.interfaces.nsITimer.TYPE_REPEATING_SLACK
			);
		}
		else {
			if (_syncInProgress) {
				Zotero.debug('Sync in progress -- not setting auto-sync timeout', 4);
				_queueSyncOptions(mergedOpts);
				return;
			}
			
			Zotero.debug('Setting auto-sync timeout to ' + timeout + ' seconds');
			_autoSyncTimer.initWithCallback(
				callback, timeout * 1000, Components.interfaces.nsITimer.TYPE_ONE_SHOT
			);
		}
	}
	
	
	function _queueSyncOptions(options) {
		var jsonOptions = JSON.stringify(options);
		// Don't queue options if already queued
		if (_queuedSyncOptions.includes(jsonOptions)) {
			return;
		}
		Zotero.debug("Queueing sync options");
		Zotero.debug(options);
		_queuedSyncOptions.push(jsonOptions);
	}
	
	
	this.clearSyncTimeout = function () {
		if (_autoSyncTimer) {
			_autoSyncTimer.cancel();
		}
	}
	
	
	this.delaySync = function (ms) {
		_delaySyncUntil = new Date(Date.now() + ms);
	};
	
	
	/**
	 * Delay syncs until the returned function is called
	 *
	 * @return {Function} - Resolve function
	 */
	this.delayIndefinite = function () {
		var resolve;
		var promise = new Zotero.Promise(function () {
			resolve = arguments[0];
		});
		_delayPromises.push(promise);
		return resolve;
	};
	
	
	/**
	 * Trigger updating of the main sync icon, the sync error icon, and
	 * library-specific sync error icons across all windows
	 */
	this.addError = function (e, libraryID) {
		if (e.added) return;
		e.added = true;
		if (libraryID) {
			e.libraryID = libraryID;
		}
		Zotero.logError(e);
		_errors.push(this.parseError(e));
	}
	
	
	this.getErrorsByLibrary = function (libraryID) {
		return _errors.filter(e => e.libraryID === libraryID);
	}
	
	
	/**
	 * Get most severe error type from an array of parsed errors
	 */
	this.getPrimaryErrorType = function (errors) {
		// Set highest priority error as the primary (sync error icon)
		var errorTypes = {
			info: 1,
			warning: 2,
			error: 3,
			upgrade: 4,
			
			// Skip these
			animate: -1,
			ignore: -2
		};
		var state = false;
		for (let i = 0; i < errors.length; i++) {
			let e = errors[i];
			
			let errorType = e.errorType;
				
			if (e.fatal) {
				return 'error';
			}
			
			if (!errorType || errorTypes[errorType] < 0) {
				continue;
			}
			if (!state || errorTypes[errorType] > errorTypes[state]) {
				state = errorType;
			}
		}
		return state;
	}
	
	
	this.checkErrors = Zotero.Promise.coroutine(function* (errors, options = {}) {
		for (let e of errors) {
			let handled = yield this.checkError(e, options);
			if (handled) {
				break;
			}
		}
	});
	
	
	this.checkError = Zotero.Promise.coroutine(function* (e, options = {}) {
		if (e.name && e.name == 'Zotero Error') {
			switch (e.error) {
				case Zotero.Error.ERROR_API_KEY_NOT_SET:
				case Zotero.Error.ERROR_API_KEY_INVALID:
					// TODO: the setTimeout() call below should just simulate a click on the sync error icon
					// instead of creating its own dialog, but updateIcons() doesn't yet provide full control
					// over dialog title and primary button text/action, which is why this version of the
					// dialog is a bit uglier than the manual click version
					// TODO: localize (=>done) and combine with below (=>?)
					var msg = Zotero.getString('sync.error.invalidLogin.text');
					e.message = msg;
					e.dialogButtonText = Zotero.getString('sync.openSyncPreferences');
					e.dialogButtonCallback = function () {
						var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
								.getService(Components.interfaces.nsIWindowMediator);
						var win = wm.getMostRecentWindow("navigator:browser");
						win.ZoteroPane.openPreferences("zotero-prefpane-sync");
					};
					
					// Manual click
					if (!options.background) {
						setTimeout(function () {
							var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
										.getService(Components.interfaces.nsIWindowMediator);
							var win = wm.getMostRecentWindow("navigator:browser");
							
							var ps = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
										.getService(Components.interfaces.nsIPromptService);
							var buttonFlags = (ps.BUTTON_POS_0) * (ps.BUTTON_TITLE_IS_STRING)
												+ (ps.BUTTON_POS_1) * (ps.BUTTON_TITLE_CANCEL);
							if (e.error == Zotero.Error.ERROR_API_KEY_NOT_SET) {
								var title = Zotero.getString('sync.error.usernameNotSet');
								var msg = Zotero.getString('sync.error.usernameNotSet.text');
							}
							else {
								var title = Zotero.getString('sync.error.invalidLogin');
								var msg = Zotero.getString('sync.error.invalidLogin.text');
							}
							var index = ps.confirmEx(
								win,
								title,
								msg,
								buttonFlags,
								Zotero.getString('sync.openSyncPreferences'),
								null, null, null, {}
							);
							
							if (index == 0) {
								Zotero.Utilities.Internal.openPreferences("zotero-prefpane-sync");
								return;
							}
						}, 1);
					}
					break;
			}
		}
		else if (e.name && e.name == 'ZoteroObjectUploadError') {
			let { code, data, objectType, object } = e;
			
			if (code == 413) {
				// Collection name too long
				if (objectType == 'collection' && data && data.value) {
					e.message = Zotero.getString('sync.error.collectionTooLong', [data.value]);
					
					e.dialogButtonText = Zotero.getString('pane.collections.showCollectionInLibrary');
					e.dialogButtonCallback = () => {
						var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
							.getService(Components.interfaces.nsIWindowMediator);
						var win = wm.getMostRecentWindow("navigator:browser");
						win.ZoteroPane.collectionsView.selectCollection(object.id);
					};
				}
				else if (objectType == 'item') {
					// Tag too long
					if (data && data.tag !== undefined) {
						// Show long tag fixer and handle result
						e.dialogButtonText = Zotero.getString('general.fix');
						e.dialogButtonCallback = Zotero.Promise.coroutine(function* () {
							var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
							   .getService(Components.interfaces.nsIWindowMediator);
							var lastWin = wm.getMostRecentWindow("navigator:browser");
							
							// Open long tag fixer for every long tag in every editable library we're syncing
							var editableLibraries = options.libraries
								.filter(x => Zotero.Libraries.get(x).editable);
							for (let libraryID of editableLibraries) {
								let oldTagIDs = yield Zotero.Tags.getLongTagsInLibrary(libraryID);
								for (let oldTagID of oldTagIDs) {
									let oldTag = Zotero.Tags.getName(oldTagID);
									let dataOut = { result: null };
									lastWin.openDialog(
										'chrome://zotero/content/longTagFixer.xul',
										'',
										'chrome,modal,centerscreen',
										oldTag,
										dataOut
									);
									// If dialog was cancelled, stop
									if (!dataOut.result) {
										return;
									}
									switch (dataOut.result.op) {
									case 'split':
										for (let libraryID of editableLibraries) {
											let itemIDs = yield Zotero.Tags.getTagItems(libraryID, oldTagID);
											yield Zotero.DB.executeTransaction(async function () {
												for (let itemID of itemIDs) {
													let item = await Zotero.Items.getAsync(itemID);
													for (let tag of dataOut.result.tags) {
														item.addTag(tag);
													}
													item.removeTag(oldTag);
													await item.save();
												}
												await Zotero.Tags.purge(oldTagID);
											});
										}
										break;
									
									case 'edit':
										for (let libraryID of editableLibraries) {
											let itemIDs = yield Zotero.Tags.getTagItems(libraryID, oldTagID);
											yield Zotero.DB.executeTransaction(async function () {
												for (let itemID of itemIDs) {
													let item = await Zotero.Items.getAsync(itemID);
													item.replaceTag(oldTag, dataOut.result.tag);
													await item.save();
												}
											});
										}
										break;
									
									case 'delete':
										for (let libraryID of editableLibraries) {
											yield Zotero.Tags.removeFromLibrary(libraryID, oldTagID);
										}
										break;
									}
								}
							}
							
							options.restartSync = true;
						});
					}
					else {
						// Note too long
						if (object.isNote() || object.isAttachment()) {
							// Throw an error that adds a button for selecting the item to the sync error dialog
							if (e.message.includes('<img src="data:image')) {
								e.message = Zotero.getString('sync.error.noteEmbeddedImage');
							}
							else if (e.message.match(/^Note '.*' too long for item/)) {
								e.message = Zotero.getString(
									'sync.error.noteTooLong',
									Zotero.Utilities.ellipsize(object.getNoteTitle(), 40)
								);
							}
						}
						// Field or creator too long
						else if (data && data.field) {
							e.message = (data.field == 'creator'
								? Zotero.getString(
									'sync.error.creatorTooLong',
									[data.value]
								)
								: Zotero.getString(
									'sync.error.fieldTooLong',
									[data.field, data.value]
								))
								+ '\n\n'
								+ Zotero.getString(
									'sync.error.reportSiteIssuesToForums',
									Zotero.clientName
								);
						}
						
						// Include "Show Item in Library" button
						e.dialogButtonText = Zotero.getString('pane.items.showItemInLibrary');
						e.dialogButtonCallback = () => {
							var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
								.getService(Components.interfaces.nsIWindowMediator);
							var win = wm.getMostRecentWindow("navigator:browser");
							win.ZoteroPane.selectItem(object.id);
						};
					}
				}
				
				// If not a background sync, show dialog immediately
				if (!options.background && e.dialogButtonCallback) {
					let maybePromise = e.dialogButtonCallback();
					if (maybePromise && maybePromise.then) {
						yield maybePromise;
					}
				}
			}
		}
		// Show warning for unknown data that couldn't be saved
		else if (e.name && e.name == 'ZoteroInvalidDataError') {
			let library = Zotero.Libraries.get(e.libraryID);
			let msg = Zotero.getString(
					'sync.error.invalidDataError',
					[
						library.name,
						Zotero.clientName
					]
				)
					+ "\n\n"
					+ Zotero.getString('sync.error.invalidDataError.otherData');
			
			// Show warning for My Library
			if (library.libraryType == 'user') {
				e.message = msg;
				e.errorType = 'warning';
				e.dialogButtonText = Zotero.getString('general.checkForUpdates');
				e.dialogButtonCallback = () => {
					Zotero.openCheckForUpdatesWindow();
				};
				e.dialogButton2Text = Zotero.getString('general.moreInformation');
				e.dialogButton2Callback = () => {
					Zotero.launchURL('https://www.zotero.org/support/kb/unknown_data_error');
				};
			}
			// Otherwise just show in sync button tooltip
			else {
				_addTooltipMessage(msg);
				e.errorType = 'ignore';
			}
		}
	});
	
	
	/**
	 * Set the sync icon and sync error icon across all windows
	 *
	 * @param {Error|Error[]|'animate'} errors - An error, an array of errors, or 'animate' to
	 *                                           spin the icon. An empty array will reset the
	 *                                           icons.
	 */
	this.updateIcons = function (errors) {
		if (typeof errors == 'string') {
			var state = errors;
			errors = [];
		}
		else {
			if (!Array.isArray(errors)) {
				errors = [errors];
			}
			errors = errors.filter(o => o.errorType !== 'ignore');
			var state = this.getPrimaryErrorType(errors);
		}
		
		// Refresh source list
		//yield Zotero.Notifier.trigger('redraw', 'collection', []);
		
		if (errors.length == 1 && errors[0].frontWindowOnly) {
			// Fake an nsISimpleEnumerator with just the topmost window
			var enumerator = {
				_returned: false,
				hasMoreElements: function () {
					return !this._returned;
				},
				getNext: function () {
					if (this._returned) {
						throw ("No more windows to return in Zotero.Sync.Runner.updateIcons()");
					}
					this._returned = true;
					var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
								.getService(Components.interfaces.nsIWindowMediator);
					return wm.getMostRecentWindow("navigator:browser");
				}
			};
		}
		// Update all windows
		else {
			var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
						.getService(Components.interfaces.nsIWindowMediator);
			var enumerator = wm.getEnumerator('navigator:browser');
		}
		
		while (enumerator.hasMoreElements()) {
			var win = enumerator.getNext();
			if (!win.ZoteroPane) continue;
			var doc = win.ZoteroPane.document;
			
			// Update sync error icon
			var icon = doc.getElementById('zotero-tb-sync-error');
			this.updateErrorIcon(icon, state, errors);
			
			// Update sync icon
			var syncIcon = doc.getElementById('zotero-tb-sync');
			var stopIcon = doc.getElementById('zotero-tb-sync-stop');
			if (state == 'animate') {
				syncIcon.setAttribute('status', state);
				// Disable button while spinning
				syncIcon.disabled = true;
				stopIcon.hidden = false;
			}
			else {
				syncIcon.removeAttribute('status');
				syncIcon.disabled = false;
				stopIcon.hidden = true;
			}
		}
		
		// Clear status
		this.setSyncStatus();
	}
	
	
	/**
	 * Set the sync icon tooltip message
	 */
	this.setSyncStatus = function (msg) {
		_lastSyncStatus = msg;
		
		// If a label is registered, update it
		if (_currentSyncStatusLabel) {
			_updateSyncStatusLabel();
		}
	}
	
	
	this.parseError = function (e) {
		if (!e) {
			return { parsed: true };
		}
		
		// Already parsed
		if (e.parsed) {
			return e;
		}
		
		e.parsed = true;
		e.errorType = e.errorType ? e.errorType : 'error';
		
		return e;
	}
	
	
	/**
	 * Set the state of the sync error icon and add an onclick to populate
	 * the error panel
	 */
	this.updateErrorIcon = function (icon, state, errors) {
		if (!errors || !errors.length) {
			icon.hidden = true;
			icon.onclick = null;
			return;
		}
		
		icon.hidden = false;
		icon.setAttribute('state', state);
		var self = this;
		icon.onclick = function () {
			var panel = self.updateErrorPanel(this.ownerDocument, errors);
			panel.openPopup(this, "after_end", 16, 0, false, false);
		};
	}
	
	
	this.updateErrorPanel = function (doc, errors) {
		var panel = doc.getElementById('zotero-sync-error-panel');
		
		// Clear existing panel content
		while (panel.hasChildNodes()) {
			panel.removeChild(panel.firstChild);
		}
		
		for (let e of errors) {
			var box = doc.createElement('vbox');
			var label = doc.createElement('label');
			if (e.libraryID !== undefined) {
				label.className = "zotero-sync-error-panel-library-name";
				if (e.libraryID == 0) {
					var libraryName = Zotero.getString('pane.collections.library');
				}
				else {
					let group = Zotero.Groups.getByLibraryID(e.libraryID);
					var libraryName = group.name;
				}
				label.setAttribute('value', libraryName);
			}
			var content = doc.createElement('vbox');
			var buttons = doc.createElement('hbox');
			buttons.pack = 'end';
			box.appendChild(label);
			box.appendChild(content);
			box.appendChild(buttons);
			
			if (e.dialogHeader) {
				let header = doc.createElement('description');
				header.className = 'error-header';
				header.textContent = e.dialogHeader;
				content.appendChild(header);
			}
			
			// Show our own error messages directly
			var msg;
			if (e instanceof Zotero.Error) {
				msg = e.message;
			}
			// For unexpected ones, just show a generic message
			else if (e instanceof Zotero.HTTP.UnexpectedStatusException && e.xmlhttp.responseText) {
				msg = Zotero.Utilities.ellipsize(e.xmlhttp.responseText, 1000, true);
			}
			else {
				msg = e.message;
			}
			
			var desc = doc.createElement('description');
			desc.textContent = msg;
			// Make the text selectable
			desc.setAttribute('style', '-moz-user-select: text; cursor: text');
			content.appendChild(desc);
			
			/*// If not an error and there's no explicit button text, don't show
			// button to report errors
			if (e.errorType != 'error' && e.dialogButtonText === undefined) {
				e.dialogButtonText = null;
			}*/
			
			if (e.dialogButtonText !== null) {
				if (e.dialogButtonText === undefined) {
					var buttonText = Zotero.getString('errorReport.reportError');
					var buttonCallback = function () {
						doc.defaultView.ZoteroPane.reportErrors();
					};
				}
				else {
					var buttonText = e.dialogButtonText;
					var buttonCallback = e.dialogButtonCallback;
				}
				
				let button = doc.createElement('button');
				button.setAttribute('label', buttonText);
				button.onclick = function () {
					buttonCallback();
					panel.hidePopup();
				};
				buttons.appendChild(button);
				
				// Second button
				if (e.dialogButton2Text) {
					buttonText = e.dialogButton2Text;
					buttonCallback = e.dialogButton2Callback;
					
					let button2 = doc.createElement('button');
					button2.setAttribute('label', buttonText);
					button2.onclick = () => {
						buttonCallback();
						panel.hidePopup();
					};
					buttons.insertBefore(button2, button);
				}
			}
			
			panel.appendChild(box)
			break;
		}
		
		return panel;
	}
	
	
	/**
	 * Register labels in sync icon tooltip to receive updates
	 *
	 * If no label passed, unregister current label
	 *
	 * @param {Tooltip} [tooltip]
	 */
	this.registerSyncStatus = function (tooltip) {
		if (tooltip) {
			_currentSyncStatusLabel = tooltip.firstChild.nextSibling;
			_currentLastSyncLabel = tooltip.firstChild.nextSibling.nextSibling;
			_currentTooltipMessages = tooltip.querySelector('.sync-button-tooltip-messages');
		}
		else {
			_currentSyncStatusLabel = null;
			_currentLastSyncLabel = null;
			_currentTooltipMessages = null;
		}
		if (_currentSyncStatusLabel) {
			_updateSyncStatusLabel();
		}
	}


	this.createAPIKeyFromCredentials = Zotero.Promise.coroutine(function* (username, password) {
		var client = this.getAPIClient();
		var json = yield client.createAPIKeyFromCredentials(username, password);
		if (!json) {
			return false;
		}

		// Sanity check
		if (!json.userID) throw new Error("userID not found in key response");
		if (!json.username) throw new Error("username not found in key response");
		if (!json.access) throw new Error("'access' not found in key response");

		Zotero.Sync.Data.Local.setAPIKey(json.key);

		return json;
	})


	this.deleteAPIKey = Zotero.Promise.coroutine(function* (){
		var apiKey = yield Zotero.Sync.Data.Local.getAPIKey();
		var client = this.getAPIClient({apiKey});
		Zotero.Sync.Data.Local.setAPIKey();
		yield client.deleteAPIKey();
	})
	
	
	function _addTooltipMessage(msg) {
		_tooltipMessages.push(msg.replace(/\n+/g, ' '));
	};
	
	
	function _updateSyncStatusLabel() {
		if (_lastSyncStatus) {
			_currentSyncStatusLabel.value = _lastSyncStatus;
			_currentSyncStatusLabel.hidden = false;
		}
		else {
			_currentSyncStatusLabel.hidden = true;
		}
		
		// Always update last sync time
		var lastSyncTime = Zotero.Sync.Data.Local.getLastSyncTime();
		if (!lastSyncTime) {
			try {
				lastSyncTime = Zotero.Sync.Data.Local.getLastClassicSyncTime();
			}
			catch (e) {
				Zotero.debug(e, 2);
				Components.utils.reportError(e);
				_currentLastSyncLabel.hidden = true;
				return;
			}
		}
		if (lastSyncTime) {
			var msg = Zotero.Date.toRelativeDate(lastSyncTime);
		}
		// Don't show "Not yet synced" if a sync is in progress
		else if (_syncInProgress) {
			_currentLastSyncLabel.hidden = true;
			return;
		}
		else {
			var msg = Zotero.getString('sync.status.notYetSynced');
		}
		
		_currentLastSyncLabel.value = Zotero.getString('sync.status.lastSync') + " " + msg;
		_currentLastSyncLabel.hidden = false;
		
		if (_tooltipMessages.length) {
			_currentTooltipMessages.textContent = '';
			for (let message of _tooltipMessages) {
				let elem = _currentTooltipMessages.ownerDocument.createElementNS(HTML_NS, 'p');
				elem.textContent = message;
				_currentTooltipMessages.appendChild(elem);
			}
			_currentTooltipMessages.hidden = false;
		}
		else {
			_currentTooltipMessages.hidden = true;
		}
	}
	
	
	var _getAPIKey = Zotero.Promise.method(function () {
		// Set as .apiKey on Runner in tests or set in login manager
		return _apiKey || Zotero.Sync.Data.Local.getAPIKey()
	})
	
	
	function _stopCheck() {
		if (_stopping) {
			throw new Zotero.Sync.UserCancelledException;
		}
	}
	
	
	function _cancellerReceiver(canceller) {
		_canceller = canceller;
	}
}