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

529 LOC · 489 covered · 40 uncovered · 87 ranges · 585 concepts · 24 introducers · 348 tests
File neighbourhood

The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
  1
  >
  /*---------------------------------------------------------------------------------------------
  
abstractSynchronizer.ts ×49

  2
  >
   *  Copyright (c) Microsoft Corporation. All rights reserved.
  
  3
  >
   *  Licensed under the MIT License. See License.txt in the project root for license information.
  
  4
  >
   *--------------------------------------------------------------------------------------------*/
  
  5
  >
  
  6
  >
  import { URI } from '../../../../base/common/uri.js';
  
  7
  >
  import { Event } from '../../../../base/common/event.js';
  
  8
  >
  import { VSBuffer } from '../../../../base/common/buffer.js';
  
  9
  >
  import { deepClone } from '../../../../base/common/objects.js';
  
  10
  >
  import { IStorageService } from '../../../storage/common/storage.js';
  
  11
  >
  import { ITelemetryService } from '../../../telemetry/common/telemetry.js';
  
  12
  >
  import { IStringDictionary } from '../../../../base/common/collections.js';
  
  13
  >
  import { CancellationToken } from '../../../../base/common/cancellation.js';
  
  14
  >
  import { IUriIdentityService } from '../../../uriIdentity/common/uriIdentity.js';
  
  15
  >
  import { IEnvironmentService } from '../../../environment/common/environment.js';
  
  16
  >
  
  17
  >
  import { IUserDataProfile } from '../../../userDataProfile/common/userDataProfile.js';
  
  18
  >
  import { IConfigurationService } from '../../../configuration/common/configuration.js';
  
  19
  >
  import { areSame, IMergeResult as IPromptsMergeResult, merge } from './promptsMerge.js';
  
  20
  >
  import { AbstractSynchroniser, IAcceptResult, IFileResourcePreview, IMergeResult } from '../abstractSynchronizer.js';
  
  21
  >
  import { FileOperationError, FileOperationResult, IFileContent, IFileService, IFileStat } from '../../../files/common/files.js';
  
  22
  >
  import { Change, IRemoteUserData, ISyncData, IUserDataSyncLocalStoreService, IUserDataSynchroniser, IUserDataSyncLogService, IUserDataSyncEnablementService, IUserDataSyncStoreService, SyncResource, USER_DATA_SYNC_SCHEME } from '../userDataSync.js';
  
  23
  >
  
  24
  >
  interface IPromptsResourcePreview extends IFileResourcePreview {
  
  25
  >
  	previewResult: IMergeResult;
  
  26
  >
  }
  
  27
  >
  
  28
  >
  interface IPromptsAcceptedResourcePreview extends IFileResourcePreview {
  
  29
  >
  	acceptResult: IAcceptResult;
  
  30
  >
  }
  
  31
  >
  
  32
  >
  export function parsePrompts(syncData: ISyncData): IStringDictionary<string> {
  
  33
  >
  	return JSON.parse(syncData.content);
  
promptsSync.ts ×3

  34
  >
  }
  
  35
  >
  
