@theia/workspace 1.68.0 → 1.68.1

package/src/browser/metadata-storage/workspace-metadata-storage-service.ts

@@ -0,0 +1,244 @@
+/********************************************************************************
+ * Copyright (C) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { URI } from '@theia/core/lib/common/uri';
+import { generateUuid } from '@theia/core/lib/common/uuid';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { WorkspaceService } from '../workspace-service';
+import { WorkspaceMetadataStore, WorkspaceMetadataStoreImpl } from './workspace-metadata-store';
+
+export const WorkspaceMetadataStoreFactory = Symbol('WorkspaceMetadataStoreFactory');
+export type WorkspaceMetadataStoreFactory = () => WorkspaceMetadataStoreImpl;
+
+/**
+ * Index mapping workspace root paths to UUIDs.
+ * Stored at $CONFIGDIR/workspace-metadata/index.json
+ */
+export interface WorkspaceMetadataIndex {
+    [workspacePath: string]: string; // workspace path -> UUID
+}
+
+/**
+ * Service for managing workspace-specific metadata storage.
+ * Provides isolated storage directories for different features within a workspace.
+ *
+ * This is different to the `WorkspaceStorageService` in that it is an unlimited free-form
+ * storage area _in the filesystem_ and not in the browser's local storage.
+ */
+export const WorkspaceMetadataStorageService = Symbol('WorkspaceMetadataStorageService');
+export interface WorkspaceMetadataStorageService {
+    /**
+     * Gets an existing metadata store for the given key, or creates a new one if it doesn't exist.
+     *
+     * @param key A unique identifier for the metadata store. Special characters will be replaced with hyphens.
+     * @returns The existing or newly created WorkspaceMetadataStore instance
+     * @throws Error if no workspace is currently open
+     */
+    getOrCreateStore(key: string): Promise<WorkspaceMetadataStore>;
+}
+
+@injectable()
+export class WorkspaceMetadataStorageServiceImpl implements WorkspaceMetadataStorageService {
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    @inject(EnvVariablesServer)
+    protected readonly envVariableServer: EnvVariablesServer;
+
+    @inject(ILogger) @named('WorkspaceMetadataStorage')
+    protected readonly logger: ILogger;
+
+    @inject(WorkspaceMetadataStoreFactory)
+    protected readonly storeFactory: WorkspaceMetadataStoreFactory;
+
+    /**
+     * Registry of created stores by their mangled keys
+     */
+    protected readonly stores = new Map<string, WorkspaceMetadataStore>();
+
+    /**
+     * Cached metadata root directory (e.g., file://$CONFIGDIR/workspace-metadata/)
+     */
+    protected metadataRoot?: URI;
+
+    /**
+     * Cached index file location
+     */
+    protected indexFile?: URI;
+
+    async getOrCreateStore(key: string): Promise<WorkspaceMetadataStore> {
+        const mangledKey = this.mangleKey(key);
+
+        const existingStore = this.stores.get(mangledKey);
+        if (existingStore) {
+            this.logger.debug(`Returning existing metadata store for key '${key}'`, {
+                mangledKey,
+                location: existingStore.location.toString()
+            });
+            return existingStore;
+        }
+
+        return this.doCreateStore(key, mangledKey);
+    }
+
+    protected async doCreateStore(key: string, mangledKey: string): Promise<WorkspaceMetadataStore> {
+        const workspaceRoot = this.getFirstWorkspaceRoot();
+        if (!workspaceRoot) {
+            throw new Error('Cannot create metadata store: no workspace is currently open');
+        }
+
+        const workspaceUuid = await this.getOrCreateWorkspaceUUID(workspaceRoot);
+        const storeLocation = await this.getStoreLocation(workspaceUuid, mangledKey);
+        const store = this.storeFactory();
+
+        store.initialize(
+            mangledKey,
+            storeLocation,
+            async () => this.resolveStoreLocation(mangledKey),
+            () => this.stores.delete(mangledKey)
+        );
+
+        this.stores.set(mangledKey, store);
+
+        this.logger.debug(`Created metadata store for key '${key}'`, {
+            mangledKey,
+            location: storeLocation.toString()
+        });
+
+        return store;
+    }
+
+    /**
+     * Mangles a key to make it safe for use as a directory name.
+     * Replaces all characters except alphanumerics, hyphens, and underscores with hyphens.
+     */
+    protected mangleKey(key: string): string {
+        return key.replace(/[^a-zA-Z0-9-_]/g, '-');
+    }
+
+    protected getFirstWorkspaceRoot(): URI | undefined {
+        const roots = this.workspaceService.tryGetRoots();
+        return roots.length > 0 ? roots[0].resource : undefined;
+    }
+
+    /**
+     * Gets or creates a UUID for the given workspace root.
+     * UUIDs are stored in an index file and reused if the same workspace is opened again.
+     */
+    protected async getOrCreateWorkspaceUUID(workspaceRoot: URI): Promise<string> {
+        const index = await this.loadIndex();
+        const workspacePath = workspaceRoot.path.toString();
+
+        if (index[workspacePath]) {
+            return index[workspacePath];
+        }
+
+        const newUuid = generateUuid();
+        index[workspacePath] = newUuid;
+
+        await this.saveIndex(index);
+
+        this.logger.debug('Generated new UUID for workspace', {
+            workspacePath,
+            uuid: newUuid
+        });
+
+        return newUuid;
+    }
+
+    protected async loadIndex(): Promise<WorkspaceMetadataIndex> {
+        const indexFileUri = await this.getIndexFile();
+
+        try {
+            const exists = await this.fileService.exists(indexFileUri);
+            if (!exists) {
+                return {};
+            }
+
+            const content = await this.fileService.readFile(indexFileUri);
+            return JSON.parse(content.value.toString()) as WorkspaceMetadataIndex;
+        } catch (error) {
+            this.logger.warn('Failed to load workspace metadata index, using empty index', error);
+            return {};
+        }
+    }
+
+    protected async saveIndex(index: WorkspaceMetadataIndex): Promise<void> {
+        const indexFileUri = await this.getIndexFile();
+
+        try {
+            // Ensure metadata root exists
+            const metadataRootUri = await this.getMetadataRoot();
+            await this.fileService.createFolder(metadataRootUri);
+
+            // Write index file
+            const content = JSON.stringify(index, undefined, 2);
+            await this.fileService.writeFile(
+                indexFileUri,
+                BinaryBuffer.fromString(content)
+            );
+        } catch (error) {
+            this.logger.error('Failed to save workspace metadata index', error);
+            throw error;
+        }
+    }
+
+    protected async getMetadataRoot(): Promise<URI> {
+        if (!this.metadataRoot) {
+            const configDirUri = await this.envVariableServer.getConfigDirUri();
+            this.metadataRoot = new URI(configDirUri).resolve('workspace-metadata');
+        }
+        return this.metadataRoot;
+    }
+
+    protected async getIndexFile(): Promise<URI> {
+        if (!this.indexFile) {
+            const metadataRoot = await this.getMetadataRoot();
+            this.indexFile = metadataRoot.resolve('index.json');
+        }
+        return this.indexFile;
+    }
+
+    /**
+     * Gets the location for a store given a workspace UUID and mangled key.
+     */
+    protected async getStoreLocation(workspaceUuid: string, mangledKey: string): Promise<URI> {
+        const metadataRoot = await this.getMetadataRoot();
+        return metadataRoot.resolve(workspaceUuid).resolve(mangledKey);
+    }
+
+    /**
+     * Resolves the current store location for a given mangled key.
+     * Used when workspace changes to get the new location.
+     */
+    protected async resolveStoreLocation(mangledKey: string): Promise<URI> {
+        const workspaceRoot = this.getFirstWorkspaceRoot();
+        if (!workspaceRoot) {
+            throw new Error('No workspace is currently open');
+        }
+
+        const workspaceUuid = await this.getOrCreateWorkspaceUUID(workspaceRoot);
+        return this.getStoreLocation(workspaceUuid, mangledKey);
+    }
+}

