Fix #85618

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -53,7 +53,7 @@ import { IProductService } from 'vs/platform/product/common/productService';
 import { IUserDataSyncService, IUserDataSyncStoreService, registerConfiguration, IUserDataSyncLogService, IUserDataSyncUtilService, ISettingsSyncService, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
 import { UserDataSyncService } from 'vs/platform/userDataSync/common/userDataSyncService';
 import { UserDataSyncStoreService } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
-import { UserDataSyncChannel, UserDataSyncUtilServiceClient, SettingsSyncChannel, UserDataAuthTokenServiceChannel } from 'vs/platform/userDataSync/common/userDataSyncIpc';
+import { UserDataSyncChannel, UserDataSyncUtilServiceClient, SettingsSyncChannel, UserDataAuthTokenServiceChannel, UserDataAutoSyncChannel } from 'vs/platform/userDataSync/common/userDataSyncIpc';
 import { IElectronService } from 'vs/platform/electron/node/electron';
 import { LoggerService } from 'vs/platform/log/node/loggerService';
 import { UserDataSyncLogService } from 'vs/platform/userDataSync/common/userDataSyncLog';
@@ -217,6 +217,10 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 			const userDataSyncChannel = new UserDataSyncChannel(userDataSyncService);
 			server.registerChannel('userDataSync', userDataSyncChannel);
 
+			const userDataAutoSync = instantiationService2.createInstance(UserDataAutoSync);
+			const userDataAutoSyncChannel = new UserDataAutoSyncChannel(userDataAutoSync);
+			server.registerChannel('userDataAutoSync', userDataAutoSyncChannel);
+
 			// clean up deprecated extensions
 			(extensionManagementService as ExtensionManagementService).removeDeprecatedExtensions();
 			// update localizations cache
@@ -227,7 +231,7 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 				instantiationService2.createInstance(LanguagePackCachedDataCleaner),
 				instantiationService2.createInstance(StorageDataCleaner),
 				instantiationService2.createInstance(LogsDataCleaner),
-				instantiationService2.createInstance(UserDataAutoSync)
+				userDataAutoSync
 			));
 			disposables.add(extensionManagementService as ExtensionManagementService);
 		});

src/vs/platform/userDataSync/common/extensionsSync.ts

@@ -192,6 +192,12 @@ export class ExtensionsSynchroniser extends Disposable implements ISynchroniser
 		});
 	}
 
+	async resetLocal(): Promise<void> {
+		try {
+			await this.fileService.del(this.lastSyncExtensionsResource);
+		} catch (e) { /* ignore */ }
+	}
+
 	private async getPreview(): Promise<ISyncPreviewResult> {
 		const lastSyncData = await this.getLastSyncUserData();
 		const lastSyncExtensions: ISyncExtension[] | null = lastSyncData ? JSON.parse(lastSyncData.content!) : null;

src/vs/platform/userDataSync/common/globalStateSync.ts

@@ -155,6 +155,12 @@ export class GlobalStateSynchroniser extends Disposable implements ISynchroniser
 		return remoteUserData.content !== null;
 	}
 
+	async resetLocal(): Promise<void> {
+		try {
+			await this.fileService.del(this.lastSyncGlobalStateResource);
+		} catch (e) { /* ignore */ }
+	}
+
 	private async getPreview(): Promise<ISyncPreviewResult> {
 		const lastSyncData = await this.getLastSyncUserData();
 		const lastSyncGlobalState = lastSyncData && lastSyncData.content ? JSON.parse(lastSyncData.content) : null;

src/vs/platform/userDataSync/common/keybindingsSync.ts

@@ -219,6 +219,12 @@ export class KeybindingsSynchroniser extends Disposable implements ISynchroniser
 		return remoteUserData.content !== null;
 	}
 