abstractSynchronizer.ts ×49

  36
  >
  /**
  
  37
  >
   * Synchronizer class for the "user" prompt files.
  
  38
  >
   * Adopted from {@link SnippetsSynchroniser}.
  
  39
  >
   */
  
  40
  >
  export class PromptsSynchronizer extends AbstractSynchroniser implements IUserDataSynchroniser {
  
  41
  >
  
  42
  >
  	protected readonly version: number = 1;
  
  43
  >
  	private readonly promptsFolder: URI;
  
  44
  >
  
  45
  >
  	constructor(
  
  46
  >
  		profile: IUserDataProfile,
  
userDataSyncService.ts ×19

  47
  >
  		collection: string | undefined,
  
  48
  >
  		@IEnvironmentService environmentService: IEnvironmentService,
  
  49
  >
  		@IFileService fileService: IFileService,
  
  50
  >
  		@IStorageService storageService: IStorageService,
  
  51
  >
  		@IUserDataSyncStoreService userDataSyncStoreService: IUserDataSyncStoreService,
  
  52
  >
  		@IUserDataSyncLocalStoreService userDataSyncLocalStoreService: IUserDataSyncLocalStoreService,
  
  53
  >
  		@IUserDataSyncLogService logService: IUserDataSyncLogService,
  
  54
  >
  		@IConfigurationService configurationService: IConfigurationService,
  
  55
  >
  		@IUserDataSyncEnablementService userDataSyncEnablementService: IUserDataSyncEnablementService,
  
  56
  >
  		@ITelemetryService telemetryService: ITelemetryService,
  
  57
  >
  		@IUriIdentityService uriIdentityService: IUriIdentityService,
  
  58
  >
  	) {
  
  59
  >
  		const syncResource = { syncResource: SyncResource.Prompts, profile };
  
  60
  >
  		super(
  
  61
  >
  			syncResource,
  
  62
  >
  			collection,
  
  63
  >
  			fileService,
  
  64
  >
  			environmentService,
  
  65
  >
  			storageService,
  
  66
  >
  			userDataSyncStoreService,
  
  67
  >
  			userDataSyncLocalStoreService,
  
  68
  >
  			userDataSyncEnablementService,
  
  69
  >
  			telemetryService,
  
  70
  >
  			logService,
  
  71
  >
  			configurationService,
  
  72
  >
  			uriIdentityService,
  
  73
  >
  		);
  
  74
  >
  
  75
  >
  		this.promptsFolder = profile.promptsHome;
  
  76
  >
  		this._register(this.fileService.watch(environmentService.userRoamingDataHome));
  
  77
  >
  		this._register(this.fileService.watch(this.promptsFolder));
  
  78
  >
  		this._register(Event.filter(this.fileService.onDidFilesChange, e => e.affects(this.promptsFolder))(() => this.triggerLocalChange()));
  
  79
  >
  	}
  
  80
  >
  
abstractSynchronizer.ts ×49

  81
  >
  	protected async generateSyncPreview(remoteUserData: IRemoteUserData, lastSyncUserData: IRemoteUserData | null, isRemoteDataFromCurrentMachine: boolean): Promise<IPromptsResourcePreview[]> {
  
  82
  >
  		const local = await this.getPromptsFileContents();
  
promptsSync.ts ×16

  83
  >
  		const localPrompts = this.toPromptContents(local);
  
  84
  >
  		const remotePrompts: IStringDictionary<string> | null = remoteUserData.syncData ? this.parsePrompts(remoteUserData.syncData) : null;
  
  85
  >
  
  86
  >
  		// Use remote data as last sync data if last sync data does not exist and remote data is from same machine
  
  87
  >
  		lastSyncUserData = lastSyncUserData === null && isRemoteDataFromCurrentMachine ? remoteUserData : lastSyncUserData;
  
  88
  >
  		const lastSyncPrompts: IStringDictionary<string> | null = lastSyncUserData && lastSyncUserData.syncData ? this.parsePrompts(lastSyncUserData.syncData) : null;
  
  89
  >
  
  90
  >
  		if (remotePrompts) {
  
  91
  >
  			this.logService.trace(`${this.syncResourceLogLabel}: Merging remote prompts with local prompts...`);
  
promptsSync.ts ×3

  92
  >
  		} else {
  
promptsSync.ts ×16

  93
  >
  			this.logService.trace(`${this.syncResourceLogLabel}: Remote prompts does not exist. Synchronizing prompts for the first time.`);
  
  94
  >
  		}
  
  95
  >
  
  96
  >
  		const mergeResult = merge(localPrompts, remotePrompts, lastSyncPrompts);
  
  97
  >
  		return this.getResourcePreviews(mergeResult, local, remotePrompts || {}, lastSyncPrompts || {});
  
  98
  >
  	}
  
  99
  >
  
abstractSynchronizer.ts ×49

  100
  >
  	protected async hasRemoteChanged(lastSyncUserData: IRemoteUserData): Promise<boolean> {
  
  101
  >
  		const lastSync: IStringDictionary<string> | null = lastSyncUserData.syncData ? this.parsePrompts(lastSyncUserData.syncData) : null;
  
globalStateSync.ts ×2

  102
  >
  		if (lastSync === null) {
  
  103
  
  			return true;
  
  104
  
  		}
  
  105
  >
  		const local = await this.getPromptsFileContents();
  
globalStateSync.ts ×2

  106
  >
  		const localPrompts = this.toPromptContents(local);
  
  107
  >
  		const mergeResult = merge(localPrompts, lastSync, lastSync);
  
  108
  >
  		return Object.keys(mergeResult.remote.added).length > 0 || Object.keys(mergeResult.remote.updated).length > 0 || mergeResult.remote.removed.length > 0 || mergeResult.conflicts.length > 0;
  
  109
  >
  	}
  
  110
  >
  
abstractSynchronizer.ts ×49

  111
  >
  	protected async getMergeResult(resourcePreview: IPromptsResourcePreview, token: CancellationToken): Promise<IMergeResult> {
  
  112
  >
  		return resourcePreview.previewResult;
  
promptsSync.ts ×11

  113
  >
  	}
  
  114
  >
  
abstractSynchronizer.ts ×49

  115
  >
  	protected async getAcceptResult(resourcePreview: IPromptsResourcePreview, resource: URI, content: string | null | undefined, token: CancellationToken): Promise<IAcceptResult> {
  
  116
  >
  
promptsSync.ts ×11

  117
  >
  		/* Accept local resource */
  
  118
  >
  		if (this.extUri.isEqualOrParent(resource, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }))) {
  
  119
  
  			return {
  
  120
  
  				content: resourcePreview.fileContent ? resourcePreview.fileContent.value.toString() : null,
  
  121
  
  				localChange: Change.None,
  
  122
  
  				remoteChange: resourcePreview.fileContent
  
  123
  
  					? resourcePreview.remoteContent !== null ? Change.Modified : Change.Added
  
  124
  
  					: Change.Deleted
  
  125
  
  			};
  
  126
  
  		}
  
  127
  >
  