package/src/browser/metadata-storage/workspace-metadata-store.ts

@@ -0,0 +1,172 @@
+/********************************************************************************
+ * Copyright (C) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { ILogger, Emitter, Event, Disposable, DisposableCollection, URI } from '@theia/core/lib/common';
+import { WorkspaceService } from '../workspace-service';
+
+/**
+ * Represents a metadata store for a specific key within a workspace.
+ * The store provides access to a dedicated directory for storing workspace-specific metadata.
+ */
+export interface WorkspaceMetadataStore extends Disposable {
+    /**
+     * The key identifying this metadata store.
+     */
+    readonly key: string;
+
+    /**
+     * The URI location of the metadata store directory.
+     */
+    readonly location: URI;
+
+    /**
+     * Event that fires when the location of the metadata store changes.
+     * It is the client's responsibility to reload or reinitialize any metadata from
+     * or in the new location.
+     */
+    readonly onDidChangeLocation: Event<URI>;
+
+    /**
+     * Ensures that the metadata store directory exists on disk.
+     * Creates the directory if it doesn't exist.
+     */
+    ensureExists(): Promise<void>;
+
+    /**
+     * Deletes the metadata store directory and all of its contents.
+     */
+    delete(): Promise<void>;
+}
+
+/**
+ * Implementation of WorkspaceMetadataStore.
+ * @internal
+ */
+@injectable()
+export class WorkspaceMetadataStoreImpl implements WorkspaceMetadataStore {
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    @inject(ILogger) @named('WorkspaceMetadataStorage')
+    protected readonly logger: ILogger;
+
+    protected readonly toDispose = new DisposableCollection();
+
+    protected readonly onDidChangeLocationEmitter = new Emitter<URI>();
+    readonly onDidChangeLocation: Event<URI> = this.onDidChangeLocationEmitter.event;
+
+    protected _location: URI;
+    protected _key: string;
+    protected currentWorkspaceRoot?: URI;
+    protected locationProvider: () => Promise<URI>;
+    protected onDisposeCallback?: () => void;
+
+    get location(): URI {
+        return this._location;
+    }
+
+    get key(): string {
+        return this._key;
+    }
+
+    /**
+     * Initializes the WorkspaceMetadataStore.
+     * @param key The key identifying this store
+     * @param initialLocation The initial location URI
+     * @param locationProvider Function to resolve the current location based on workspace changes
+     * @param onDispose Callback invoked when the store is disposed
+     */
+    initialize(key: string, initialLocation: URI, locationProvider: () => Promise<URI>, onDispose?: () => void): void {
+        this._key = key;
+        this._location = initialLocation;
+        this.locationProvider = locationProvider;
+        this.onDisposeCallback = onDispose;
+        this.currentWorkspaceRoot = this.getFirstWorkspaceRoot();
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this.toDispose.push(this.onDidChangeLocationEmitter);
+        this.toDispose.push(
+            this.workspaceService.onWorkspaceChanged(() => this.handleWorkspaceChange())
+        );
+    }
+
+    protected async handleWorkspaceChange(): Promise<void> {
+        const newWorkspaceRoot = this.getFirstWorkspaceRoot();
+
+        // Check if the first workspace root actually changed
+        if (this.currentWorkspaceRoot?.toString() !== newWorkspaceRoot?.toString()) {
+            this.currentWorkspaceRoot = newWorkspaceRoot;
+
+            try {
+                const newLocation = await this.locationProvider();
+                if (this._location.toString() !== newLocation.toString()) {
+                    this._location = newLocation;
+                    this.onDidChangeLocationEmitter.fire(newLocation);
+                    this.logger.debug(`Metadata store location changed for key '${this._key}'`, {
+                        newLocation: newLocation.toString()
+                    });
+                }
+            } catch (error) {
+                this.logger.error(`Failed to update location for metadata store '${this._key}'`, error);
+            }
+        }
+    }
+
+    protected getFirstWorkspaceRoot(): URI | undefined {
+        const roots = this.workspaceService.tryGetRoots();
+        return roots.length > 0 ? roots[0].resource : undefined;
+    }
+
+    async ensureExists(): Promise<void> {
+        try {
+            await this.fileService.createFolder(this._location);
+            this.logger.debug(`Ensured metadata store exists for key '${this._key}'`, {
+                location: this._location.toString()
+            });
+        } catch (error) {
+            this.logger.error(`Failed to create metadata store directory for key '${this._key}'`, error);
+            throw error;
+        }
+    }
+
+    async delete(): Promise<void> {
+        try {
+            const exists = await this.fileService.exists(this._location);
+            if (exists) {
+                await this.fileService.delete(this._location, { recursive: true, useTrash: false });
+                this.logger.debug(`Deleted metadata store for key '${this._key}'`, {
+                    location: this._location.toString()
+                });
+            }
+        } catch (error) {
+            this.logger.error(`Failed to delete metadata store directory for key '${this._key}'`, error);
+            throw error;
+        }
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+        this.onDisposeCallback?.();
+    }
+}

