@theia/plugin-ext 1.40.1 → 1.41.0

package/src/main/browser/plugin-icon-theme-service.ts

@@ -390,6 +390,12 @@ export class PluginIconTheme extends PluginIconThemeDefinition implements IconTh
     ): void {
         if (associations.folder) {
             accept(associations.folder, this.folderIcon);
+            if (associations.folderExpanded === undefined) {
+                // Use the same icon for expanded state (issue #12727). Check for
+                // undefined folderExpanded property to allow for
+                // "folderExpanded": null in case a developer really wants that
+                accept(associations.folder, this.folderExpandedIcon);
+            }
             this.hasFolderIcons = true;
         }
         if (associations.folderExpanded) {

package/src/main/browser/plugin-shared-style.ts

@@ -110,7 +110,8 @@ export class PluginSharedStyle {
         const lightIconUrl = PluginSharedStyle.toExternalIconUrl(`${typeof iconUrl === 'object' ? iconUrl.light : iconUrl}`);
         const iconClass = 'plugin-icon-' + this.iconSequence++;
         const toDispose = new DisposableCollection();
-        toDispose.push(this.insertRule('.' + iconClass, theme => `
+        toDispose.push(this.insertRule('.' + iconClass + '::before', theme => `
+                content: "";
                 background-position: 2px;
                 width: ${size}px;
                 height: ${size}px;

package/src/main/browser/tasks-main.ts

@@ -184,8 +184,8 @@ export class TasksMainImpl implements TasksMain, Disposable {
     protected createTaskProvider(handle: number): TaskProvider {
         return {
             provideTasks: () =>
-                this.proxy.$provideTasks(handle).then(v =>
-                    v!.map(taskDto =>
+                this.proxy.$provideTasks(handle).then(tasks =>
+                    tasks.map(taskDto =>
                         this.toTaskConfiguration(taskDto)
                     )
                 )
@@ -195,8 +195,8 @@ export class TasksMainImpl implements TasksMain, Disposable {
     protected createTaskResolver(handle: number): TaskResolver {
         return {
             resolveTask: taskConfig =>
-                this.proxy.$resolveTask(handle, this.fromTaskConfiguration(taskConfig)).then(v =>
-                    this.toTaskConfiguration(v!)
+                this.proxy.$resolveTask(handle, this.fromTaskConfiguration(taskConfig)).then(task =>
+                    this.toTaskConfiguration(task)
                 )
         };
     }

package/src/main/browser/terminal-main.ts

@@ -22,7 +22,7 @@ import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-servi
 import { TerminalServiceMain, TerminalServiceExt, MAIN_RPC_CONTEXT } from '../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
-import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
+import { SerializableEnvironmentVariableCollection, SerializableExtensionEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
 import { ShellTerminalServerProxy } from '@theia/terminal/lib/common/shell-terminal-protocol';
 import { TerminalLink, TerminalLinkProvider } from '@theia/terminal/lib/browser/terminal-link-provider';
 import { URI } from '@theia/core/lib/common/uri';
@@ -75,11 +75,11 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         return this.extProxy.$startProfile(id, CancellationToken.None);
     }
 
-    $setEnvironmentVariableCollection(extensionIdentifier: string, persistent: boolean, collection: SerializableEnvironmentVariableCollection | undefined): void {
-        if (collection) {
-            this.shellTerminalServer.setCollection(extensionIdentifier, persistent, collection);
+    $setEnvironmentVariableCollection(persistent: boolean, collection: SerializableExtensionEnvironmentVariableCollection): void {
+        if (collection.collection) {
+            this.shellTerminalServer.setCollection(collection.extensionIdentifier, persistent, collection.collection, collection.description);
         } else {
-            this.shellTerminalServer.deleteCollection(extensionIdentifier);
+            this.shellTerminalServer.deleteCollection(collection.extensionIdentifier);
         }
     }
 

package/src/main/browser/view/tree-view-widget.tsx

@@ -50,7 +50,7 @@ import { AccessibilityInformation } from '@theia/plugin';
 import { ColorRegistry } from '@theia/core/lib/browser/color-registry';
 import { DecoratedTreeNode } from '@theia/core/lib/browser/tree/tree-decorator';
 import { WidgetDecoration } from '@theia/core/lib/browser/widget-decoration';
-import { CancellationTokenSource, CancellationToken } from '@theia/core/lib/common';
+import { CancellationTokenSource, CancellationToken, Mutable } from '@theia/core/lib/common';
 import { mixin } from '../../../common/types';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { DnDFileContentStore } from './dnd-file-content-store';
@@ -165,6 +165,7 @@ export namespace CompositeTreeViewNode {
 @injectable()
 export class TreeViewWidgetOptions {
     id: string;
+    manageCheckboxStateManually: boolean | undefined;
     showCollapseAll: boolean | undefined;
     multiSelect: boolean | undefined;
     dragMimeTypes: string[] | undefined;
@@ -272,6 +273,37 @@ export class PluginTree extends TreeImpl {
         }, update);
     }
 
+    override markAsChecked(node: Mutable<TreeNode>, checked: boolean): void {
+        function findParentsToChange(child: TreeNode, nodes: TreeNode[]): void {
+            if ((child.parent?.checkboxInfo !== undefined && child.parent.checkboxInfo.checked !== checked) &&
+                (!checked || !child.parent.children.some(candidate => candidate !== child && candidate.checkboxInfo?.checked === false))) {
+                nodes.push(child.parent);
+                findParentsToChange(child.parent, nodes);
+            }
+        }
+
+        function findChildrenToChange(parent: TreeNode, nodes: TreeNode[]): void {
+            if (CompositeTreeNode.is(parent)) {
+                parent.children.forEach(child => {
+                    if (child.checkboxInfo !== undefined && child.checkboxInfo.checked !== checked) {
+                        nodes.push(child);
+                    }
+                    findChildrenToChange(child, nodes);
+                });
+            }
+        }
+
+        const nodesToChange = [node];
+        if (!this.options.manageCheckboxStateManually) {
+            findParentsToChange(node, nodesToChange);
+            findChildrenToChange(node, nodesToChange);
+
+        }
+        nodesToChange.forEach(n => n.checkboxInfo!.checked = checked);
+        this.onDidUpdateEmitter.fire(nodesToChange);
+        this.proxy?.$checkStateChanged(this.options.id, [{ id: node.id, checked: checked }]);
+    }
+
     /** Creates a resolvable tree node. If a node already exists, reset it because the underlying TreeViewItem might have been disposed in the backend. */
     protected createResolvableTreeNode(item: TreeViewItem, parent: CompositeTreeNode): TreeNode {
         const update: Partial<TreeViewNode> = this.createTreeNodeUpdate(item);
@@ -328,6 +360,7 @@ export class PluginTree extends TreeImpl {
             tooltip: item.tooltip,
             contextValue: item.contextValue,
             command: item.command,
+            checkboxInfo: item.checkboxInfo,
             accessibilityInformation: item.accessibilityInformation,
         };
     }
@@ -496,6 +529,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
                 ...attrs,
                 onMouseLeave: () => source?.cancel(),
                 onMouseEnter: async event => {
+                    const target = event.currentTarget; // event.currentTarget will be null after awaiting node resolve()
                     if (configuredTip) {
                         if (MarkdownString.is(node.tooltip)) {
                             this.hoverService.requestHover({
@@ -524,7 +558,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
                         const title = node.tooltip ||
                             (node.resourceUri && this.labelProvider.getLongName(new URI(node.resourceUri)))
                             || this.toNodeName(node);
-                        event.currentTarget.title = title;
+                        target.title = title;
                     }
                     configuredTip = true;
                 }

package/src/main/browser/view/tree-views-main.ts

@@ -63,6 +63,7 @@ export class TreeViewsMainImpl implements TreeViewsMain, Disposable {
         this.treeViewProviders.set(treeViewId, this.viewRegistry.registerViewDataProvider(treeViewId, async ({ state, viewInfo }) => {
             const options: TreeViewWidgetOptions = {
                 id: treeViewId,
+                manageCheckboxStateManually: $options.manageCheckboxStateManually,
                 showCollapseAll: $options.showCollapseAll,
                 multiSelect: $options.canSelectMany,
                 dragMimeTypes: $options.dragMimeTypes,
@@ -183,6 +184,13 @@ export class TreeViewsMainImpl implements TreeViewsMain, Disposable {
         }
     }
 
+    async setChecked(treeViewWidget: TreeViewWidget, changedNodes: TreeViewNode[]): Promise<void> {
+        await this.proxy.$checkStateChanged(treeViewWidget.id, changedNodes.map(node => ({
+            id: node.id,
+            checked: !!node.checkboxInfo?.checked
+        })));
+    }
+
     protected handleTreeEvents(treeViewId: string, treeViewWidget: TreeViewWidget): void {
         this.toDispose.push(treeViewWidget.model.onExpansionChanged(event => {
             this.proxy.$setExpanded(treeViewId, event.id, event.expanded);

package/src/main/browser/webview/webview.ts

@@ -592,6 +592,12 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget, Extract
         this._state = state;
     }
 
+    setIframeHeight(height: number): void {
+        if (this.element) {
+            this.element.style.height = `${height}px`;
+        }
+    }
+
     protected async doSend(channel: string, data?: any): Promise<void> {
         if (!this.element) {
             return;

package/src/main/node/errors.spec.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2023 Arduino SA 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 { rejects } from 'assert';
+import { strictEqual } from 'assert/strict';
+import { promises as fs } from 'fs';
+import { v4 } from 'uuid';
+import { isENOENT } from '../../common/errors';
+
+describe('errors', () => {
+    describe('errno-exception', () => {
+        it('should be ENOENT error', async () => {
+            await rejects(fs.readFile(v4()), reason => isENOENT(reason));
+        });
+
+        it('should not be ENOENT error (no code)', () => {
+            strictEqual(isENOENT(new Error('I am not ENOENT')), false);
+        });
+
+        it('should not be ENOENT error (other code)', async () => {
+            await rejects(fs.readdir(__filename), reason => !isENOENT(reason));
+        });
+    });
+});

package/src/main/node/handlers/plugin-theia-directory-handler.ts

@@ -17,27 +17,35 @@
 import * as path from 'path';
 import * as filenamify from 'filenamify';
 import * as fs from '@theia/core/shared/fs-extra';
+import type { URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 import { FileUri } from '@theia/core/lib/node';
 import {
     PluginDeployerDirectoryHandler, PluginDeployerEntry, PluginPackage, PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginType, PluginIdentifiers
 } from '../../../common/plugin-protocol';
 import { PluginCliContribution } from '../plugin-cli-contribution';
-import { getTempDir } from '../temp-dir-util';
+import { getTempDirPathAsync } from '../temp-dir-util';
 
 @injectable()
 export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandler {
 
-    protected readonly deploymentDirectory = FileUri.create(getTempDir('theia-copied'));
+    protected readonly deploymentDirectory: Deferred<URI>;
 
     @inject(PluginCliContribution) protected readonly pluginCli: PluginCliContribution;
 
-    accept(resolvedPlugin: PluginDeployerEntry): boolean {
+    constructor() {
+        this.deploymentDirectory = new Deferred();
+        getTempDirPathAsync('theia-copied')
+            .then(deploymentDirectory => this.deploymentDirectory.resolve(FileUri.create(deploymentDirectory)));
+    }
+
+    async accept(resolvedPlugin: PluginDeployerEntry): Promise<boolean> {
 
         console.debug('PluginTheiaDirectoryHandler: accepting plugin with path', resolvedPlugin.path());
 
         // handle only directories
-        if (resolvedPlugin.isFile()) {
+        if (await resolvedPlugin.isFile()) {
             return false;
         }
 
@@ -47,7 +55,7 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
         try {
             let packageJson = resolvedPlugin.getValue<PluginPackage>('package.json');
             if (!packageJson) {
-                packageJson = fs.readJSONSync(packageJsonPath);
+                packageJson = await fs.readJSON(packageJsonPath);
                 packageJson.publisher ??= PluginIdentifiers.UNPUBLISHED;
                 resolvedPlugin.storeValue('package.json', packageJson);
             }
@@ -81,11 +89,12 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
             const origin = entry.originalPath();
             const targetDir = await this.getExtensionDir(context);
             try {
-                if (fs.existsSync(targetDir) || !entry.path().startsWith(origin)) {
+                if (await fs.pathExists(targetDir) || !entry.path().startsWith(origin)) {
                     console.log(`[${id}]: already copied.`);
                 } else {
                     console.log(`[${id}]: copying to "${targetDir}"`);
-                    await fs.mkdirp(FileUri.fsPath(this.deploymentDirectory));
+                    const deploymentDirectory = await this.deploymentDirectory.promise;
+                    await fs.mkdirp(FileUri.fsPath(deploymentDirectory));
                     await context.copy(origin, targetDir);
                     entry.updatePath(targetDir);
                     if (!this.accept(entry)) {
@@ -100,6 +109,7 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
     }
 
     protected async getExtensionDir(context: PluginDeployerDirectoryHandlerContext): Promise<string> {
-        return FileUri.fsPath(this.deploymentDirectory.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
+        const deploymentDirectory = await this.deploymentDirectory.promise;
+        return FileUri.fsPath(deploymentDirectory.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
     }
 }

package/src/main/node/handlers/plugin-theia-file-handler.ts

@@ -15,8 +15,10 @@
 // *****************************************************************************
 
 import { PluginDeployerFileHandler, PluginDeployerEntry, PluginDeployerFileHandlerContext, PluginType } from '../../../common/plugin-protocol';
-import { injectable, inject } from '@theia/core/shared/inversify';
-import { getTempDir } from '../temp-dir-util';
+import type { URI } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { getTempDirPathAsync } from '../temp-dir-util';
 import * as fs from '@theia/core/shared/fs-extra';
 import * as filenamify from 'filenamify';
 import { FileUri } from '@theia/core/lib/node/file-uri';
@@ -25,13 +27,22 @@ import { PluginTheiaEnvironment } from '../../common/plugin-theia-environment';
 @injectable()
 export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
 
-    private readonly systemPluginsDirUri = FileUri.create(getTempDir('theia-unpacked'));
+    private readonly systemPluginsDirUri: Deferred<URI>;
 
     @inject(PluginTheiaEnvironment)
     protected readonly environment: PluginTheiaEnvironment;
 
-    accept(resolvedPlugin: PluginDeployerEntry): boolean {
-        return resolvedPlugin.isFile() && resolvedPlugin.path() !== null && resolvedPlugin.path().endsWith('.theia');
+    constructor() {
+        this.systemPluginsDirUri = new Deferred();
+        getTempDirPathAsync('theia-unpacked')
+            .then(systemPluginsDirPath => this.systemPluginsDirUri.resolve(FileUri.create(systemPluginsDirPath)));
+    }
+
+    async accept(resolvedPlugin: PluginDeployerEntry): Promise<boolean> {
+        if (resolvedPlugin.path() !== null && resolvedPlugin.path().endsWith('.theia')) {
+            return resolvedPlugin.isFile();
+        }
+        return false;
     }
 
     async handle(context: PluginDeployerFileHandlerContext): Promise<void> {
@@ -49,6 +60,7 @@ export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
     }
 
     protected async getPluginDir(context: PluginDeployerFileHandlerContext): Promise<string> {
-        return FileUri.fsPath(this.systemPluginsDirUri.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
+        const systemPluginsDirUri = await this.systemPluginsDirUri.promise;
+        return FileUri.fsPath(systemPluginsDirUri.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
     }
 }

package/src/main/node/paths/plugin-paths-service.ts

@@ -18,7 +18,8 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
-import { readdir, remove } from '@theia/core/shared/fs-extra';
+import { readdir } from 'fs/promises';
+import { remove } from '@theia/core/shared/fs-extra';
 import * as crypto from 'crypto';
 import { ILogger } from '@theia/core';
 import { FileUri } from '@theia/core/lib/node';
@@ -139,15 +140,9 @@ export class PluginPathsServiceImpl implements PluginPathsService {
     }
 
     private async cleanupOldLogs(parentLogsDir: string): Promise<void> {
-        // @ts-ignore - fs-extra types (Even latest version) is not updated with the `withFileTypes` option.
-        const dirEntries = await readdir(parentLogsDir, { withFileTypes: true }) as string[];
-        // `Dirent` type is defined in @types/node since 10.10.0
-        // However, upgrading the @types/node in theia to 10.11 (as defined in engine field)
-        // Causes other packages to break in compilation, so we are using the infamous `any` type...
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const subDirEntries = dirEntries.filter((dirent: any) => dirent.isDirectory());
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const subDirNames = subDirEntries.map((dirent: any) => dirent.name);
+        const dirEntries = await readdir(parentLogsDir, { withFileTypes: true });
+        const subDirEntries = dirEntries.filter(dirent => dirent.isDirectory());
+        const subDirNames = subDirEntries.map(dirent => dirent.name);
         // We never clean a folder that is not a Theia logs session folder.
         // Even if it does appears under the `parentLogsDir`...
         const sessionSubDirNames = subDirNames.filter((dirName: string) => SESSION_TIMESTAMP_PATTERN.test(dirName));

package/src/main/node/plugin-deployer-directory-handler-context-impl.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import * as path from 'path';
-import * as fs from '@theia/core/shared/fs-extra';
+import { promises as fs } from 'fs';
 import { PluginDeployerEntry, PluginDeployerDirectoryHandlerContext } from '../../common/plugin-protocol';
 
 export class PluginDeployerDirectoryHandlerContextImpl implements PluginDeployerDirectoryHandlerContext {
@@ -23,17 +23,17 @@ export class PluginDeployerDirectoryHandlerContextImpl implements PluginDeployer
     constructor(private readonly pluginDeployerEntry: PluginDeployerEntry) { }
 
     async copy(origin: string, target: string): Promise<void> {
-        const contents = await fs.readdir(origin);
-        await fs.mkdirp(target);
-        await Promise.all(contents.map(async item => {
+        const entries = await fs.readdir(origin, { withFileTypes: true });
+        await fs.mkdir(target, { recursive: true });
+        await Promise.all(entries.map(async entry => {
+            const item = entry.name;
             const itemPath = path.resolve(origin, item);
             const targetPath = path.resolve(target, item);
-            const stat = await fs.stat(itemPath);
-            if (stat.isDirectory()) {
+            if (entry.isDirectory()) {
                 return this.copy(itemPath, targetPath);
             }
-            if (stat.isFile()) {
-                return new Promise<void>((resolve, reject) => fs.copyFile(itemPath, targetPath, e => e === null ? resolve() : reject(e)));
+            if (entry.isFile()) {
+                return fs.copyFile(itemPath, targetPath);
             }
         }));
     }

package/src/main/node/plugin-deployer-entry-impl.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { PluginDeployerEntry, PluginDeployerEntryType, PluginType } from '../../common/plugin-protocol';
-import * as fs from 'fs';
+import { promises as fs } from 'fs';
 
 export class PluginDeployerEntryImpl implements PluginDeployerEntry {
 
@@ -73,17 +73,19 @@ export class PluginDeployerEntryImpl implements PluginDeployerEntry {
     getChanges(): string[] {
         return this.changes;
     }
-    isFile(): boolean {
+    async isFile(): Promise<boolean> {
         try {
-            return fs.statSync(this.currentPath).isFile();
-        } catch (e) {
+            const stat = await fs.stat(this.currentPath);
+            return stat.isFile();
+        } catch {
             return false;
         }
     }
-    isDirectory(): boolean {
+    async isDirectory(): Promise<boolean> {
         try {
-            return fs.statSync(this.currentPath).isDirectory();
-        } catch (e) {
+            const stat = await fs.stat(this.currentPath);
+            return stat.isDirectory();
+        } catch {
             return false;
         }
     }

package/src/main/node/plugin-deployer-impl.ts

@@ -21,8 +21,8 @@ import * as semver from 'semver';
 import {
     PluginDeployerResolver, PluginDeployerFileHandler, PluginDeployerDirectoryHandler,
     PluginDeployerEntry, PluginDeployer, PluginDeployerParticipant, PluginDeployerStartContext,
-    PluginDeployerResolverInit, PluginDeployerFileHandlerContext,
-    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions
+    PluginDeployerResolverInit,
+    PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions
 } from '../../common/plugin-protocol';
 import { PluginDeployerEntryImpl } from './plugin-deployer-entry-impl';
 import {
@@ -295,41 +295,33 @@ export class PluginDeployerImpl implements PluginDeployer {
     /**
      * If there are some single files, try to see if we can work on these files (like unpacking it, etc)
      */
-    public async applyFileHandlers(pluginDeployerEntries: PluginDeployerEntry[]): Promise<any> {
-        const waitPromises: Array<Promise<any>> = [];
-
-        pluginDeployerEntries.filter(pluginDeployerEntry => pluginDeployerEntry.isResolved()).map(pluginDeployerEntry => {
-            this.pluginDeployerFileHandlers.map(pluginFileHandler => {
+    public async applyFileHandlers(pluginDeployerEntries: PluginDeployerEntry[]): Promise<void> {
+        const waitPromises = pluginDeployerEntries.filter(pluginDeployerEntry => pluginDeployerEntry.isResolved()).flatMap(pluginDeployerEntry =>
+            this.pluginDeployerFileHandlers.map(async pluginFileHandler => {
                 const proxyPluginDeployerEntry = new ProxyPluginDeployerEntry(pluginFileHandler, (pluginDeployerEntry) as PluginDeployerEntryImpl);
-                if (pluginFileHandler.accept(proxyPluginDeployerEntry)) {
-                    const pluginDeployerFileHandlerContext: PluginDeployerFileHandlerContext = new PluginDeployerFileHandlerContextImpl(proxyPluginDeployerEntry);
-                    const promise: Promise<void> = pluginFileHandler.handle(pluginDeployerFileHandlerContext);
-                    waitPromises.push(promise);
+                if (await pluginFileHandler.accept(proxyPluginDeployerEntry)) {
+                    const pluginDeployerFileHandlerContext = new PluginDeployerFileHandlerContextImpl(proxyPluginDeployerEntry);
+                    await pluginFileHandler.handle(pluginDeployerFileHandlerContext);
                 }
-            });
-
-        });
-        return Promise.all(waitPromises);
+            })
+        );
+        await Promise.all(waitPromises);
     }
 
     /**
      * Check for all registered directories to see if there are some plugins that can be accepted to be deployed.
      */
-    public async applyDirectoryFileHandlers(pluginDeployerEntries: PluginDeployerEntry[]): Promise<any> {
-        const waitPromises: Array<Promise<any>> = [];
-
-        pluginDeployerEntries.filter(pluginDeployerEntry => pluginDeployerEntry.isResolved()).map(pluginDeployerEntry => {
-            this.pluginDeployerDirectoryHandlers.map(pluginDirectoryHandler => {
+    public async applyDirectoryFileHandlers(pluginDeployerEntries: PluginDeployerEntry[]): Promise<void> {
+        const waitPromises = pluginDeployerEntries.filter(pluginDeployerEntry => pluginDeployerEntry.isResolved()).flatMap(pluginDeployerEntry =>
+            this.pluginDeployerDirectoryHandlers.map(async pluginDirectoryHandler => {
                 const proxyPluginDeployerEntry = new ProxyPluginDeployerEntry(pluginDirectoryHandler, (pluginDeployerEntry) as PluginDeployerEntryImpl);
-                if (pluginDirectoryHandler.accept(proxyPluginDeployerEntry)) {
-                    const pluginDeployerDirectoryHandlerContext: PluginDeployerDirectoryHandlerContext = new PluginDeployerDirectoryHandlerContextImpl(proxyPluginDeployerEntry);
-                    const promise: Promise<void> = pluginDirectoryHandler.handle(pluginDeployerDirectoryHandlerContext);
-                    waitPromises.push(promise);
+                if (await pluginDirectoryHandler.accept(proxyPluginDeployerEntry)) {
+                    const pluginDeployerDirectoryHandlerContext = new PluginDeployerDirectoryHandlerContextImpl(proxyPluginDeployerEntry);
+                    await pluginDirectoryHandler.handle(pluginDeployerDirectoryHandlerContext);
                 }
-            });
-
-        });
-        return Promise.all(waitPromises);
+            })
+        );
+        await Promise.all(waitPromises);
     }
 
     /**

package/src/main/node/plugin-deployer-proxy-entry-impl.ts

@@ -54,11 +54,11 @@ export class ProxyPluginDeployerEntry<T> implements PluginDeployerEntry {
         return this.delegate.getChanges();
     }
 
-    isFile(): boolean {
+    isFile(): Promise<boolean> {
         return this.delegate.isFile();
     }
 
-    isDirectory(): boolean {
+    isDirectory(): Promise<boolean> {
         return this.delegate.isDirectory();
     }
     isResolved(): boolean {

package/src/main/node/plugin-github-resolver.ts

@@ -16,10 +16,11 @@
 
 import { RequestContext, RequestService } from '@theia/core/shared/@theia/request';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { promises as fs, existsSync, mkdirSync } from 'fs';
-import * as os from 'os';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 import { PluginDeployerResolver, PluginDeployerResolverContext } from '../../common';
+import { getTempDirPathAsync } from './temp-dir-util';
 
 /**
  * Resolver that handle the github: protocol
@@ -33,16 +34,21 @@ export class GithubPluginDeployerResolver implements PluginDeployerResolver {
 
     private static GITHUB_ENDPOINT = 'https://github.com/';
 
-    private unpackedFolder: string;
+    private unpackedFolder: Deferred<string>;
 
     @inject(RequestService)
     protected readonly request: RequestService;
 
     constructor() {
-        this.unpackedFolder = path.resolve(os.tmpdir(), 'github-remote');
-        if (!existsSync(this.unpackedFolder)) {
-            mkdirSync(this.unpackedFolder);
-        }
+        this.unpackedFolder = new Deferred();
+        getTempDirPathAsync('github-remote').then(async unpackedFolder => {
+            try {
+                await fs.mkdir(unpackedFolder, { recursive: true });
+                this.unpackedFolder.resolve(unpackedFolder);
+            } catch (err) {
+                this.unpackedFolder.reject(err);
+            }
+        });
     }
 
     /**
@@ -106,7 +112,8 @@ export class GithubPluginDeployerResolver implements PluginDeployerResolver {
      * Grab the github file specified by the plugin's ID
      */
     protected async grabGithubFile(pluginResolverContext: PluginDeployerResolverContext, orgName: string, repoName: string, filename: string, version: string): Promise<void> {
-        const unpackedPath = path.resolve(this.unpackedFolder, path.basename(version + filename));
+        const unpackedFolder = await this.unpackedFolder.promise;
+        const unpackedPath = path.resolve(unpackedFolder, path.basename(version + filename));
         try {
             await fs.access(unpackedPath);
             // use of cache. If file is already there use it directly

package/src/main/node/plugin-http-resolver.ts

@@ -16,11 +16,12 @@
 
 import { RequestContext, RequestService } from '@theia/core/shared/@theia/request';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { promises as fs, existsSync, mkdirSync } from 'fs';
-import * as os from 'os';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 import * as url from 'url';
 import { PluginDeployerResolver, PluginDeployerResolverContext } from '../../common';
+import { getTempDirPathAsync } from './temp-dir-util';
 
 /**
  * Resolver that handle the http(s): protocol
@@ -30,16 +31,21 @@ import { PluginDeployerResolver, PluginDeployerResolverContext } from '../../com
 @injectable()
 export class HttpPluginDeployerResolver implements PluginDeployerResolver {
 
-    private unpackedFolder: string;
+    private unpackedFolder: Deferred<string>;
 
     @inject(RequestService)
     protected readonly request: RequestService;
 
     constructor() {
-        this.unpackedFolder = path.resolve(os.tmpdir(), 'http-remote');
-        if (!existsSync(this.unpackedFolder)) {
-            mkdirSync(this.unpackedFolder);
-        }
+        this.unpackedFolder = new Deferred();
+        getTempDirPathAsync('http-remote').then(async unpackedFolder => {
+            try {
+                await fs.mkdir(unpackedFolder, { recursive: true });
+                this.unpackedFolder.resolve(unpackedFolder);
+            } catch (err) {
+                this.unpackedFolder.reject(err);
+            }
+        });
     }
 
     /**
@@ -58,7 +64,8 @@ export class HttpPluginDeployerResolver implements PluginDeployerResolver {
         const dirname = path.dirname(link.pathname);
         const basename = path.basename(link.pathname);
         const filename = dirname.replace(/\W/g, '_') + ('-') + basename;
-        const unpackedPath = path.resolve(this.unpackedFolder, path.basename(filename));
+        const unpackedFolder = await this.unpackedFolder.promise;
+        const unpackedPath = path.resolve(unpackedFolder, path.basename(filename));
 
         try {
             await fs.access(unpackedPath);