promptsSync.ts ×11

  128
  >
  		/* Accept remote resource */
  
  129
  >
  		if (this.extUri.isEqualOrParent(resource, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }))) {
  
  130
  
  			return {
  
  131
  
  				content: resourcePreview.remoteContent,
  
  132
  
  				localChange: resourcePreview.remoteContent !== null
  
  133
  
  					? resourcePreview.fileContent ? Change.Modified : Change.Added
  
  134
  
  					: Change.Deleted,
  
  135
  
  				remoteChange: Change.None,
  
  136
  
  			};
  
  137
  
  		}
  
  138
  >
  
promptsSync.ts ×11

  139
  >
  		/* Accept preview resource */
  
  140
  >
  		if (this.extUri.isEqualOrParent(resource, this.syncPreviewFolder)) {
  
  141
  >
  			if (content === undefined) {
  
  142
  >
  				return {
  
  143
  >
  					content: resourcePreview.previewResult.content,
  
  144
  >
  					localChange: resourcePreview.previewResult.localChange,
  
  145
  >
  					remoteChange: resourcePreview.previewResult.remoteChange,
  
  146
  >
  				};
  
  147
  >
  			} else {
  
  148
  >
  				return {
  
promptsSync.ts ×3

  149
  >
  					content,
  
  150
  >
  					localChange: content === null
  
  151
  >
  						? resourcePreview.fileContent !== null ? Change.Deleted : Change.None
  
promptsSync.ts ×2

  152
  >
  						: Change.Modified,
  
promptsSync.ts ×2

  153
  >
  					remoteChange: content === null
  
promptsSync.ts ×3

  154
  >
  						? resourcePreview.remoteContent !== null ? Change.Deleted : Change.None
  
promptsSync.ts ×2

  155
  >
  						: Change.Modified
  
promptsSync.ts ×2

  156
  >
  				};
  
promptsSync.ts ×3

  157
  >
  			}
  
  158
  >
  		}
  
promptsSync.ts ×11

  159
  
  160
  
  		throw new Error(`Invalid Resource: ${resource.toString()}`);
  
  161
  >
  	}
  
promptsSync.ts ×11

  162
  >
  