+	async resetLocal(): Promise<void> {
+		try {
+			await this.fileService.del(this.lastSyncKeybindingsResource);
+		} catch (e) { /* ignore */ }
+	}
+
 	private async continueSync(): Promise<boolean> {
 		if (this.status !== SyncStatus.HasConflicts) {
 			return false;

src/vs/platform/userDataSync/common/settingsSync.ts

@@ -220,6 +220,12 @@ export class SettingsSynchroniser extends Disposable implements ISettingsSyncSer
 		}
 	}
 
+	async resetLocal(): Promise<void> {
+		try {
+			await this.fileService.del(this.lastSyncSettingsResource);
+		} catch (e) { /* ignore */ }
+	}
+
 	private async doSync(resolvedConflicts: { key: string, value: any | undefined }[]): Promise<boolean> {
 		try {
 			const result = await this.getPreview(resolvedConflicts);

src/vs/platform/userDataSync/common/userDataAutoSync.ts

@@ -7,9 +7,11 @@ import { timeout } from 'vs/base/common/async';
 import { Event } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { IUserDataSyncLogService, IUserDataSyncService, SyncStatus, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncLogService, IUserDataSyncService, SyncStatus, IUserDataAuthTokenService, IUserDataAutoSyncService, IUserDataSyncUtilService } from 'vs/platform/userDataSync/common/userDataSync';
 
-export class UserDataAutoSync extends Disposable {
+export class UserDataAutoSync extends Disposable implements IUserDataAutoSyncService {
+
+	_serviceBrand: any;
 
 	private enabled: boolean = false;
 
@@ -18,15 +20,16 @@ export class UserDataAutoSync extends Disposable {
 		@IUserDataSyncService private readonly userDataSyncService: IUserDataSyncService,
 		@IUserDataSyncLogService private readonly logService: IUserDataSyncLogService,
 		@IUserDataAuthTokenService private readonly userDataAuthTokenService: IUserDataAuthTokenService,
+		@IUserDataSyncUtilService private readonly userDataSyncUtilService: IUserDataSyncUtilService,
 	) {
 		super();
-		this.updateEnablement(false);
-		this._register(Event.any<any>(userDataAuthTokenService.onDidChangeToken)(() => this.updateEnablement(true)));
-		this._register(Event.any<any>(userDataSyncService.onDidChangeStatus)(() => this.updateEnablement(true)));
-		this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('sync.enable'))(() => this.updateEnablement(true)));
+		this.updateEnablement(false, true);
+		this._register(Event.any<any>(userDataAuthTokenService.onDidChangeToken)(() => this.updateEnablement(true, true)));
+		this._register(Event.any<any>(userDataSyncService.onDidChangeStatus)(() => this.updateEnablement(true, true)));
+		this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('sync.enable'))(() => this.updateEnablement(true, false)));
 	}
 
