@theia/workspace 1.22.0-next.7 → 1.22.1

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

@@ -15,17 +15,17 @@
  ********************************************************************************/
 
 import { injectable, inject } from '@theia/core/shared/inversify';
-import { CommandContribution, CommandRegistry, MenuContribution, MenuModelRegistry, SelectionService, MessageService, isWindows } from '@theia/core/lib/common';
+import { CommandContribution, CommandRegistry, MenuContribution, MenuModelRegistry, SelectionService, MessageService, isWindows, MaybeArray } from '@theia/core/lib/common';
 import { isOSX, environment, OS } from '@theia/core';
 import {
     open, OpenerService, CommonMenus, StorageService, LabelProvider, ConfirmDialog, KeybindingRegistry, KeybindingContribution,
-    CommonCommands, FrontendApplicationContribution, ApplicationShell, Saveable, SaveableSource, Widget, Navigatable, SHELL_TABBAR_CONTEXT_COPY
+    CommonCommands, FrontendApplicationContribution, ApplicationShell, Saveable, SaveableSource, Widget, Navigatable, SHELL_TABBAR_CONTEXT_COPY, OnWillStopAction
 } from '@theia/core/lib/browser';
 import { FileDialogService, OpenFileDialogProps, FileDialogTreeFilters } from '@theia/filesystem/lib/browser';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { WorkspaceService } from './workspace-service';
 import { THEIA_EXT, VSCODE_EXT } from '../common';
-import { WorkspaceCommands } from './workspace-commands';
+import { WorkspaceCommands, WorkspaceCommandContribution } from './workspace-commands';
 import { QuickOpenWorkspace } from './quick-open-workspace';
 import { WorkspacePreferences } from './workspace-preferences';
 import URI from '@theia/core/lib/common/uri';
@@ -35,6 +35,9 @@ import { UTF8 } from '@theia/core/lib/common/encodings';
 import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import { PreferenceConfigurations } from '@theia/core/lib/browser/preferences/preference-configurations';
 import { nls } from '@theia/core/lib/common/nls';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { FileStat } from '@theia/filesystem/lib/common/files';