abstractSynchronizer.ts ×49

  163
  >
  	protected async applyResult(remoteUserData: IRemoteUserData, lastSyncUserData: IRemoteUserData | null, resourcePreviews: [IPromptsResourcePreview, IAcceptResult][], force: boolean): Promise<void> {
  
  164
  >
  		const accptedResourcePreviews: IPromptsAcceptedResourcePreview[] = resourcePreviews.map(([resourcePreview, acceptResult]) => ({ ...resourcePreview, acceptResult }));
  
promptsSync.ts ×5

  165
  >
  		if (accptedResourcePreviews.every(({ localChange, remoteChange }) => localChange === Change.None && remoteChange === Change.None)) {
  
  166
  >
  			this.logService.info(`${this.syncResourceLogLabel}: No changes found during synchronizing prompts.`);
  
promptsSync.ts ×1

  167
  >
  		}
  
  168
  >
  
promptsSync.ts ×5

  169
  >
  		if (accptedResourcePreviews.some(({ localChange }) => localChange !== Change.None)) {
  
  170
  >
  			// back up all prompts
  
promptsSync.ts ×6

  171
  >
  			await this.updateLocalBackup(accptedResourcePreviews);
  
  172
  >
  			await this.updateLocalPrompts(accptedResourcePreviews, force);
  
  173
  >
  		}
  
  174
  >
  
promptsSync.ts ×5

  175
  >
  		if (accptedResourcePreviews.some(({ remoteChange }) => remoteChange !== Change.None)) {
  
  176
  >
  			remoteUserData = await this.updateRemotePrompts(accptedResourcePreviews, remoteUserData, force);
  
promptsSync.ts ×4

  177
  >
  		}
  
  178
  >
  
promptsSync.ts ×5

  179
  >
  		if (lastSyncUserData?.ref !== remoteUserData.ref) {
  
  180
  >
  			// update last sync
  
  181
  >
  			this.logService.trace(`${this.syncResourceLogLabel}: Updating last synchronized prompts...`);
  
  182
  >
  			await this.updateLastSyncUserData(remoteUserData);
  
  183
  >
  			this.logService.info(`${this.syncResourceLogLabel}: Updated last synchronized prompts`);
  
  184
  >
  		}
  
  185
  >
  
  186
  >
  		for (const { previewResource } of accptedResourcePreviews) {
  
  187
  >
  			// Delete the preview
  
promptsSync.ts ×4

  188
  >
  			try {
  
  189
  >
  				await this.fileService.del(previewResource);
  
  190
  >
  			} catch (e) { /* ignore */ }
  
  191
  >
  		}
  
  192
  >
  
promptsSync.ts ×5

  193
  >
  	}
  
  194
  >
  
