@theia/terminal 1.42.1 → 1.43.0

package/src/node/shell-terminal-server.ts

@@ -17,18 +17,32 @@
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { ILogger } from '@theia/core/lib/common/logger';
 import { EnvironmentUtils } from '@theia/core/lib/node/environment-utils';
-import { IShellTerminalServerOptions } from '../common/shell-terminal-protocol';
 import { BaseTerminalServer } from './base-terminal-server';
-import { ShellProcessFactory } from './shell-process';
-import { ProcessManager } from '@theia/process/lib/node';
+import { ShellProcessFactory, getRootPath } from './shell-process';
+import { ProcessManager, TerminalProcess } from '@theia/process/lib/node';
 import { isWindows } from '@theia/core/lib/common/os';
 import * as cp from 'child_process';
+import {
+    EnvironmentVariableCollectionWithPersistence, EnvironmentVariableMutatorType, NO_ROOT_URI, SerializableEnvironmentVariableCollection,
+    IShellTerminalServer, IShellTerminalServerOptions
+}
+    from '../common/shell-terminal-protocol';
+import { URI } from '@theia/core';
+import { MultiKeyMap } from '@theia/core/lib/common/collections';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering/markdown-string';
 
-@injectable()
-export class ShellTerminalServer extends BaseTerminalServer {
+interface SerializedExtensionEnvironmentVariableCollection {
+    extensionIdentifier: string,
+    rootUri: string,
+    collection: SerializableEnvironmentVariableCollection,
+}
 
+@injectable()
+export class ShellTerminalServer extends BaseTerminalServer implements IShellTerminalServer {
     @inject(EnvironmentUtils) protected environmentUtils: EnvironmentUtils;
 
+    readonly collections: MultiKeyMap<string, EnvironmentVariableCollectionWithPersistence> = new MultiKeyMap(2);
+
     constructor(
         @inject(ShellProcessFactory) protected readonly shellFactory: ShellProcessFactory,
         @inject(ProcessManager) processManager: ProcessManager,
@@ -40,7 +54,7 @@ export class ShellTerminalServer extends BaseTerminalServer {
         try {
             if (options.strictEnv !== true) {
                 options.env = this.environmentUtils.mergeProcessEnv(options.env);
-                this.mergedCollection.applyToProcessEnvironment(options.env);
+                this.applyToProcessEnvironment(URI.fromFilePath(getRootPath(options.rootURI)), options.env);
             }
             const term = this.shellFactory(options);
             this.postCreate(term);
@@ -92,4 +106,116 @@ export class ShellTerminalServer extends BaseTerminalServer {
         // fall back to safe side
         return Promise.resolve(true);
     }
+
+    applyToProcessEnvironment(cwdUri: URI, env: { [key: string]: string | null }): void {
+        let lowerToActualVariableNames: {
+            [lowerKey: string]: string | undefined
+        } | undefined;
+        if (isWindows) {
+            lowerToActualVariableNames = {};
+            Object.keys(env).forEach(e => lowerToActualVariableNames![e.toLowerCase()] = e);
+        }
+        this.collections.forEach((mutators, [extensionIdentifier, rootUri]) => {
+            if (rootUri === NO_ROOT_URI || this.matchesRootUri(cwdUri, rootUri)) {
+                mutators.variableMutators.forEach((mutator, variable) => {
+                    const actualVariable = isWindows ? lowerToActualVariableNames![variable.toLowerCase()] || variable : variable;
+                    switch (mutator.type) {
+                        case EnvironmentVariableMutatorType.Append:
+                            env[actualVariable] = (env[actualVariable] || '') + mutator.value;
+                            break;
+                        case EnvironmentVariableMutatorType.Prepend:
+                            env[actualVariable] = mutator.value + (env[actualVariable] || '');
+                            break;
+                        case EnvironmentVariableMutatorType.Replace:
+                            env[actualVariable] = mutator.value;
+                            break;
+                    }
+                });
+            }
+        });
+    }
+
+    matchesRootUri(cwdUri: URI, rootUri: string): boolean {
+        return new URI(rootUri).isEqualOrParent(cwdUri);
+    }
+
+    /*---------------------------------------------------------------------------------------------
+  *  Copyright (c) Microsoft Corporation. All rights reserved.
+  *  Licensed under the MIT License. See License.txt in the project root for license information.
+  *--------------------------------------------------------------------------------------------*/
+    // some code copied and modified from https://github.com/microsoft/vscode/blob/1.49.0/src/vs/workbench/contrib/terminal/common/environmentVariableService.ts
+
+    setCollection(extensionIdentifier: string, baseUri: string, persistent: boolean,
+        collection: SerializableEnvironmentVariableCollection): void {
+        this.doSetCollection(extensionIdentifier, baseUri, persistent, collection);
+        this.updateCollections();
+    }
+
+    private doSetCollection(extensionIdentifier: string, baseUri: string, persistent: boolean,
+        collection: SerializableEnvironmentVariableCollection): void {
+        this.collections.set([extensionIdentifier, baseUri], {
+            persistent: persistent,
+            description: collection.description,
+            variableMutators: new Map(collection.mutators)
+        });
+    }
+
+    restorePersisted(jsonValue: string): void {
+        const collectionsJson: SerializedExtensionEnvironmentVariableCollection[] = JSON.parse(jsonValue);
+        collectionsJson.forEach(c => this.doSetCollection(c.extensionIdentifier, c.rootUri ?? NO_ROOT_URI, true, c.collection));
+
+    }
+
+    deleteCollection(extensionIdentifier: string): void {
+        this.collections.delete([extensionIdentifier]);
+        this.updateCollections();
+    }
+
+    private updateCollections(): void {
+        this.persistCollections();
+    }
+
+    protected persistCollections(): void {
+        const collectionsJson: SerializedExtensionEnvironmentVariableCollection[] = [];
+        this.collections.forEach((collection, [extensionIdentifier, rootUri]) => {
+            if (collection.persistent) {
+                collectionsJson.push({
+                    extensionIdentifier,
+                    rootUri,
+                    collection: {
+                        description: collection.description,
+                        mutators: [...this.collections.get([extensionIdentifier, rootUri])!.variableMutators.entries()]
+                    },
+                });
+            }
+        });
+        if (this.client) {
+            const stringifiedJson = JSON.stringify(collectionsJson);
+            this.client.storeTerminalEnvVariables(stringifiedJson);
+        }
+    }
+
+    async getEnvVarCollectionDescriptionsByExtension(id: number): Promise<Map<string, (string | MarkdownString | undefined)[]>> {
+        const terminal = this.processManager.get(id);
+        if (!(terminal instanceof TerminalProcess)) {
+            throw new Error(`terminal "${id}" does not exist`);
+        }
+        const result = new Map<string, (string | MarkdownString | undefined)[]>();
+        this.collections.forEach((value, key) => {
+            const prev = result.get(key[0]) || [];
+            prev.push(value.description);
+            result.set(key[0], prev);
+        });
+        return result;
+    }
+
+    async getEnvVarCollections(): Promise<[string, string, boolean, SerializableEnvironmentVariableCollection][]> {
+        const result: [string, string, boolean, SerializableEnvironmentVariableCollection][] = [];
+
+        this.collections.forEach((value, [extensionIdentifier, rootUri]) => {
+            result.push([extensionIdentifier, rootUri, value.persistent, { description: value.description, mutators: [...value.variableMutators.entries()] }]);
+        });
+
+        return result;
+    }
 }