+import { UntitledWorkspaceExitDialog } from './untitled-workspace-exit-dialog';
 
 export enum WorkspaceStates {
     /**
@@ -51,6 +54,7 @@ export enum WorkspaceStates {
     folder = 'folder',
 };
 export type WorkspaceState = keyof typeof WorkspaceStates;
+export type WorkbenchState = keyof typeof WorkspaceStates;
 
 @injectable()
 export class WorkspaceFrontendContribution implements CommandContribution, KeybindingContribution, MenuContribution, FrontendApplicationContribution {
@@ -67,6 +71,7 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
     @inject(WorkspacePreferences) protected preferences: WorkspacePreferences;
     @inject(SelectionService) protected readonly selectionService: SelectionService;
     @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
+    @inject(WorkspaceCommandContribution) protected readonly workspaceCommands: WorkspaceCommandContribution;
 
     @inject(ContextKeyService)
     protected readonly contextKeyService: ContextKeyService;
@@ -90,11 +95,16 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
         const updateWorkspaceStateKey = () => workspaceStateKey.set(this.updateWorkspaceStateKey());
         updateWorkspaceStateKey();
 
+        const workbenchStateKey = this.contextKeyService.createKey<WorkbenchState>('workbenchState', 'empty');
+        const updateWorkbenchStateKey = () => workbenchStateKey.set(this.updateWorkbenchStateKey());
+        updateWorkbenchStateKey();
+
         this.updateStyles();
         this.workspaceService.onWorkspaceChanged(() => {
             this.updateEncodingOverrides();
             updateWorkspaceFolderCountKey();
             updateWorkspaceStateKey();
+            updateWorkbenchStateKey();
             this.updateStyles();
         });
     }
@@ -308,32 +318,64 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
     }
 
     /**
-     * Opens a folder after prompting the `Open Folder` dialog. Resolves to `undefined`, if
-     *  - the workspace root is not set,
-     *  - the folder to open does not exist, or
-     *  - it was not a directory, but a file resource.
+     * Opens one or more folders after prompting the `Open Folder` dialog. Resolves to `undefined`, if
+     *  - the user's selection is empty or contains only files.
+     *  - the new workspace is equal to the old workspace.
      *
-     * Otherwise, resolves to the URI of the folder.
+     * Otherwise, resolves to the URI of the new workspace:
+     *  - a single folder if a single folder was selected.
+     *  - a new, untitled workspace file if multiple folders were selected.
      */
     protected async doOpenFolder(): Promise<URI | undefined> {
         const props: OpenFileDialogProps = {
             title: WorkspaceCommands.OPEN_FOLDER.dialogLabel,
             canSelectFolders: true,
-            canSelectFiles: false
+            canSelectFiles: false,
+            canSelectMany: this.preferences['workspace.supportMultiRootWorkspace'],
         };
         const [rootStat] = await this.workspaceService.roots;
-        const destinationFolderUri = await this.fileDialogService.showOpenDialog(props, rootStat);
-        if (destinationFolderUri &&
-            this.getCurrentWorkspaceUri()?.toString() !== destinationFolderUri.toString()) {
-            const destinationFolder = await this.fileService.resolve(destinationFolderUri);
-            if (destinationFolder.isDirectory) {
-                this.workspaceService.open(destinationFolderUri);
-                return destinationFolderUri;
-            }
+        const targetFolders = await this.fileDialogService.showOpenDialog(props, rootStat);
+        if (targetFolders) {
+            const openableURI = await this.getOpenableWorkspaceUri(targetFolders);
+            if (openableURI) {
+                if (!this.workspaceService.workspace || !openableURI.isEqual(this.workspaceService.workspace.resource)) {
+                    this.workspaceService.open(openableURI);
+                    return openableURI;
+                }
+            };
         }
         return undefined;
     }
 
+    protected async getOpenableWorkspaceUri(uris: MaybeArray<URI>): Promise<URI | undefined> {
+        if (Array.isArray(uris)) {
+            if (uris.length < 2) {
+                return uris[0];
+            } else {
+                const foldersToOpen = (await Promise.all(uris.map(uri => this.fileService.resolve(uri))))
+                    .filter(fileStat => !!fileStat?.isDirectory);
+                if (foldersToOpen.length === 1) {
+                    return foldersToOpen[0].resource;
+                } else {
+                    return this.createMultiRootWorkspace(foldersToOpen);
+                }
+            }
+        } else {
+            return uris;
+        }
+    }
+
+    protected async createMultiRootWorkspace(roots: FileStat[]): Promise<URI> {
+        const untitledWorkspace = await this.workspaceService.getUntitledWorkspace();
+        const folders = Array.from(new Set(roots.map(stat => stat.resource.path.toString())), path => ({ path }));
+        const workspaceStat = await this.fileService.createFile(
+            untitledWorkspace,
+            BinaryBuffer.fromString(JSON.stringify({ folders }, null, 4)), // eslint-disable-line no-null/no-null
+            { overwrite: true }
+        );
+        return workspaceStat.resource;
+    }
+
     /**
      * Opens a workspace after raising the `Open Workspace` dialog. Resolves to the URI of the recently opened workspace,
      * if it was successful. Otherwise, resolves to `undefined`.
@@ -396,7 +438,10 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
         }
     }
 
-    protected async saveWorkspaceAs(): Promise<void> {
+    /**
+     * @returns whether the file was successfully saved.
+     */
+    protected async saveWorkspaceAs(): Promise<boolean> {
         let exist: boolean = false;
         let overwrite: boolean = false;
         let selected: URI | undefined;
@@ -418,8 +463,14 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
         } while (selected && exist && !overwrite);
 
         if (selected) {
-            this.workspaceService.save(selected);
+            try {
+                await this.workspaceService.save(selected);
+                return true;
+            } catch {
+                this.messageService.error(nls.localizeByDefault("Unable to save workspace '{0}'", selected.path.toString()));
+            }
         }
+        return false;
     }
 
     /**
@@ -495,8 +546,16 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
     }
 
     protected updateWorkspaceStateKey(): WorkspaceState {
+        return this.doUpdateState();
+    }
+
+    protected updateWorkbenchStateKey(): WorkbenchState {
+        return this.doUpdateState();
+    }
+
+    protected doUpdateState(): WorkspaceState | WorkbenchState {
         if (this.workspaceService.opened) {
-            return this.workspaceService.isMultiRootWorkspaceOpened ? 'folder' : 'workspace';
+            return this.workspaceService.isMultiRootWorkspaceOpened ? 'workspace' : 'folder';
         }
         return 'empty';
     }
@@ -527,6 +586,28 @@ export class WorkspaceFrontendContribution implements CommandContribution, Keybi
         return this.workspaceService.workspace?.resource;
     }
 
+    onWillStop(): OnWillStopAction | undefined {
+        const { workspace } = this.workspaceService;
+        if (workspace && this.workspaceService.isUntitledWorkspace(workspace.resource)) {
+            return {
+                action: async () => {
+                    const shouldSaveFile = await new UntitledWorkspaceExitDialog({
+                        title: nls.localizeByDefault('Do you want to save your workspace configuration as a file?')
+                    }).open();
+                    if (shouldSaveFile === "Don't Save") {
+                        return true;
+                    } else if (shouldSaveFile === 'Save') {
+                        return this.saveWorkspaceAs();
+                    }
+                    return false; // If cancel, prevent exit.
+
+                },
+                reason: 'Untitled workspace.',
+                // Since deleting the workspace would hobble any future functionality, run this late.
+                priority: 100,
+            };
+        }
+    }
 }
 
 export namespace WorkspaceFrontendContribution {

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

@@ -30,7 +30,7 @@ import {
 import { StorageService } from '@theia/core/lib/browser/storage-service';
 import { LabelProviderContribution } from '@theia/core/lib/browser/label-provider';
 import { VariableContribution } from '@theia/variable-resolver/lib/browser';
-import { WorkspaceServer, workspacePath } from '../common';
+import { WorkspaceServer, workspacePath, CommonWorkspaceUtils } from '../common';
 import { WorkspaceFrontendContribution } from './workspace-frontend-contribution';
 import { WorkspaceService } from './workspace-service';
 import { WorkspaceCommandContribution, FileMenuContribution, EditMenuContribution } from './workspace-commands';
@@ -95,6 +95,7 @@ export default new ContainerModule((bind: interfaces.Bind, unbind: interfaces.Un
     bind(QuickOpenWorkspace).toSelf().inSingletonScope();
 
     bind(WorkspaceUtils).toSelf().inSingletonScope();
+    bind(CommonWorkspaceUtils).toSelf().inSingletonScope();
 
     bind(WorkspaceSchemaUpdater).toSelf().inSingletonScope();
     bind(JsonSchemaContribution).toService(WorkspaceSchemaUpdater);

package/src/browser/workspace-schema-updater.ts

@@ -145,4 +145,6 @@ export const workspaceSchema: IJSONSchema = {
             }
         }
     },
+    allowComments: true,
+    allowTrailingCommas: true,
 };

package/src/browser/workspace-service.ts

@@ -16,7 +16,7 @@
 
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
-import { WorkspaceServer, THEIA_EXT, VSCODE_EXT, getTemporaryWorkspaceFileUri } from '../common';
+import { WorkspaceServer, THEIA_EXT, CommonWorkspaceUtils } from '../common';
 import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import { DEFAULT_WINDOW_HASH } from '@theia/core/lib/common/window';
 import {
@@ -24,10 +24,10 @@ import {
 } from '@theia/core/lib/browser';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
-import { ILogger, Disposable, DisposableCollection, Emitter, Event, MaybePromise, MessageService } from '@theia/core';
+import { ILogger, Disposable, DisposableCollection, Emitter, Event, MaybePromise, MessageService, nls } from '@theia/core';
 import { WorkspacePreferences } from './workspace-preferences';
 import * as jsoncparser from 'jsonc-parser';
-import * as Ajv from 'ajv';
+import * as Ajv from '@theia/core/shared/ajv';
 import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
 import { FileStat, BaseStat } from '@theia/filesystem/lib/common/files';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
@@ -82,6 +82,9 @@ export class WorkspaceService implements FrontendApplicationContribution {
     @inject(WorkspaceSchemaUpdater)
     protected readonly schemaUpdater: WorkspaceSchemaUpdater;
 
+    @inject(CommonWorkspaceUtils)
+    protected readonly utils: CommonWorkspaceUtils;
+
     protected applicationName: string;
 
     protected _ready = new Deferred<void>();
@@ -297,9 +300,8 @@ export class WorkspaceService implements FrontendApplicationContribution {
         let title: string | undefined;
         if (this._workspace) {
             const displayName = this._workspace.name;
-            if (!this._workspace.isDirectory &&
-                (displayName.endsWith(`.${THEIA_EXT}`) || displayName.endsWith(`.${VSCODE_EXT}`))) {
-                title = displayName.slice(0, displayName.lastIndexOf('.'));
+            if (this.isWorkspaceFile(this._workspace)) {
+                title = this.isUntitledWorkspace(this._workspace.resource) ? nls.localizeByDefault('Untitled (Workspace)') : displayName.slice(0, displayName.lastIndexOf('.'));
             } else {
                 title = displayName;
             }
@@ -353,12 +355,11 @@ export class WorkspaceService implements FrontendApplicationContribution {
         this.doOpen(uri, options);
     }
 
-    protected async doOpen(uri: URI, options?: WorkspaceInput): Promise<void> {
-        const rootUri = uri.toString();
-        const stat = await this.toFileStat(rootUri);
+    protected async doOpen(uri: URI, options?: WorkspaceInput): Promise<URI | undefined> {
+        const stat = await this.toFileStat(uri);
         if (stat) {
             if (!stat.isDirectory && !this.isWorkspaceFile(stat)) {
-                const message = `Not a valid workspace file: ${uri}`;
+                const message = `Not a valid workspace: ${uri.path.toString()}`;
                 this.messageService.error(message);
                 throw new Error(message);
             }
@@ -369,14 +370,14 @@ export class WorkspaceService implements FrontendApplicationContribution {
                 preserveWindow: this.preferences['workspace.preserveWindow'] || !this.opened,
                 ...options
             };
-            await this.server.setMostRecentlyUsedWorkspace(rootUri);
+            await this.server.setMostRecentlyUsedWorkspace(uri.toString());
             if (preserveWindow) {
                 this._workspace = stat;
             }
             this.openWindow(stat, { preserveWindow });
             return;
         }
-        throw new Error('Invalid workspace root URI. Expected an existing directory location.');
+        throw new Error('Invalid workspace root URI. Expected an existing directory or workspace file.');
     }
 
     /**
@@ -409,7 +410,7 @@ export class WorkspaceService implements FrontendApplicationContribution {
 
     async spliceRoots(start: number, deleteCount?: number, ...rootsToAdd: URI[]): Promise<URI[]> {
         if (!this._workspace) {
-            throw new Error('There is not active workspace');
+            throw new Error('There is no active workspace');
         }
         const dedup = new Set<string>();
         const roots = this._roots.map(root => (dedup.add(root.resource.toString()), root.resource.toString()));
@@ -437,13 +438,30 @@ export class WorkspaceService implements FrontendApplicationContribution {
     }
 
     async getUntitledWorkspace(): Promise<URI> {
-        return getTemporaryWorkspaceFileUri(this.envVariableServer);
+        const configDirURI = await this.envVariableServer.getConfigDirUri();
+        let uri;
+        let attempts = 0;
+        do {
+            attempts++;
+            uri = new URI(configDirURI).resolve(`workspaces/Untitled-${Math.round(Math.random() * 1000)}.${THEIA_EXT}`);
+            if (attempts === 10) {
+                this.messageService.warn(nls.localize(
+                    'theia/workspace-service/untitled-cleanup',
+                    'There appear to be many untitled workspace files. Please check {0} and remove any unused files.',
+                    new URI(configDirURI).resolve('workspaces').path.toString())
+                );
+            }
+            if (attempts === 50) {
+                throw new Error('Workspace Service: too many attempts to find unused filename.');
+            }
+        } while (await this.fileService.exists(uri));
+        return uri;
     }
 
     protected async writeWorkspaceFile(workspaceFile: FileStat | undefined, workspaceData: WorkspaceData): Promise<FileStat | undefined> {
         if (workspaceFile) {
             const data = JSON.stringify(WorkspaceData.transformToRelative(workspaceData, workspaceFile));
-            const edits = jsoncparser.format(data, undefined, { tabSize: 3, insertSpaces: true, eol: '' });
+            const edits = jsoncparser.format(data, undefined, { tabSize: 2, insertSpaces: true, eol: '' });
             const result = jsoncparser.applyEdits(data, edits);
             await this.fileService.write(workspaceFile.resource, result);
             return this.fileService.resolve(workspaceFile.resource);
@@ -515,7 +533,7 @@ export class WorkspaceService implements FrontendApplicationContribution {
             this.setURLFragment('');
         }
 
-        window.location.reload(true);
+        this.windowService.reload();
     }
 
     protected openNewWindow(workspacePath: string): void {
@@ -549,6 +567,11 @@ export class WorkspaceService implements FrontendApplicationContribution {
         return false;
     }
 
+    /**
+     * `true` if the current workspace is configured using a configuration file.
+     *
+     * `false` if there is no workspace or the workspace is simply a folder.
+     */
     get saved(): boolean {
         return !!this._workspace && !this._workspace.isDirectory;
     }
@@ -578,7 +601,12 @@ export class WorkspaceService implements FrontendApplicationContribution {
         Object.assign(workspaceData, await this.getWorkspaceDataFromFile());
         stat = await this.writeWorkspaceFile(stat, WorkspaceData.buildWorkspaceData(this._roots, workspaceData));
         await this.server.setMostRecentlyUsedWorkspace(resource.toString());
+        // If saving a workspace based on an untitled workspace, delete the old file.
+        const toDelete = this.isUntitledWorkspace(this.workspace?.resource) && this.workspace!.resource;
         await this.setWorkspace(stat);
+        if (toDelete && stat && !toDelete.isEqual(stat.resource)) {
+            await this.fileService.delete(toDelete).catch(() => { });
+        }
         this.onWorkspaceLocationChangedEmitter.fire(stat);
     }
 
@@ -661,8 +689,12 @@ export class WorkspaceService implements FrontendApplicationContribution {
      *
      * Example: We should not try to read the contents of an .exe file.
      */
-    protected isWorkspaceFile(fileStat: FileStat): boolean {
-        return fileStat.resource.path.ext === `.${THEIA_EXT}` || fileStat.resource.path.ext === `.${VSCODE_EXT}`;
+    protected isWorkspaceFile(candidate: FileStat | URI): boolean {
+        return this.utils.isWorkspaceFile(candidate);
+    }
+
+    isUntitledWorkspace(candidate?: URI): boolean {
+        return this.utils.isUntitledWorkspace(candidate);
     }
 
     /**
@@ -741,7 +773,10 @@ export namespace WorkspaceData {
                 if (path.startsWith('file:///')) {
                     folders.push(path);
                 } else {
-                    folders.push(workspaceFile.resource.withScheme('file').parent.resolve(path).toString());
+                    const absolutePath = workspaceFile.resource.withScheme('file').parent.resolveToAbsolute(path)?.toString();
+                    if (absolutePath) {
+                        folders.push(absolutePath.toString());
+                    }
                 }
 
             }

package/src/common/utils.ts

@@ -18,6 +18,8 @@
 
 import URI from '@theia/core/lib/common/uri';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { injectable } from '@theia/core/shared/inversify';
+import { FileStat } from '@theia/filesystem/lib/common/files';
 
 export const THEIA_EXT = 'theia-workspace';
 export const VSCODE_EXT = 'code-workspace';
@@ -29,3 +31,20 @@ export async function getTemporaryWorkspaceFileUri(envVariableServer: EnvVariabl
     const configDirUri = await envVariableServer.getConfigDirUri();
     return new URI(configDirUri).resolve(`Untitled.${THEIA_EXT}`);
 }
+
+@injectable()
+export class CommonWorkspaceUtils {
+    /**
+     * Check if the file should be considered as a workspace file.
+     *
+     * Example: We should not try to read the contents of an .exe file.
+     */
+    isWorkspaceFile(candidate: FileStat | URI): boolean {
+        const uri = FileStat.is(candidate) ? candidate.resource : candidate;
+        return uri.path.ext === `.${THEIA_EXT}` || uri.path.ext === `.${VSCODE_EXT}`;
+    }
+
+    isUntitledWorkspace(candidate?: URI): boolean {
+        return !!candidate && this.isWorkspaceFile(candidate) && candidate.path.base.startsWith('Untitled');
+    }
+}

package/src/node/default-workspace-server.ts

@@ -18,12 +18,11 @@ import * as path from 'path';
 import * as yargs from '@theia/core/shared/yargs';
 import * as fs from '@theia/core/shared/fs-extra';
 import * as jsoncparser from 'jsonc-parser';
-
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
-import { FileUri } from '@theia/core/lib/node';
+import { FileUri, BackendApplicationContribution } from '@theia/core/lib/node';
 import { CliContribution } from '@theia/core/lib/node/cli';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { WorkspaceServer } from '../common';
+import { WorkspaceServer, CommonWorkspaceUtils } from '../common';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 
 @injectable()
@@ -59,9 +58,14 @@ export class WorkspaceCliContribution implements CliContribution {
 }
 
 @injectable()
-export class DefaultWorkspaceServer implements WorkspaceServer {
+export class DefaultWorkspaceServer implements WorkspaceServer, BackendApplicationContribution {
 
     protected root: Deferred<string | undefined> = new Deferred();
+    /**
+     * Untitled workspaces that are not among the most recent N workspaces will be deleted on start. Increase this number to keep older files,
+     * lower it to delete stale untitled workspaces more aggressively.
+     */
+    protected untitledWorkspaceStaleThreshhold = 10;
 
     @inject(WorkspaceCliContribution)
     protected readonly cliParams: WorkspaceCliContribution;
@@ -69,12 +73,19 @@ export class DefaultWorkspaceServer implements WorkspaceServer {
     @inject(EnvVariablesServer)
     protected readonly envServer: EnvVariablesServer;
 
+    @inject(CommonWorkspaceUtils)
+    protected readonly utils: CommonWorkspaceUtils;
+
     @postConstruct()
     protected async init(): Promise<void> {
         const root = await this.getRoot();
         this.root.resolve(root);
     }
 
+    async onStart(): Promise<void> {
+        await this.removeOldUntitledWorkspaces();
+    }
+
     protected async getRoot(): Promise<string | undefined> {
         let root = await this.getWorkspaceURIFromCli();
         if (!root) {
@@ -115,7 +126,7 @@ export class DefaultWorkspaceServer implements WorkspaceServer {
             data.recentRoots.forEach(element => {
                 if (element.length > 0) {
                     if (this.workspaceStillExist(element)) {
-                        listUri.push(element);
+                        listUri.push(FileUri.fsPath(element));
                     }
                 }
             });
@@ -169,6 +180,19 @@ export class DefaultWorkspaceServer implements WorkspaceServer {
         const configDirUri = await this.envServer.getConfigDirUri();
         return path.resolve(FileUri.fsPath(configDirUri), 'recentworkspace.json');
     }
+
+    /**
+     * Removes untitled workspaces that are not among the most recently used workspaces.
+     * Use the `untitledWorkspaceStaleThreshhold` to configure when to delete workspaces.
+     */
+    protected async removeOldUntitledWorkspaces(): Promise<void> {
+        const recents = (await this.getRecentWorkspaces()).map(FileUri.fsPath);
+        const olderUntitledWorkspaces = recents.slice(this.untitledWorkspaceStaleThreshhold).filter(workspace => this.utils.isUntitledWorkspace(FileUri.create(workspace)));
+        await Promise.all(olderUntitledWorkspaces.map(workspace => fs.promises.unlink(FileUri.fsPath(workspace)).catch(() => { })));
+        if (olderUntitledWorkspaces.length > 0) {
+            await this.writeToUserHome({ recentRoots: await this.getRecentWorkspaces() });
+        }
+    }
 }
 
 interface RecentWorkspacePathsData {

package/src/node/workspace-backend-module.ts

@@ -16,15 +16,18 @@
 
 import { ContainerModule } from '@theia/core/shared/inversify';
 import { ConnectionHandler, JsonRpcConnectionHandler } from '@theia/core/lib/common';
-import { WorkspaceServer, workspacePath } from '../common';
+import { WorkspaceServer, workspacePath, CommonWorkspaceUtils } from '../common';
 import { DefaultWorkspaceServer, WorkspaceCliContribution } from './default-workspace-server';
 import { CliContribution } from '@theia/core/lib/node/cli';
+import { BackendApplicationContribution } from '@theia/core/lib/node';
 
 export default new ContainerModule(bind => {
     bind(WorkspaceCliContribution).toSelf().inSingletonScope();
     bind(CliContribution).toService(WorkspaceCliContribution);
     bind(DefaultWorkspaceServer).toSelf().inSingletonScope();
     bind(WorkspaceServer).toService(DefaultWorkspaceServer);
+    bind(BackendApplicationContribution).toService(WorkspaceServer);
+    bind(CommonWorkspaceUtils).toSelf().inSingletonScope();
 
     bind(ConnectionHandler).toDynamicValue(ctx =>
         new JsonRpcConnectionHandler(workspacePath, () =>