abstractSynchronizer.ts ×49

  195
  >
  	private getResourcePreviews(
  
  196
  >
  		mergeResult: IPromptsMergeResult,
  
promptsSync.ts ×16

  197
  >
  		localFileContent: IStringDictionary<IFileContent>,
  
  198
  >
  		remote: IStringDictionary<string>,
  
  199
  >
  		base: IStringDictionary<string>,
  
  200
  >
  	): IPromptsResourcePreview[] {
  
  201
  >
  		const resourcePreviews: Map<string, IPromptsResourcePreview> = new Map<string, IPromptsResourcePreview>();
  
  202
  >
  
  203
  >
  		/* Prompts added remotely -> add locally */
  
  204
  >
  		for (const key of Object.keys(mergeResult.local.added)) {
  
  205
  >
  			const previewResult: IMergeResult = {
  
promptsSync.ts ×2

  206
  >
  				content: mergeResult.local.added[key],
  
  207
  >
  				hasConflicts: false,
  
  208
  >
  				localChange: Change.Added,
  
  209
  >
  				remoteChange: Change.None,
  
  210
  >
  			};
  
  211
  >
  			resourcePreviews.set(key, {
  
  212
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  213
  >
  				baseContent: null,
  
  214
  >
  				fileContent: null,
  
  215
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  216
  >
  				localContent: null,
  
  217
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  218
  >
  				remoteContent: remote[key],
  
  219
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  220
  >
  				previewResult,
  
  221
  >
  				localChange: previewResult.localChange,
  
  222
  >
  				remoteChange: previewResult.remoteChange,
  
  223
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  224
  >
  			});
  
  225
  >
  		}
  
  226
  >
  
promptsSync.ts ×16

  227
  >
  		/* Prompts updated remotely -> update locally */
  
  228
  >
  		for (const key of Object.keys(mergeResult.local.updated)) {
  
  229
  >
  			const previewResult: IMergeResult = {
  
promptsMerge.ts ×1

  230
  >
  				content: mergeResult.local.updated[key],
  
  231
  >
  				hasConflicts: false,
  
  232
  >
  				localChange: Change.Modified,
  
  233
  >
  				remoteChange: Change.None,
  
  234
  >
  			};
  
  235
  >
  			const localContent = localFileContent[key] ? localFileContent[key].value.toString() : null;
  
  236
  >
  			resourcePreviews.set(key, {
  
  237
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  238
  >
  				baseContent: base[key] ?? null,
  
  239
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  240
  >
  				fileContent: localFileContent[key],
  
  241
  >
  				localContent,
  
  242
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  243
  >
  				remoteContent: remote[key],
  
  244
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  245
  >
  				previewResult,
  
  246
  >
  				localChange: previewResult.localChange,
  
  247
  >
  				remoteChange: previewResult.remoteChange,
  
  248
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  249
  >
  			});
  
  250
  >
  		}
  
  251
  >
  
promptsSync.ts ×16

  252
  >
  		/* Prompts removed remotely -> remove locally */
  
  253
  >
  		for (const key of mergeResult.local.removed) {
  
  254
  >
  			const previewResult: IMergeResult = {
  
promptsMerge.ts ×1

  255
  >
  				content: null,
  
  256
  >
  				hasConflicts: false,
  
  257
  >
  				localChange: Change.Deleted,
  
  258
  >
  				remoteChange: Change.None,
  
  259
  >
  			};
  
  260
  >
  			const localContent = localFileContent[key] ? localFileContent[key].value.toString() : null;
  
  261
  >
  			resourcePreviews.set(key, {
  
  262
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  263
  >
  				baseContent: base[key] ?? null,
  
  264
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  265
  >
  				fileContent: localFileContent[key],
  
  266
  >
  				localContent,
  
  267
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  268
  >
  				remoteContent: null,
  
  269
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  270
  >
  				previewResult,
  
  271
  >
  				localChange: previewResult.localChange,
  
  272
  >
  				remoteChange: previewResult.remoteChange,
  
  273
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  274
  >
  			});
  
  275
  >
  		}
  
  276
  >
  
promptsSync.ts ×16

  277
  >
  		/* Prompts added locally -> add remotely */
  
  278
  >
  		for (const key of Object.keys(mergeResult.remote.added)) {
  
  279
  >
  			const previewResult: IMergeResult = {
  
promptsSync.ts ×11

  280
  >
  				content: mergeResult.remote.added[key],
  
  281
  >
  				hasConflicts: false,
  
  282
  >
  				localChange: Change.None,
  
  283
  >
  				remoteChange: Change.Added,
  
  284
  >
  			};
  
  285
  >
  			const localContent = localFileContent[key] ? localFileContent[key].value.toString() : null;
  
  286
  >
  			resourcePreviews.set(key, {
  
  287
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  288
  >
  				baseContent: base[key] ?? null,
  
  289
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  290
  >
  				fileContent: localFileContent[key],
  
  291
  >
  				localContent,
  
  292
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  293
  >
  				remoteContent: null,
  
  294
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  295
  >
  				previewResult,
  
  296
  >
  				localChange: previewResult.localChange,
  
  297
  >
  				remoteChange: previewResult.remoteChange,
  
  298
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  299
  >
  			});
  
  300
  >
  		}
  
  301
  >
  
promptsSync.ts ×16

  302
  >
  		/* Prompts updated locally -> update remotely */
  
  303
  >
  		for (const key of Object.keys(mergeResult.remote.updated)) {
  
  304
  >
  			const previewResult: IMergeResult = {
  
promptsMerge.ts ×2

  305
  >
  				content: mergeResult.remote.updated[key],
  
  306
  >
  				hasConflicts: false,
  
  307
  >
  				localChange: Change.None,
  
  308
  >
  				remoteChange: Change.Modified,
  
  309
  >
  			};
  
  310
  >
  			const localContent = localFileContent[key] ? localFileContent[key].value.toString() : null;
  
  311
  >
  			resourcePreviews.set(key, {
  
  312
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  313
  >
  				baseContent: base[key] ?? null,
  
  314
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  315
  >
  				fileContent: localFileContent[key],
  
  316
  >
  				localContent,
  
  317
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  318
  >
  				remoteContent: remote[key],
  
  319
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  320
  >
  				previewResult,
  
  321
  >
  				localChange: previewResult.localChange,
  
  322
  >
  				remoteChange: previewResult.remoteChange,
  
  323
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  324
  >
  			});
  
  325
  >
  		}
  
  326
  >
  
promptsSync.ts ×16

  327
  >
  		/* Prompts removed locally -> remove remotely */
  
  328
  >
  		for (const key of mergeResult.remote.removed) {
  
  329
  >
  			const previewResult: IMergeResult = {
  
promptsSync.ts ×2

  330
  >
  				content: null,
  
  331
  >
  				hasConflicts: false,
  
  332
  >
  				localChange: Change.None,
  
  333
  >
  				remoteChange: Change.Deleted,
  
  334
  >
  			};
  
  335
  >
  			resourcePreviews.set(key, {
  
  336
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  337
  >
  				baseContent: base[key] ?? null,
  
  338
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  339
  >
  				fileContent: null,
  
  340
  >
  				localContent: null,
  
  341
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  342
  >
  				remoteContent: remote[key],
  
  343
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  344
  >
  				previewResult,
  
  345
  >
  				localChange: previewResult.localChange,
  
  346
  >
  				remoteChange: previewResult.remoteChange,
  
  347
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  348
  >
  			});
  
  349
  >
  		}
  
  350
  >
  
promptsSync.ts ×16

  351
  >
  		/* Prompts with conflicts */
  
  352
  >
  		for (const key of mergeResult.conflicts) {
  
  353
  >
  			const previewResult: IMergeResult = {
  
promptsSync.ts ×1

  354
  >
  				content: base[key] ?? null,
  
  355
  >
  				hasConflicts: true,
  
  356
  >
  				localChange: localFileContent[key] ? Change.Modified : Change.Added,
  
  357
  >
  				remoteChange: remote[key] ? Change.Modified : Change.Added
  
  358
  >
  			};
  
  359
  >
  			const localContent = localFileContent[key] ? localFileContent[key].value.toString() : null;
  
  360
  >
  			resourcePreviews.set(key, {
  
  361
  >
  				baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  362
  >
  				baseContent: base[key] ?? null,
  
  363
  >
  				localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  364
  >
  				fileContent: localFileContent[key] || null,
  
  365
  >
  				localContent,
  
  366
  >
  				remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  367
  >
  				remoteContent: remote[key] || null,
  
  368
  >
  				previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  369
  >
  				previewResult,
  
  370
  >
  				localChange: previewResult.localChange,
  
  371
  >
  				remoteChange: previewResult.remoteChange,
  
  372
  >
  				acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  373
  >
  			});
  
  374
  >
  		}
  
  375
  >
  
promptsSync.ts ×16

  376
  >
  		/* Unmodified Prompts */
  
  377
  >
  		for (const key of Object.keys(localFileContent)) {
  
  378
  >
  			if (!resourcePreviews.has(key)) {
  
promptsSync.ts ×11

  379
  >
  				const previewResult: IMergeResult = {
  
promptsSync.ts ×1

  380
  >
  					content: localFileContent[key] ? localFileContent[key].value.toString() : null,
  
  381
  >
  					hasConflicts: false,
  
  382
  >
  					localChange: Change.None,
  
  383
  >
  					remoteChange: Change.None
  
  384
  >
  				};
  
  385
  >
  				const localContent = localFileContent[key] ? localFileContent[key].value.toString() : null;
  
  386
  >
  				resourcePreviews.set(key, {
  
  387
  >
  					baseResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }),
  
  388
  >
  					baseContent: base[key] ?? null,
  
  389
  >
  					localResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }),
  
  390
  >
  					fileContent: localFileContent[key] || null,
  
  391
  >
  					localContent,
  
  392
  >
  					remoteResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }),
  
  393
  >
  					remoteContent: remote[key] || null,
  
  394
  >
  					previewResource: this.extUri.joinPath(this.syncPreviewFolder, key),
  
  395
  >
  					previewResult,
  
  396
  >
  					localChange: previewResult.localChange,
  
  397
  >
  					remoteChange: previewResult.remoteChange,
  
  398
  >
  					acceptedResource: this.extUri.joinPath(this.syncPreviewFolder, key).with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' })
  
  399
  >
  				});
  
  400
  >
  			}
  
  401
  >
  		}
  