-	private async updateEnablement(stopIfDisabled: boolean): Promise<void> {
+	private async updateEnablement(stopIfDisabled: boolean, auto: boolean): Promise<void> {
 		const enabled = await this.isSyncEnabled();
 		if (this.enabled === enabled) {
 			return;
@@ -35,7 +38,7 @@ export class UserDataAutoSync extends Disposable {
 		this.enabled = enabled;
 		if (this.enabled) {
 			this.logService.info('Syncing configuration started');
-			this.sync(true);
+			this.sync(true, auto);
 			return;
 		} else {
 			if (stopIfDisabled) {
@@ -46,24 +49,42 @@ export class UserDataAutoSync extends Disposable {
 
 	}
 
-	protected async sync(loop: boolean): Promise<void> {
+	private async sync(loop: boolean, auto: boolean): Promise<void> {
 		if (this.enabled) {
 			try {
+				if (auto) {
+					if (await this.isTurnedOffEverywhere()) {
+						// Turned off everywhere. Reset & Stop Sync.
+						await this.userDataSyncService.resetLocal();
+						await this.userDataSyncUtilService.updateConfigurationValue('sync.enable', false);
+						return;
+					}
+				}
 				await this.userDataSyncService.sync();
 			} catch (e) {
 				this.logService.error(e);
 			}
 			if (loop) {
 				await timeout(1000 * 60 * 5); // Loop sync for every 5 min.
-				this.sync(loop);
+				this.sync(loop, true);
 			}
 		}
 	}
 
+	private async isTurnedOffEverywhere(): Promise<boolean> {
+		const hasRemote = await this.userDataSyncService.hasRemote();
+		const hasPreviouslySynced = await this.userDataSyncService.hasPreviouslySynced();
+		return !hasRemote && hasPreviouslySynced;
+	}
+
 	private async isSyncEnabled(): Promise<boolean> {
 		return this.configurationService.getValue<boolean>('sync.enable')
 			&& this.userDataSyncService.status !== SyncStatus.Uninitialized
 			&& !!(await this.userDataAuthTokenService.getToken());
 	}
 
+	triggerAutoSync(): Promise<void> {
+		return this.sync(false, true);
+	}
+
 }

src/vs/platform/userDataSync/common/userDataSync.ts

@@ -153,6 +153,7 @@ export interface IUserDataSyncStoreService {
 	readonly userDataSyncStore: IUserDataSyncStore | undefined;
 	read(key: string, oldValue: IUserData | null): Promise<IUserData>;
 	write(key: string, content: string, ref: string | null): Promise<string>;
+	clear(): Promise<void>;
 }
 
 export interface ISyncExtension {
@@ -190,18 +191,28 @@ export interface ISynchroniser {
 	stop(): void;
 	hasPreviouslySynced(): Promise<boolean>
 	hasRemote(): Promise<boolean>;
+	resetLocal(): Promise<void>;
 }
 
 export const IUserDataSyncService = createDecorator<IUserDataSyncService>('IUserDataSyncService');
 export interface IUserDataSyncService extends ISynchroniser {
 	_serviceBrand: any;
 	readonly conflictsSource: SyncSource | null;
+	reset(): Promise<void>;
+	resetLocal(): Promise<void>;
 	removeExtension(identifier: IExtensionIdentifier): Promise<void>;
 }
 
+export const IUserDataAutoSyncService = createDecorator<IUserDataAutoSyncService>('IUserDataAutoSyncService');
+export interface IUserDataAutoSyncService {
+	_serviceBrand: any;
+	triggerAutoSync(): Promise<void>;
+}
+
 export const IUserDataSyncUtilService = createDecorator<IUserDataSyncUtilService>('IUserDataSyncUtilService');
 export interface IUserDataSyncUtilService {
 	_serviceBrand: undefined;
+	updateConfigurationValue(key: string, value: any): Promise<void>;
 	resolveUserBindings(userbindings: string[]): Promise<IStringDictionary<string>>;
 	resolveFormattingOptions(resource: URI): Promise<FormattingOptions>;
 }

src/vs/platform/userDataSync/common/userDataSyncIpc.ts

@@ -5,7 +5,7 @@
 
 import { IServerChannel, IChannel } from 'vs/base/parts/ipc/common/ipc';
 import { Event } from 'vs/base/common/event';
-import { IUserDataSyncService, IUserDataSyncUtilService, ISettingsSyncService, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncService, IUserDataSyncUtilService, ISettingsSyncService, IUserDataAuthTokenService, IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
 import { URI } from 'vs/base/common/uri';
 import { IStringDictionary } from 'vs/base/common/collections';
 import { FormattingOptions } from 'vs/base/common/jsonFormatter';
@@ -31,6 +31,8 @@ export class UserDataSyncChannel implements IServerChannel {
 			case 'getConflictsSource': return Promise.resolve(this.service.conflictsSource);
 			case 'removeExtension': return this.service.removeExtension(args[0]);
 			case 'stop': this.service.stop(); return Promise.resolve();
+			case 'reset': return this.service.reset();
+			case 'resetLocal': return this.service.resetLocal();
 			case 'hasPreviouslySynced': return this.service.hasPreviouslySynced();
 			case 'hasRemote': return this.service.hasRemote();
 		}
@@ -59,6 +61,7 @@ export class SettingsSyncChannel implements IServerChannel {
 			case '_getInitialStatus': return Promise.resolve(this.service.status);
 			case '_getInitialConflicts': return Promise.resolve(this.service.conflicts);
 			case 'stop': this.service.stop(); return Promise.resolve();
+			case 'resetLocal': return this.service.resetLocal();
 			case 'hasPreviouslySynced': return this.service.hasPreviouslySynced();
 			case 'hasRemote': return this.service.hasRemote();
 			case 'resolveConflicts': return this.service.resolveConflicts(args[0]);
@@ -67,6 +70,22 @@ export class SettingsSyncChannel implements IServerChannel {
 	}
 }
 
+export class UserDataAutoSyncChannel implements IServerChannel {
+
+	constructor(private readonly service: IUserDataAutoSyncService) { }
+
+	listen(_: unknown, event: string): Event<any> {
+		throw new Error(`Event not found: ${event}`);
+	}
+
+	call(context: any, command: string, args?: any): Promise<any> {
+		switch (command) {
+			case 'triggerAutoSync': return this.service.triggerAutoSync();
+		}
+		throw new Error('Invalid call');
+	}
+}
+
 export class UserDataAuthTokenServiceChannel implements IServerChannel {
 	constructor(private readonly service: IUserDataAuthTokenService) { }
 
@@ -98,6 +117,7 @@ export class UserDataSycnUtilServiceChannel implements IServerChannel {
 		switch (command) {
 			case 'resolveUserKeybindings': return this.service.resolveUserBindings(args[0]);
 			case 'resolveFormattingOptions': return this.service.resolveFormattingOptions(URI.revive(args[0]));
+			case 'updateConfigurationValue': return this.service.updateConfigurationValue(args[0], args[1]);
 		}
 		throw new Error('Invalid call');
 	}
@@ -118,5 +138,9 @@ export class UserDataSyncUtilServiceClient implements IUserDataSyncUtilService {
 		return this.channel.call('resolveFormattingOptions', [file]);
 	}
 
+	async updateConfigurationValue(key: string, value: any): Promise<void> {
+		return this.channel.call('updateConfigurationValue', [key, value]);
+	}
+
 }
 

src/vs/platform/userDataSync/common/userDataSyncService.ts

@@ -146,6 +146,43 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
 		return false;
 	}
 
+	async reset(): Promise<void> {
+		await this.resetRemote();
+		await this.resetLocal();
+	}
+
+	private async resetRemote(): Promise<void> {
+		if (!this.userDataSyncStoreService.userDataSyncStore) {
+			throw new Error('Not enabled');
+		}
+		if (!(await this.userDataAuthTokenService.getToken())) {
+			throw new Error('Not Authenticated. Please sign in to start sync.');
+		}
+		try {
+			await this.userDataSyncStoreService.clear();
+			this.logService.info('Completed clearing remote data');
+		} catch (e) {
+			this.logService.error(e);
+		}
+	}
+
+	async resetLocal(): Promise<void> {
+		if (!this.userDataSyncStoreService.userDataSyncStore) {
+			throw new Error('Not enabled');
+		}
+		if (!(await this.userDataAuthTokenService.getToken())) {
+			throw new Error('Not Authenticated. Please sign in to start sync.');
+		}
+		for (const synchroniser of this.synchronisers) {
+			try {
+				await synchroniser.resetLocal();
+			} catch (e) {
+				this.logService.error(`${this.getSyncSource(synchroniser)}: ${toErrorMessage(e)}`);
+			}
+		}
+		this.logService.info('Completed resetting local cache');
+	}
+
 	removeExtension(identifier: IExtensionIdentifier): Promise<void> {
 		return this.extensionsSynchroniser.removeExtension(identifier);
 	}

src/vs/platform/userDataSync/common/userDataSyncStoreService.ts

@@ -88,6 +88,21 @@ export class UserDataSyncStoreService extends Disposable implements IUserDataSyn
 		return newRef;
 	}
 
+	async clear(): Promise<void> {
+		if (!this.userDataSyncStore) {
+			throw new Error('No settings sync store url configured.');
+		}
+
+		const url = joinPath(URI.parse(this.userDataSyncStore.url), 'resource').toString();
+		const headers: IHeaders = { 'Content-Type': 'text/plain' };
+
+		const context = await this.request({ type: 'DELETE', url, headers }, CancellationToken.None);
+
+		if (!isSuccess(context)) {
+			throw new Error('Server returned ' + context.res.statusCode);
+		}
+	}
+
 	private async request(options: IRequestOptions, token: CancellationToken): Promise<IRequestContext> {
 		const authToken = await this.authTokenService.getToken();
 		if (!authToken) {

src/vs/platform/userDataSync/electron-browser/userDataAutoSync.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IUserDataSyncService, IUserDataSyncLogService, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncService, IUserDataSyncLogService, IUserDataAuthTokenService, IUserDataSyncUtilService } from 'vs/platform/userDataSync/common/userDataSync';
 import { Event } from 'vs/base/common/event';
 import { IElectronService } from 'vs/platform/electron/node/electron';
 import { UserDataAutoSync as BaseUserDataAutoSync } from 'vs/platform/userDataSync/common/userDataAutoSync';
@@ -17,15 +17,16 @@ export class UserDataAutoSync extends BaseUserDataAutoSync {
 		@IConfigurationService configurationService: IConfigurationService,
 		@IUserDataSyncLogService logService: IUserDataSyncLogService,
 		@IUserDataAuthTokenService authTokenService: IUserDataAuthTokenService,
+		@IUserDataSyncUtilService userDataSyncUtilService: IUserDataSyncUtilService,
 	) {
-		super(configurationService, userDataSyncService, logService, authTokenService);
+		super(configurationService, userDataSyncService, logService, authTokenService, userDataSyncUtilService);
 
 		// Sync immediately if there is a local change.
 		this._register(Event.debounce(Event.any<any>(
 			electronService.onWindowFocus,
 			electronService.onWindowOpen,
-			userDataSyncService.onDidChangeLocal
-		), () => undefined, 500)(() => this.sync(false)));
+			userDataSyncService.onDidChangeLocal,
+		), () => undefined, 500)(() => this.triggerAutoSync()));
 	}
 
 }

src/vs/platform/userDataSync/test/common/keybindingsMerge.test.ts

@@ -731,4 +731,6 @@ class MockUserDataSyncUtilService implements IUserDataSyncUtilService {
 	async resolveFormattingOptions(file?: URI): Promise<FormattingOptions> {
 		return { eol: '\n', insertSpaces: false, tabSize: 4 };
 	}
+
+	async updateConfigurationValue(key: string, value: any): Promise<void> { }
 }

src/vs/workbench/contrib/userDataSync/browser/userDataAutoSync.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IUserDataSyncService, IUserDataSyncLogService, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncService, IUserDataSyncLogService, IUserDataAuthTokenService, IUserDataSyncUtilService } from 'vs/platform/userDataSync/common/userDataSync';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { Event } from 'vs/base/common/event';
 import { UserDataAutoSync as BaseUserDataAutoSync } from 'vs/platform/userDataSync/common/userDataAutoSync';
@@ -20,15 +20,16 @@ export class UserDataAutoSync extends BaseUserDataAutoSync {
 		@IUserDataAuthTokenService authTokenService: IUserDataAuthTokenService,
 		@IInstantiationService instantiationService: IInstantiationService,
 		@IHostService hostService: IHostService,
+		@IUserDataSyncUtilService userDataSyncUtilService: IUserDataSyncUtilService,
 	) {
-		super(configurationService, userDataSyncService, logService, authTokenService);
+		super(configurationService, userDataSyncService, logService, authTokenService, userDataSyncUtilService);
 
 		// Sync immediately if there is a local change.
 		this._register(Event.debounce(Event.any<any>(
 			userDataSyncService.onDidChangeLocal,
 			instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync,
 			hostService.onDidChangeFocus
-		), () => undefined, 500)(() => this.sync(false)));
+		), () => undefined, 500)(() => this.triggerAutoSync()));
 	}
 
 }

