Add APPLICATION_SHARED storage scope for cross-app state sharing

product.json

@@ -3,6 +3,7 @@
 	"nameLong": "Code - OSS",
 	"applicationName": "code-oss",
 	"dataFolderName": ".vscode-oss",
+	"sharedDataFolderName": ".vscode-oss-shared",
 	"win32MutexName": "vscodeoss",
 	"licenseName": "MIT",
 	"licenseUrl": "https://github.com/microsoft/vscode/blob/main/LICENSE.txt",

src/vs/base/common/product.ts

@@ -86,6 +86,7 @@ export interface IProductConfiguration {
 
 	readonly urlProtocol: string;
 	readonly dataFolderName: string; // location for extensions (e.g. ~/.vscode-insiders)
+	readonly sharedDataFolderName: string; // location for shared data (e.g. ~/.vscode-insiders-shared)
 
 	readonly builtInExtensions?: IBuiltInExtension[];
 	readonly walkthroughMetadata?: IProductWalkthrough[];

src/vs/base/parts/storage/common/storage.ts

@@ -7,7 +7,7 @@ import { ThrottledDelayer } from '../../../common/async.js';
 import { Event, PauseableEmitter } from '../../../common/event.js';
 import { Disposable, IDisposable } from '../../../common/lifecycle.js';
 import { parse, stringify } from '../../../common/marshalling.js';
-import { isObject, isUndefinedOrNull } from '../../../common/types.js';
+import { isObject, isUndefined, isUndefinedOrNull } from '../../../common/types.js';
 
 export enum StorageHint {
 
@@ -434,3 +434,66 @@ export class InMemoryStorageDatabase implements IStorageDatabase {
 	async optimize(): Promise<void> { }
 	async close(): Promise<void> { }
 }
+
+
+export const MIGRATED_KEY = '__$__migratedStorageMarker';
+
+export class MigratingStorage extends Storage {
+
+	private migratedKeys: Set<string> = new Set();
+	private fallbackStorage: IStorage | undefined = undefined;
+	private isFallbackStorageReadonly: boolean = false;
+
+	override async init(): Promise<void> {
+		await super.init();
+
+		// Load the set of keys already migrated from fallback
+		this.migratedKeys = this.loadMigratedKeys();
+	}
+
+	public setFallbackStorage(storage: IStorage, isReadonly: boolean): void {
+		this.fallbackStorage = storage;
+		this.isFallbackStorageReadonly = isReadonly;
+	}
+
+	private static readonly INTERNAL_KEY_PREFIX = '__$__';
+
+	override get(key: string, fallbackValue: string): string;
+	override get(key: string, fallbackValue?: string): string | undefined;
+	override get(key: string, fallbackValue?: string): string | undefined {
+		if (!key.startsWith(MigratingStorage.INTERNAL_KEY_PREFIX) && !this.migratedKeys.has(key) && isUndefined(super.get(key))) {
+			// Check fallback storage and auto-migrate on hit.
+			// Mark the key as migrated immediately to prevent
+			// re-checking the fallback, and to ensure a key
+			// that was intentionally removed after migration
+			// is not resurrected from the fallback.
+			this.migratedKeys.add(key);
+			const value = this.fallbackStorage?.items.get(key);
+			if (!isUndefined(value)) {
+				this.set(key, value);
+				if (!this.isFallbackStorageReadonly) {
+					this.fallbackStorage?.delete(key);
+				}
+				this.persistMigratedKeys();
+			}
+		}
+		return super.get(key, fallbackValue);
+	}
+
+	private loadMigratedKeys(): Set<string> {
+		const raw = super.get(MIGRATED_KEY);
+		if (raw) {
+			try {
+				return new Set(JSON.parse(raw));
+			} catch {
+				// Fail gracefully
+			}
+		}
+		return new Set();
+	}
+
+	private persistMigratedKeys(): void {
+		this.set(MIGRATED_KEY, JSON.stringify([...this.migratedKeys]));
+	}
+}
+

src/vs/base/parts/storage/node/storage.ts

@@ -22,6 +22,14 @@ interface IDatabaseConnection {
 
 export interface ISQLiteStorageDatabaseOptions {
 	readonly logging?: ISQLiteStorageDatabaseLoggingOptions;
+	readonly useWAL?: boolean;
+
+	/**
+	 * If set, configures SQLite's busy timeout in milliseconds.
+	 * When another process holds a write lock, SQLite will retry
+	 * for this duration before returning SQLITE_BUSY.
+	 */
+	readonly busyTimeout?: number;
 }
 
 export interface ISQLiteStorageDatabaseLoggingOptions {
@@ -41,6 +49,8 @@ export class SQLiteStorageDatabase implements IStorageDatabase {
 	private readonly name: string;
 
 	private readonly logger: SQLiteStorageDatabaseLogger;
+	private readonly useWAL: boolean;
+	private readonly busyTimeout: number | undefined;
 
 	private readonly whenConnected: Promise<IDatabaseConnection>;
 
@@ -50,6 +60,8 @@ export class SQLiteStorageDatabase implements IStorageDatabase {
 	) {
 		this.name = basename(this.path);
 		this.logger = new SQLiteStorageDatabaseLogger(options.logging);
+		this.useWAL = !!options.useWAL;
+		this.busyTimeout = options.busyTimeout;
 		this.whenConnected = this.connect(this.path);
 	}
 
@@ -326,10 +338,17 @@ export class SQLiteStorageDatabase implements IStorageDatabase {
 						// The following exec() statement serves two purposes:
 						// - create the DB if it does not exist yet
 						// - validate that the DB is not corrupt (the open() call does not throw otherwise)
-						return this.exec(connection, [
+						const pragmas: string[] = [
 							'PRAGMA user_version = 1;',
-							'CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB)'
-						].join('')).then(() => {
+							'CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);'
+						];
+						if (this.useWAL) {
+							pragmas.push('PRAGMA journal_mode=WAL;');
+						}
+						if (this.busyTimeout) {
+							pragmas.push(`PRAGMA busy_timeout=${this.busyTimeout};`);
+						}
+						return this.exec(connection, pragmas.join('')).then(() => {
 							return resolve(connection);
 						}, error => {
 							return connection.db.close(() => reject(error));

src/vs/code/node/cli.ts

@@ -248,11 +248,13 @@ export async function main(argv: string[]): Promise<void> {
 			const tempParentDir = randomPath(tmpdir(), 'vscode');
 			const tempUserDataDir = join(tempParentDir, 'data');
 			const tempExtensionsDir = join(tempParentDir, 'extensions');
+			const tempSharedDataDir = join(tempParentDir, 'shared');
 
 			addArg(argv, '--user-data-dir', tempUserDataDir);
 			addArg(argv, '--extensions-dir', tempExtensionsDir);
+			addArg(argv, '--shared-data-dir', tempSharedDataDir);
 
-			console.log(`State is temporarily stored. Relaunch this state with: ${product.applicationName} --user-data-dir "${tempUserDataDir}" --extensions-dir "${tempExtensionsDir}"`);
+			console.log(`State is temporarily stored. Relaunch this state with: ${product.applicationName} --user-data-dir "${tempUserDataDir}" --extensions-dir "${tempExtensionsDir}" --shared-data-dir "${tempSharedDataDir}"`);
 		}
 
 		const hasReadStdinArg = args._.some(arg => arg === '-') || args.chat?._.some(arg => arg === '-');

src/vs/editor/standalone/browser/standaloneServices.ts

@@ -223,6 +223,7 @@ class StandaloneEnvironmentService implements IEnvironmentService {
 	readonly argvResource: URI = URI.from({ scheme: 'monaco', authority: 'argvResource' });
 	readonly untitledWorkspacesHome: URI = URI.from({ scheme: 'monaco', authority: 'untitledWorkspacesHome' });
 	readonly workspaceStorageHome: URI = URI.from({ scheme: 'monaco', authority: 'workspaceStorageHome' });
+	readonly appSharedDataHome: URI = URI.from({ scheme: 'monaco', authority: 'appSharedDataHome' });
 	readonly localHistoryHome: URI = URI.from({ scheme: 'monaco', authority: 'localHistoryHome' });
 	readonly cacheHome: URI = URI.from({ scheme: 'monaco', authority: 'cacheHome' });
 	readonly userDataSyncHome: URI = URI.from({ scheme: 'monaco', authority: 'userDataSyncHome' });

src/vs/platform/environment/common/argv.ts

@@ -75,6 +75,7 @@ export interface NativeParsedArgs {
 	'extensions-dir'?: string;
 	'extensions-download-dir'?: string;
 	'builtin-extensions-dir'?: string;
+	'shared-data-dir'?: string;
 	'agent-plugins-dir'?: string;
 	extensionDevelopmentPath?: string[]; // undefined or array of 1 or more local paths or URIs
 	extensionTestsPath?: string; // either a local path or a URI

src/vs/platform/environment/common/environment.ts

@@ -58,6 +58,7 @@ export interface IEnvironmentService {
 	workspaceStorageHome: URI;
 	localHistoryHome: URI;
 	cacheHome: URI;
+	appSharedDataHome: URI;
 
 	// --- settings sync
 	userDataSyncHome: URI;

src/vs/platform/environment/common/environmentService.ts

@@ -147,6 +147,21 @@ export abstract class AbstractNativeEnvironmentService implements INativeEnviron
 		return joinPath(this.userHome, this.productService.dataFolderName, 'extensions').fsPath;
 	}
 
+	@memoize
+	get appSharedDataHome(): URI {
+		const cliSharedDataDir = this.args['shared-data-dir'];
+		if (cliSharedDataDir) {
+			return URI.file(resolve(cliSharedDataDir));
+		}
+
+		const vscodePortable = env['VSCODE_PORTABLE'];
+		if (vscodePortable) {
+			return URI.file(join(vscodePortable, 'shared-data'));
+		}
+
+		return joinPath(this.userHome, this.productService.sharedDataFolderName);
+	}
+
 	@memoize
 	get agentPluginsPath(): string {
 		const cliAgentPluginsDir = this.args['agent-plugins-dir'];

src/vs/platform/environment/node/argv.ts

@@ -119,6 +119,7 @@ export const OPTIONS: OptionDescriptions<Required<NativeParsedArgs>> = {
 	'extensions-dir': { type: 'string', deprecates: ['extensionHomePath'], cat: 'e', args: 'dir', description: localize('extensionHomePath', "Set the root path for extensions.") },
 	'extensions-download-dir': { type: 'string' },
 	'builtin-extensions-dir': { type: 'string' },
+	'shared-data-dir': { type: 'string' },
 	'list-extensions': { type: 'boolean', cat: 'e', description: localize('listExtensions', "List the installed extensions.") },
 	'agent-plugins-dir': { type: 'string' },
 	'show-versions': { type: 'boolean', cat: 'e', description: localize('showVersions', "Show versions of installed extensions, when using --list-extensions.") },

src/vs/platform/storage/common/storage.ts

@@ -54,6 +54,10 @@ export interface IApplicationStorageValueChangeEvent extends IStorageValueChange
 	readonly scope: StorageScope.APPLICATION;
 }
 
+export interface IApplicationSharedStorageValueChangeEvent extends IStorageValueChangeEvent {
+	readonly scope: StorageScope.APPLICATION_SHARED;
+}
+
 export interface IStorageService {
 
 	readonly _serviceBrand: undefined;
@@ -69,6 +73,7 @@ export interface IStorageService {
 	onDidChangeValue(scope: StorageScope.WORKSPACE, key: string | undefined, disposable: DisposableStore): Event<IWorkspaceStorageValueChangeEvent>;
 	onDidChangeValue(scope: StorageScope.PROFILE, key: string | undefined, disposable: DisposableStore): Event<IProfileStorageValueChangeEvent>;
 	onDidChangeValue(scope: StorageScope.APPLICATION, key: string | undefined, disposable: DisposableStore): Event<IApplicationStorageValueChangeEvent>;
+	onDidChangeValue(scope: StorageScope.APPLICATION_SHARED, key: string | undefined, disposable: DisposableStore): Event<IApplicationSharedStorageValueChangeEvent>;
 	onDidChangeValue(scope: StorageScope, key: string | undefined, disposable: DisposableStore): Event<IStorageValueChangeEvent>;
 
 	/**
@@ -222,6 +227,12 @@ export interface IStorageService {
 
 export const enum StorageScope {
 
+	/**
+	 * The stored data will be scoped to all workspaces across all profiles
+	 * and shared across VS Code and Sessions app.
+	 */
+	APPLICATION_SHARED = -2,
+
 	/**
 	 * The stored data will be scoped to all workspaces across all profiles.
 	 */
@@ -340,6 +351,7 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 	onDidChangeValue(scope: StorageScope.WORKSPACE, key: string | undefined, disposable: DisposableStore): Event<IWorkspaceStorageValueChangeEvent>;
 	onDidChangeValue(scope: StorageScope.PROFILE, key: string | undefined, disposable: DisposableStore): Event<IProfileStorageValueChangeEvent>;
 	onDidChangeValue(scope: StorageScope.APPLICATION, key: string | undefined, disposable: DisposableStore): Event<IApplicationStorageValueChangeEvent>;
+	onDidChangeValue(scope: StorageScope.APPLICATION_SHARED, key: string | undefined, disposable: DisposableStore): Event<IApplicationSharedStorageValueChangeEvent>;
 	onDidChangeValue(scope: StorageScope, key: string | undefined, disposable: DisposableStore): Event<IStorageValueChangeEvent> {
 		return Event.filter(this._onDidChangeValue.event, e => e.scope === scope && (key === undefined || e.key === key), disposable);
 	}
@@ -398,6 +410,9 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 
 			// Clear our cached version which is now out of date
 			switch (scope) {
+				case StorageScope.APPLICATION_SHARED:
+					this._applicationSharedKeyTargets = undefined;
+					break;
 				case StorageScope.APPLICATION:
 					this._applicationKeyTargets = undefined;
 					break;
@@ -564,8 +579,19 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 		return this._applicationKeyTargets;
 	}
 
+	private _applicationSharedKeyTargets: IKeyTargets | undefined = undefined;
+	private get applicationSharedKeyTargets(): IKeyTargets {
+		if (!this._applicationSharedKeyTargets) {
+			this._applicationSharedKeyTargets = this.loadKeyTargets(StorageScope.APPLICATION_SHARED);
+		}
+
+		return this._applicationSharedKeyTargets;
+	}
+
 	private getKeyTargets(scope: StorageScope): IKeyTargets {
 		switch (scope) {
+			case StorageScope.APPLICATION_SHARED:
+				return this.applicationSharedKeyTargets;
 			case StorageScope.APPLICATION:
 				return this.applicationKeyTargets;
 			case StorageScope.PROFILE:
@@ -591,6 +617,7 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 		this._onWillSaveState.fire({ reason });
 
 		const applicationStorage = this.getStorage(StorageScope.APPLICATION);
+		const applicationSharedStorage = this.getStorage(StorageScope.APPLICATION_SHARED);
 		const profileStorage = this.getStorage(StorageScope.PROFILE);
 		const workspaceStorage = this.getStorage(StorageScope.WORKSPACE);
 
@@ -600,6 +627,7 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 			case WillSaveStateReason.NONE:
 				await Promises.settled([
 					applicationStorage?.whenFlushed() ?? Promise.resolve(),
+					applicationSharedStorage?.whenFlushed() ?? Promise.resolve(),
 					profileStorage?.whenFlushed() ?? Promise.resolve(),
 					workspaceStorage?.whenFlushed() ?? Promise.resolve()
 				]);
@@ -610,6 +638,7 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 			case WillSaveStateReason.SHUTDOWN:
 				await Promises.settled([
 					applicationStorage?.flush(0) ?? Promise.resolve(),
+					applicationSharedStorage?.flush(0) ?? Promise.resolve(),
 					profileStorage?.flush(0) ?? Promise.resolve(),
 					workspaceStorage?.flush(0) ?? Promise.resolve()
 				]);
@@ -619,14 +648,17 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 
 	async log(): Promise<void> {
 		const applicationItems = this.getStorage(StorageScope.APPLICATION)?.items ?? new Map<string, string>();
+		const applicationSharedItems = this.getStorage(StorageScope.APPLICATION_SHARED)?.items ?? new Map<string, string>();
 		const profileItems = this.getStorage(StorageScope.PROFILE)?.items ?? new Map<string, string>();
 		const workspaceItems = this.getStorage(StorageScope.WORKSPACE)?.items ?? new Map<string, string>();
 
 		return logStorage(
 			applicationItems,
+			applicationSharedItems,
 			profileItems,
 			workspaceItems,
 			this.getLogDetails(StorageScope.APPLICATION) ?? '',
+			this.getLogDetails(StorageScope.APPLICATION_SHARED) ?? '',
 			this.getLogDetails(StorageScope.PROFILE) ?? '',
 			this.getLogDetails(StorageScope.WORKSPACE) ?? ''
 		);
@@ -707,6 +739,7 @@ export function isProfileUsingDefaultStorage(profile: IUserDataProfile): boolean
 export class InMemoryStorageService extends AbstractStorageService {
 
 	private readonly applicationStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));
+	private readonly applicationSharedStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));
 	private readonly profileStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));
 	private readonly workspaceStorage = this._register(new Storage(new InMemoryStorageDatabase(), { hint: StorageHint.STORAGE_IN_MEMORY }));
 
@@ -716,10 +749,13 @@ export class InMemoryStorageService extends AbstractStorageService {
 		this._register(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.WORKSPACE, e)));
 		this._register(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.PROFILE, e)));
 		this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.APPLICATION, e)));
+		this._register(this.applicationSharedStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.APPLICATION_SHARED, e)));
 	}
 
 	protected getStorage(scope: StorageScope): IStorage {
 		switch (scope) {
+			case StorageScope.APPLICATION_SHARED:
+				return this.applicationSharedStorage;
 			case StorageScope.APPLICATION:
 				return this.applicationStorage;
 			case StorageScope.PROFILE:
@@ -731,6 +767,8 @@ export class InMemoryStorageService extends AbstractStorageService {
 
 	protected getLogDetails(scope: StorageScope): string | undefined {
 		switch (scope) {
+			case StorageScope.APPLICATION_SHARED:
+				return 'inMemory (application-shared)';
 			case StorageScope.APPLICATION:
 				return 'inMemory (application)';
 			case StorageScope.PROFILE:
@@ -759,7 +797,7 @@ export class InMemoryStorageService extends AbstractStorageService {
 	}
 }
 
-export async function logStorage(application: Map<string, string>, profile: Map<string, string>, workspace: Map<string, string>, applicationPath: string, profilePath: string, workspacePath: string): Promise<void> {
+export async function logStorage(application: Map<string, string>, applicationShared: Map<string, string>, profile: Map<string, string>, workspace: Map<string, string>, applicationPath: string, applicationSharedPath: string, profilePath: string, workspacePath: string): Promise<void> {
 	const safeParse = (value: string) => {
 		try {
 			return JSON.parse(value);
@@ -775,6 +813,13 @@ export async function logStorage(application: Map<string, string>, profile: Map<
 		applicationItemsParsed.set(key, safeParse(value));
 	});
 
+	const applicationSharedItems = new Map<string, string>();
+	const applicationSharedItemsParsed = new Map<string, string>();
+	applicationShared.forEach((value, key) => {
+		applicationSharedItems.set(key, value);
+		applicationSharedItemsParsed.set(key, safeParse(value));
+	});
+
 	const profileItems = new Map<string, string>();
 	const profileItemsParsed = new Map<string, string>();
 	profile.forEach((value, key) => {
@@ -803,6 +848,16 @@ export async function logStorage(application: Map<string, string>, profile: Map<
 
 	console.log(applicationItemsParsed);
 
+	console.group(`Storage: Application Shared (path: ${applicationSharedPath})`);
+	const applicationSharedValues: { key: string; value: string }[] = [];
+	applicationSharedItems.forEach((value, key) => {
+		applicationSharedValues.push({ key, value });
+	});
+	console.table(applicationSharedValues);
+	console.groupEnd();
+
+	console.log(applicationSharedItemsParsed);
+
 	if (applicationPath !== profilePath) {
 		console.group(`Storage: Profile (path: ${profilePath}, profile specific)`);
 		const profileValues: { key: string; value: string }[] = [];