promptsSync.ts ×11

  402
  >
  
promptsSync.ts ×16

  403
  >
  		return [...resourcePreviews.values()];
  
  404
  >
  	}
  
  405
  >
  
abstractSynchronizer.ts ×49

  406
  >
  	override async resolveContent(uri: URI): Promise<string | null> {
  
  407
  
  		if (this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }))
  
  408
  
  			|| this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }))
  
  409
  
  			|| this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'base' }))
  
  410
  
  			|| this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' }))) {
  
  411
  
  			return this.resolvePreviewContent(uri);
  
  412
  
  		}
  
  413
  
  		return null;
  
  414
  
  	}
  
  415
  >
  
abstractSynchronizer.ts ×49

  416
  >
  	async hasLocalData(): Promise<boolean> {
  
  417
  
  		try {
  
  418
  
  			const local = await this.getPromptsFileContents();
  
  419
  
  			if (Object.keys(local).length) {
  
  420
  
  				return true;
  
  421
  
  			}
  
  422
  
  		} catch (error) {
  
  423
  
  			/* ignore error */
  
  424
  
  		}
  
  425
  
  		return false;
  
  426
  
  	}
  
  427
  >
  
abstractSynchronizer.ts ×49

  428
  >
  	private async updateLocalBackup(resourcePreviews: IFileResourcePreview[]): Promise<void> {
  
  429
  >
  		const local: IStringDictionary<IFileContent> = {};
  
promptsSync.ts ×6

  430
  >
  		for (const resourcePreview of resourcePreviews) {
  
  431
  >
  			if (resourcePreview.fileContent) {
  
  432
  >
  				local[this.extUri.basename(resourcePreview.localResource)] = resourcePreview.fileContent;
  
promptsSync.ts ×1

  433
  >
  			}
  
  434
  >
  		}
  
promptsSync.ts ×6

  435
  >
  		await this.backupLocal(JSON.stringify(this.toPromptContents(local)));
  
  436
  >
  	}
  
  437
  >
  