src/vs/workbench/contrib/userDataSync/browser/userDataSync.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
-import { IUserDataSyncService, SyncStatus, SyncSource, CONTEXT_SYNC_STATE, IUserDataSyncStore, registerConfiguration, getUserDataSyncStore, ISyncConfiguration, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncService, SyncStatus, SyncSource, CONTEXT_SYNC_STATE, IUserDataSyncStore, registerConfiguration, getUserDataSyncStore, ISyncConfiguration, IUserDataAuthTokenService, IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
 import { localize } from 'vs/nls';
 import { Disposable, MutableDisposable, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
@@ -76,6 +76,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 		@IInstantiationService instantiationService: IInstantiationService,
 		@IOutputService private readonly outputService: IOutputService,
 		@IUserDataAuthTokenService private readonly userDataAuthTokenService: IUserDataAuthTokenService,
+		@IUserDataAutoSyncService userDataAutoSyncService: IUserDataAutoSyncService,
 	) {
 		super();
 		this.userDataSyncStore = getUserDataSyncStore(configurationService);
@@ -94,20 +95,12 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 				if (isWeb) {
 					this._register(instantiationService.createInstance(UserDataAutoSync));
 				} else {
-					this._register(instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync(() => this.triggerSync()));
+					this._register(instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync(() => userDataAutoSyncService.triggerAutoSync()));
 				}
 			});
 		}
 	}
 