package/src/browser/workspace-frontend-module.ts

@@ -57,6 +57,8 @@ import { WorkspaceUserWorkingDirectoryProvider } from './workspace-user-working-
 import { WindowTitleUpdater } from '@theia/core/lib/browser/window/window-title-updater';
 import { WorkspaceWindowTitleUpdater } from './workspace-window-title-updater';
 import { CanonicalUriService } from './canonical-uri-service';
+import { WorkspaceMetadataStorageService, WorkspaceMetadataStorageServiceImpl, WorkspaceMetadataStoreFactory } from './metadata-storage';
+import { WorkspaceMetadataStoreImpl } from './metadata-storage/workspace-metadata-store';
 
 export default new ContainerModule((bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind) => {
     bindWorkspacePreferences(bind);
@@ -101,6 +103,11 @@ export default new ContainerModule((bind: interfaces.Bind, unbind: interfaces.Un
     bind(WorkspaceStorageService).toSelf().inSingletonScope();
     rebind(StorageService).toService(WorkspaceStorageService);
 
+    bind(WorkspaceMetadataStoreImpl).toSelf();
+    bind(WorkspaceMetadataStoreFactory).toFactory(ctx => () => ctx.container.get(WorkspaceMetadataStoreImpl));
+    bind(WorkspaceMetadataStorageServiceImpl).toSelf().inSingletonScope();
+    bind(WorkspaceMetadataStorageService).toService(WorkspaceMetadataStorageServiceImpl);
+
     bind(LabelProviderContribution).to(WorkspaceUriLabelProviderContribution).inSingletonScope();
     bind(WorkspaceVariableContribution).toSelf().inSingletonScope();
     bind(VariableContribution).toService(WorkspaceVariableContribution);

package/src/browser/workspace-trust-service.ts

@@ -394,12 +394,11 @@ export class WorkspaceTrustService {
                 this.storage.setData(STORAGE_TRUSTED, undefined);
             }
 
-            if (change.preferenceName === WORKSPACE_TRUST_ENABLED && this.isWorkspaceTrustResolved() && await this.confirmRestart()) {
-                this.windowService.setSafeToShutDown();
-                this.windowService.reload();
-            }
-
             if (change.preferenceName === WORKSPACE_TRUST_ENABLED) {
+                if (!await this.isEmptyWorkspace() && this.isWorkspaceTrustResolved() && await this.confirmRestart()) {
+                    this.windowService.setSafeToShutDown();
+                    this.windowService.reload();
+                }
                 this.resolveWorkspaceTrust();
             }