abstractSynchronizer.ts ×49

  438
  >
  	private async updateLocalPrompts(resourcePreviews: IPromptsAcceptedResourcePreview[], force: boolean): Promise<void> {
  
  439
  >
  		for (const { fileContent, acceptResult, localResource, remoteResource, localChange } of resourcePreviews) {
  
promptsSync.ts ×6

  440
  >
  			if (localChange !== Change.None) {
  
  441
  >
  				const key = remoteResource ? this.extUri.basename(remoteResource) : this.extUri.basename(localResource);
  
  442
  >
  				const resource = this.extUri.joinPath(this.promptsFolder, key);
  
  443
  >
  
  444
  >
  				// Removed
  
  445
  >
  				if (localChange === Change.Deleted) {
  
  446
  >
  					this.logService.trace(`${this.syncResourceLogLabel}: Deleting prompt...`, this.extUri.basename(resource));
  
promptsSync.ts ×1

  447
  >
  					await this.fileService.del(resource);
  
  448
  >
  					this.logService.info(`${this.syncResourceLogLabel}: Deleted prompt`, this.extUri.basename(resource));
  
  449
  >
  				}
  
  450
  >
  
promptsSync.ts ×6

  451
  >
  				// Added
  
  452
  >
  				else if (localChange === Change.Added) {
  
  453
  >
  					this.logService.trace(`${this.syncResourceLogLabel}: Creating prompt...`, this.extUri.basename(resource));
  
promptsSync.ts ×2

  454
  >
  					await this.fileService.createFile(resource, VSBuffer.fromString(acceptResult.content!), { overwrite: force });
  
  455
  >
  					this.logService.info(`${this.syncResourceLogLabel}: Created prompt`, this.extUri.basename(resource));
  
  456
  >
  				}
  
  457
  >
  
promptsSync.ts ×1

  458
  >
  				// Updated
  
  459
  >
  				else {
  
  460
  >
  					this.logService.trace(`${this.syncResourceLogLabel}: Updating prompt...`, this.extUri.basename(resource));
  
  461
  >
  					await this.fileService.writeFile(resource, VSBuffer.fromString(acceptResult.content!), force ? undefined : fileContent!);
  
  462
  >
  					this.logService.info(`${this.syncResourceLogLabel}: Updated prompt`, this.extUri.basename(resource));
  
  463
  >
  				}
  
  464
  >
  			}
  
promptsSync.ts ×6

  465
  >
  		}
  
  466
  >
  	}
  
  467
  >
  