-	private triggerSync(): void {
-		if (this.configurationService.getValue<boolean>('sync.enable')
-			&& this.userDataSyncService.status !== SyncStatus.Uninitialized
-			&& this.authenticationState.get() === MSAAuthStatus.SignedIn) {
-			this.userDataSyncService.sync();
-		}
-	}
-
 	private async initializeActiveAccount(): Promise<void> {
 		const accounts = await this.authenticationService.getAccounts(MSA);
 		// MSA provider has not yet been registered
@@ -441,7 +434,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 				case 1: return Promise.reject(canceled());
 				case 2: return this.userDataSyncService.pull();
 				// case 3: return this.userDataSyncService.push();
-				case 3: return this.notificationService.info('not yet supported');
+				case 3: return this.notificationService.info('Upload: Not yet supported');
 			}
 		}
 	}
@@ -451,10 +444,16 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 			type: 'info',
 			message: localize('turn off sync confirmation', "Turn off Sync"),
 			detail: localize('turn off sync detail', "Your settings, keybindings, extensions and more will no longer be synced."),
-			primaryButton: localize('turn off', "Turn off")
+			primaryButton: localize('turn off', "Turn off"),
+			checkbox: {
+				label: localize('turn off sync everywhere', "Turn off sync in all your devices and clear the data from cloud.")
+			}
 		});
 		if (result.confirmed) {
 			await this.configurationService.updateValue(UserDataSyncWorkbenchContribution.ENABLEMENT_SETTING, false);
+			if (result.checkboxChecked) {
+				await this.userDataSyncService.reset();
+			}
 		}
 	}
 
@@ -689,5 +688,15 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 			},
 			when: ContextKeyExpr.and(CONTEXT_SYNC_STATE.notEqualsTo(SyncStatus.Uninitialized)),
 		});
+
+		const resetLocalCommandId = 'workbench.userData.actions.resetLocal';
+		CommandsRegistry.registerCommand(resetLocalCommandId, () => this.userDataSyncService.resetLocal());
+		MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+			command: {
+				id: resetLocalCommandId,
+				title: localize('reset local', "Developer: Reset Local (Sync)")
+			},
+			when: ContextKeyExpr.and(CONTEXT_SYNC_STATE.notEqualsTo(SyncStatus.Uninitialized)),
+		});
 	}
 }

src/vs/workbench/services/userDataSync/common/userDataSyncUtil.ts

@@ -11,6 +11,7 @@ import { FormattingOptions } from 'vs/base/common/jsonFormatter';
 import { URI } from 'vs/base/common/uri';
 import { ITextModelService } from 'vs/editor/common/services/resolverService';
 import { ITextResourcePropertiesService, ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfigurationService';
+import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
 
 class UserDataSyncUtilService implements IUserDataSyncUtilService {
 
@@ -21,8 +22,13 @@ class UserDataSyncUtilService implements IUserDataSyncUtilService {
 		@ITextModelService private readonly textModelService: ITextModelService,
 		@ITextResourcePropertiesService private readonly textResourcePropertiesService: ITextResourcePropertiesService,
 		@ITextResourceConfigurationService private readonly textResourceConfigurationService: ITextResourceConfigurationService,
+		@IConfigurationService private readonly configurationService: IConfigurationService,
 	) { }
 
+	public async updateConfigurationValue(key: string, value: any): Promise<void> {
+		await this.configurationService.updateValue(key, value, ConfigurationTarget.USER);
+	}
+
 	public async resolveUserBindings(userBindings: string[]): Promise<IStringDictionary<string>> {
 		const keys: IStringDictionary<string> = {};
 		for (const userbinding of userBindings) {

src/vs/workbench/services/userDataSync/electron-browser/settingsSyncService.ts

@@ -61,6 +61,10 @@ export class SettingsSyncService extends Disposable implements ISettingsSyncServ
 		this.channel.call('stop');
 	}
 
+	resetLocal(): Promise<void> {
+		return this.channel.call('resetLocal');
+	}
+
 	hasPreviouslySynced(): Promise<boolean> {
 		return this.channel.call('hasPreviouslySynced');
 	}

src/vs/workbench/services/userDataSync/electron-browser/userDataAutoSyncService.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
+import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IChannel } from 'vs/base/parts/ipc/common/ipc';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+
+export class UserDataAutoSyncService extends Disposable implements IUserDataAutoSyncService {
+
+	_serviceBrand: undefined;
+
+	private readonly channel: IChannel;
+
+	constructor(
+		@ISharedProcessService sharedProcessService: ISharedProcessService
+	) {
+		super();
+		this.channel = sharedProcessService.getChannel('userDataAutoSync');
+	}
+
+	triggerAutoSync(): Promise<void> {
+		return this.channel.call('triggerAutoSync');
+	}
+
+}
+
+registerSingleton(IUserDataAutoSyncService, UserDataAutoSyncService);

src/vs/workbench/services/userDataSync/electron-browser/userDataSyncService.ts

@@ -50,6 +50,14 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
 		return this.channel.call('sync', [_continue]);
 	}
 
+	reset(): Promise<void> {
+		return this.channel.call('reset');
+	}
+
+	resetLocal(): Promise<void> {
+		return this.channel.call('resetLocal');
+	}
+
 	stop(): void {
 		this.channel.call('stop');
 	}

src/vs/workbench/workbench.desktop.main.ts

@@ -51,6 +51,7 @@ import 'vs/workbench/services/workspaces/electron-browser/workspacesService';
 import 'vs/workbench/services/workspaces/electron-browser/workspaceEditingService';
 import 'vs/workbench/services/userDataSync/electron-browser/userDataSyncService';
 import 'vs/workbench/services/userDataSync/electron-browser/settingsSyncService';
+import 'vs/workbench/services/userDataSync/electron-browser/userDataAutoSyncService';
 import 'vs/workbench/services/userDataSync/electron-browser/userDataAuthTokenService';
 import 'vs/workbench/services/authentication/browser/authenticationService';
 import 'vs/workbench/services/host/electron-browser/desktopHostService';