abstractSynchronizer.ts ×49

  468
  >
  	private async updateRemotePrompts(resourcePreviews: IPromptsAcceptedResourcePreview[], remoteUserData: IRemoteUserData, forcePush: boolean): Promise<IRemoteUserData> {
  
  469
  >
  		const currentPrompts: IStringDictionary<string> = remoteUserData.syncData ? this.parsePrompts(remoteUserData.syncData) : {};
  
promptsSync.ts ×4

  470
  >
  		const newPrompts: IStringDictionary<string> = deepClone(currentPrompts);
  
  471
  >
  
  472
  >
  		for (const { acceptResult, localResource, remoteResource, remoteChange } of resourcePreviews) {
  
  473
  >
  			if (remoteChange !== Change.None) {
  
  474
  >
  				const key = localResource ? this.extUri.basename(localResource) : this.extUri.basename(remoteResource);
  
  475
  >
  				if (remoteChange === Change.Deleted) {
  
  476
  >
  					delete newPrompts[key];
  
promptsSync.ts ×2

  477
  >
  				} else {
  
promptsSync.ts ×4

  478
  >
  					newPrompts[key] = acceptResult.content!;
  
  479
  >
  				}
  
  480
  >
  			}
  
  481
  >
  		}
  
  482
  >
  
  483
  >
  		if (!areSame(currentPrompts, newPrompts)) {
  
  484
  >
  			// update remote
  
  485
  >
  			this.logService.trace(`${this.syncResourceLogLabel}: Updating remote prompts...`);
  
  486
  >
  			remoteUserData = await this.updateRemoteUserData(JSON.stringify(newPrompts), forcePush ? null : remoteUserData.ref);
  
  487
  >
  			this.logService.info(`${this.syncResourceLogLabel}: Updated remote prompts`);
  
  488
  >
  		}
  
  489
  >
  		return remoteUserData;
  
  490
  >
  	}
  
  491
  >
  
abstractSynchronizer.ts ×49

  492
  >
  	private parsePrompts(syncData: ISyncData): IStringDictionary<string> {
  
  493
  >
  		return parsePrompts(syncData);
  
promptsSync.ts ×3

  494
  >
  	}
  
  495
  >
  
abstractSynchronizer.ts ×49

  496
  >
  	private toPromptContents(fileContents: IStringDictionary<IFileContent>): IStringDictionary<string> {
  
  497
  >
  		const prompts: IStringDictionary<string> = {};
  
promptsSync.ts ×16

  498
  >
  		for (const key of Object.keys(fileContents)) {
  
  499
  >
  			prompts[key] = fileContents[key].value.toString();
  
promptsSync.ts ×11

  500
  >
  		}
  
  501
  >
  		return prompts;
  
promptsSync.ts ×16

  502
  >
  	}
  
  503
  >
  
abstractSynchronizer.ts ×49

  504
  >
  	private async getPromptsFileContents(): Promise<IStringDictionary<IFileContent>> {
  
  505
  >
  		const prompts: IStringDictionary<IFileContent> = {};
  
promptsSync.ts ×16

  506
  >
  		let stat: IFileStat;
  
  507
  >
  		try {
  
  508
  >
  			stat = await this.fileService.resolve(this.promptsFolder);
  
  509
  >
  		} catch (e) {
  
  510
  >
  			// No prompts
  
promptsSync.ts ×2

  511
  >
  			if (e instanceof FileOperationError && e.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
  
  512
  >
  				return prompts;
  
  513
  >
  			} else {
  
  514
  
  				throw e;
  
  515
  
  			}
  
  516
  >
  		}
  
promptsSync.ts ×2

  517
  >
  		for (const entry of stat.children || []) {
  
promptsSync.ts ×16

  518
  >
  			const resource = entry.resource;
  
promptsSync.ts ×11

  519
  >
  			const path = resource.path;
  
  520
  >
  			if (['.prompt.md', '.instructions.md', '.chatmode.md', '.agent.md'].some(ext => path.endsWith(ext))) {
  
  521
  >
  				const key = this.extUri.relativePath(this.promptsFolder, resource)!;
  
  522
  >
  				const content = await this.fileService.readFile(resource);
  
  523
  >
  				prompts[key] = content;
  
  524
  >
  			}
  
  525
  >
  		}
  
  526
  >
  
  527
  >
  		return prompts;
  
  528
  >
  	}
  
promptsSync.ts ×16

  529
  >
  }
  
abstractSynchronizer.ts ×49