Merge from vscode a348d103d1256a06a2c9b3f9b406298a9fef6898 (#15681)

* Merge from vscode a348d103d1256a06a2c9b3f9b406298a9fef6898

* Fixes and cleanup

* Distro

* Fix hygiene yarn

* delete no yarn lock changes file

* Fix hygiene

* Fix layer check

* Fix CI

* Skip lib checks

* Remove tests deleted in vs code

* Fix tests

* Distro

* Fix tests and add removed extension point

* Skip failing notebook tests for now

* Disable broken tests and cleanup build folder

* Update yarn.lock and fix smoke tests

* Bump sqlite

* fix contributed actions and file spacing

* Fix user data path

* Update yarn.locks

Co-authored-by: ADS Merger <karlb@microsoft.com>

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

@@ -83,6 +83,7 @@ export const OPTIONS: OptionDescriptions<Required<NativeParsedArgs>> = {
 
 	'locate-extension': { type: 'string[]' },
 	'extensionDevelopmentPath': { type: 'string[]' },
+	'extensionDevelopmentKind': { type: 'string[]' },
 	'extensionTestsPath': { type: 'string' },
 	'debugId': { type: 'string' },
 	'debugRenderer': { type: 'boolean' },
@@ -95,6 +96,7 @@ export const OPTIONS: OptionDescriptions<Required<NativeParsedArgs>> = {
 	'skip-release-notes': { type: 'boolean' },
 	'disable-telemetry': { type: 'boolean' },
 	'disable-updates': { type: 'boolean' },
+	'disable-keytar': { type: 'boolean' },
 	'disable-crash-reporter': { type: 'boolean' },
 	'crash-reporter-directory': { type: 'string' },
 	'crash-reporter-id': { type: 'string' },
@@ -139,6 +141,7 @@ export const OPTIONS: OptionDescriptions<Required<NativeParsedArgs>> = {
 	'ignore-certificate-errors': { type: 'boolean' },
 	'allow-insecure-localhost': { type: 'boolean' },
 	'log-net-log': { type: 'string' },
+	'vmodule': { type: 'string' },
 	'_urls': { type: 'string[]' },
 
 	_: { type: 'string[]' } // main arguments
@@ -269,7 +272,7 @@ export function formatOptions(options: OptionDescriptions<any>, columns: number)
 }
 
 function indent(count: number): string {
-	return (<any>' ').repeat(count);
+	return ' '.repeat(count);
 }
 
 function wrapText(text: string, columns: number): string[] {

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

@@ -8,6 +8,7 @@ import { localize } from 'vs/nls';
 import { MIN_MAX_MEMORY_SIZE_MB } from 'vs/platform/files/common/files';
 import { parseArgs, ErrorReporter, OPTIONS } from 'vs/platform/environment/node/argv';
 import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
+import { IProcessEnvironment } from 'vs/base/common/platform';
 
 function parseAndValidate(cmdLineArgs: string[], reportWarnings: boolean): NativeParsedArgs {
 	const errorReporter: ErrorReporter = {
@@ -79,6 +80,6 @@ export function addArg(argv: string[], ...args: string[]): string[] {
 	return argv;
 }
 
-export function isLaunchedFromCli(env: NodeJS.ProcessEnv): boolean {
+export function isLaunchedFromCli(env: IProcessEnvironment): boolean {
 	return env['VSCODE_CLI'] === '1';
 }

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

@@ -3,254 +3,19 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as os from 'os';
-import { IDebugParams, IExtensionHostDebugParams, INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { homedir, tmpdir } from 'os';
 import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
-import * as paths from 'vs/base/node/paths';
-import * as path from 'vs/base/common/path';
-import * as resources from 'vs/base/common/resources';
-import { memoize } from 'vs/base/common/decorators';
-import product from 'vs/platform/product/common/product';
-import { toLocalISOString } from 'vs/base/common/date';
-import { FileAccess } from 'vs/base/common/network';
-import { URI } from 'vs/base/common/uri';
-import { createStaticIPCHandle } from 'vs/base/parts/ipc/node/ipc.net';
+import { getUserDataPath } from 'vs/platform/environment/node/userDataPath';
+import { AbstractNativeEnvironmentService } from 'vs/platform/environment/common/environmentService';
+import { IProductService } from 'vs/platform/product/common/productService';
 
-export class NativeEnvironmentService implements INativeEnvironmentService {
+export class NativeEnvironmentService extends AbstractNativeEnvironmentService {
 
-	declare readonly _serviceBrand: undefined;
-
-	get args(): NativeParsedArgs { return this._args; }
-
-	@memoize
-	get appRoot(): string { return path.dirname(FileAccess.asFileUri('', require).fsPath); }
-
-	readonly logsPath: string;
-
-	@memoize
-	get userHome(): URI { return URI.file(os.homedir()); }
-
-	@memoize
-	get userDataPath(): string {
-		const vscodePortable = process.env['VSCODE_PORTABLE'];
-		if (vscodePortable) {
-			return path.join(vscodePortable, 'user-data');
-		}
-
-		return parseUserDataDir(this._args, process);
-	}
-
-	@memoize
-	get appSettingsHome(): URI { return URI.file(path.join(this.userDataPath, 'User')); }
-
-	@memoize
-	get tmpDir(): URI { return URI.file(os.tmpdir()); }
-
-	@memoize
-	get userRoamingDataHome(): URI { return this.appSettingsHome; }
-
-	@memoize
-	get settingsResource(): URI { return resources.joinPath(this.userRoamingDataHome, 'settings.json'); }
-
-	@memoize
-	get userDataSyncHome(): URI { return resources.joinPath(this.userRoamingDataHome, 'sync'); }
-
-	@memoize
-	get userDataSyncLogResource(): URI { return URI.file(path.join(this.logsPath, 'userDataSync.log')); }
-
-	@memoize
-	get sync(): 'on' | 'off' | undefined { return this.args.sync; }
-
-	@memoize
-	get machineSettingsResource(): URI { return resources.joinPath(URI.file(path.join(this.userDataPath, 'Machine')), 'settings.json'); }
-
-	@memoize
-	get globalStorageHome(): URI { return URI.joinPath(this.appSettingsHome, 'globalStorage'); }
-
-	@memoize
-	get workspaceStorageHome(): URI { return URI.joinPath(this.appSettingsHome, 'workspaceStorage'); }
-
-	@memoize
-	get keybindingsResource(): URI { return resources.joinPath(this.userRoamingDataHome, 'keybindings.json'); }
-
-	@memoize
-	get keyboardLayoutResource(): URI { return resources.joinPath(this.userRoamingDataHome, 'keyboardLayout.json'); }
-
-	@memoize
-	get argvResource(): URI {
-		const vscodePortable = process.env['VSCODE_PORTABLE'];
-		if (vscodePortable) {
-			return URI.file(path.join(vscodePortable, 'argv.json'));
-		}
-
-		return resources.joinPath(this.userHome, product.dataFolderName, 'argv.json');
-	}
-
-	@memoize
-	get snippetsHome(): URI { return resources.joinPath(this.userRoamingDataHome, 'snippets'); }
-
-	@memoize
-	get isExtensionDevelopment(): boolean { return !!this._args.extensionDevelopmentPath; }
-
-	@memoize
-	get untitledWorkspacesHome(): URI { return URI.file(path.join(this.userDataPath, 'Workspaces')); }
-
-	@memoize
-	get installSourcePath(): string { return path.join(this.userDataPath, 'installSource'); }
-
-	@memoize
-	get builtinExtensionsPath(): string {
-		const fromArgs = parsePathArg(this._args['builtin-extensions-dir'], process);
-		if (fromArgs) {
-			return fromArgs;
-		} else {
-			return path.normalize(path.join(FileAccess.asFileUri('', require).fsPath, '..', 'extensions'));
-		}
-	}
-
-	get extensionsDownloadPath(): string {
-		const fromArgs = parsePathArg(this._args['extensions-download-dir'], process);
-		if (fromArgs) {
-			return fromArgs;
-		} else {
-			return path.join(this.userDataPath, 'CachedExtensionVSIXs');
-		}
-	}
-
-	@memoize
-	get extensionsPath(): string {
-		const fromArgs = parsePathArg(this._args['extensions-dir'], process);
-
-		if (fromArgs) {
-			return fromArgs;
-		}
-
-		const vscodeExtensions = process.env['VSCODE_EXTENSIONS'];
-		if (vscodeExtensions) {
-			return vscodeExtensions;
-		}
-
-		const vscodePortable = process.env['VSCODE_PORTABLE'];
-		if (vscodePortable) {
-			return path.join(vscodePortable, 'extensions');
-		}
-
-		return resources.joinPath(this.userHome, product.dataFolderName, 'extensions').fsPath;
-	}
-
-	@memoize
-	get extensionDevelopmentLocationURI(): URI[] | undefined {
-		const s = this._args.extensionDevelopmentPath;
-		if (Array.isArray(s)) {
-			return s.map(p => {
-				if (/^[^:/?#]+?:\/\//.test(p)) {
-					return URI.parse(p);
-				}
-				return URI.file(path.normalize(p));
-			});
-		}
-		return undefined;
-	}
-
-	@memoize
-	get extensionTestsLocationURI(): URI | undefined {
-		const s = this._args.extensionTestsPath;
-		if (s) {
-			if (/^[^:/?#]+?:\/\//.test(s)) {
-				return URI.parse(s);
-			}
-			return URI.file(path.normalize(s));
-		}
-		return undefined;
-	}
-
-	get disableExtensions(): boolean | string[] {
-		if (this._args['disable-extensions']) {
-			return true;
-		}
-		const disableExtensions = this._args['disable-extension'];
-		if (disableExtensions) {
-			if (typeof disableExtensions === 'string') {
-				return [disableExtensions];
-			}
-			if (Array.isArray(disableExtensions) && disableExtensions.length > 0) {
-				return disableExtensions;
-			}
-		}
-		return false;
-	}
-
-	@memoize
-	get debugExtensionHost(): IExtensionHostDebugParams { return parseExtensionHostPort(this._args, this.isBuilt); }
-	get debugRenderer(): boolean { return !!this._args.debugRenderer; }
-
-	get isBuilt(): boolean { return !process.env['VSCODE_DEV']; }
-	get verbose(): boolean { return !!this._args.verbose; }
-	get logLevel(): string | undefined { return this._args.log; }
-
-	@memoize
-	get sharedIPCHandle(): string { return createStaticIPCHandle(this.userDataPath, 'shared', product.version); }
-
-	@memoize
-	get serviceMachineIdResource(): URI { return resources.joinPath(URI.file(this.userDataPath), 'machineid'); }
-
-	get crashReporterId(): string | undefined { return this._args['crash-reporter-id']; }
-	get crashReporterDirectory(): string | undefined { return this._args['crash-reporter-directory']; }
-
-	get driverHandle(): string | undefined { return this._args['driver']; }
-
-	@memoize
-	get telemetryLogResource(): URI { return URI.file(path.join(this.logsPath, 'telemetry.log')); }
-	get disableTelemetry(): boolean { return !!this._args['disable-telemetry']; }
-
-	constructor(protected _args: NativeParsedArgs) {
-		if (!_args.logsPath) {
-			const key = toLocalISOString(new Date()).replace(/-|:|\.\d+Z$/g, '');
-			_args.logsPath = path.join(this.userDataPath, 'logs', key);
-		}
-		// {{SQL CARBON EDIT}} Note we keep the VSCODE_LOGS var above in case merges come in that use that so we don't
-		//                     break functionality. ADS code should always use ADS_LOGS when referring to the log path
-		if (!process.env['ADS_LOGS']) {
-			const key = toLocalISOString(new Date()).replace(/-|:|\.\d+Z$/g, '');
-			process.env['ADS_LOGS'] = path.join(this.userDataPath, 'logs', key);
-		}
-
-		this.logsPath = process.env['ADS_LOGS']!;
+	constructor(args: NativeParsedArgs, productService: IProductService) {
+		super(args, {
+			homeDir: homedir(),
+			tmpDir: tmpdir(),
+			userDataDir: getUserDataPath(args)
+		}, productService);
 	}
 }
-
-export function parseExtensionHostPort(args: NativeParsedArgs, isBuild: boolean): IExtensionHostDebugParams {
-	return parseDebugPort(args['inspect-extensions'], args['inspect-brk-extensions'], 5870, isBuild, args.debugId);
-}
-
-export function parseSearchPort(args: NativeParsedArgs, isBuild: boolean): IDebugParams {
-	return parseDebugPort(args['inspect-search'], args['inspect-brk-search'], 5876, isBuild);
-}
-
-function parseDebugPort(debugArg: string | undefined, debugBrkArg: string | undefined, defaultBuildPort: number, isBuild: boolean, debugId?: string): IExtensionHostDebugParams {
-	const portStr = debugBrkArg || debugArg;
-	const port = Number(portStr) || (!isBuild ? defaultBuildPort : null);
-	const brk = port ? Boolean(!!debugBrkArg) : false;
-
-	return { port, break: brk, debugId };
-}
-
-export function parsePathArg(arg: string | undefined, process: NodeJS.Process): string | undefined {
-	if (!arg) {
-		return undefined;
-	}
-
-	// Determine if the arg is relative or absolute, if relative use the original CWD
-	// (VSCODE_CWD), not the potentially overridden one (process.cwd()).
-	const resolved = path.resolve(arg);
-
-	if (path.normalize(arg) === resolved) {
-		return resolved;
-	}
-
-	return path.resolve(process.env['VSCODE_CWD'] || process.cwd(), arg);
-}
-
-export function parseUserDataDir(args: NativeParsedArgs, process: NodeJS.Process): string {
-	return parsePathArg(args['user-data-dir'], process) || path.resolve(paths.getDefaultUserDataPath());
-}

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

@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { generateUuid } from 'vs/base/common/uuid';
+import { IProcessEnvironment, isWindows, OS } from 'vs/base/common/platform';
+import { ILogService } from 'vs/platform/log/common/log';
+import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
+import { isLaunchedFromCli } from 'vs/platform/environment/node/argvHelper';
+import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { getSystemShell } from 'vs/base/node/shell';
+
+/**
+ * We need to get the environment from a user's shell.
+ * This should only be done when Code itself is not launched
+ * from within a shell.
+ */
+export async function resolveShellEnv(logService: ILogService, args: NativeParsedArgs, env: IProcessEnvironment): Promise<typeof process.env> {
+
+	// Skip if --force-disable-user-env
+	if (args['force-disable-user-env']) {
+		logService.trace('resolveShellEnv(): skipped (--force-disable-user-env)');
+
+		return {};
+	}
+
+	// Skip on windows
+	else if (isWindows) {
+		logService.trace('resolveShellEnv(): skipped (Windows)');
+
+		return {};
+	}
+
+	// Skip if running from CLI already
+	else if (isLaunchedFromCli(env) && !args['force-user-env']) {
+		logService.trace('resolveShellEnv(): skipped (VSCODE_CLI is set)');
+
+		return {};
+	}
+
+	// Otherwise resolve (macOS, Linux)
+	else {
+		if (isLaunchedFromCli(env)) {
+			logService.trace('resolveShellEnv(): running (--force-user-env)');
+		} else {
+			logService.trace('resolveShellEnv(): running (macOS/Linux)');
+		}
+
+		if (!unixShellEnvPromise) {
+			unixShellEnvPromise = doResolveUnixShellEnv(logService);
+		}
+
+		return unixShellEnvPromise;
+	}
+}
+
+let unixShellEnvPromise: Promise<typeof process.env> | undefined = undefined;
+
+async function doResolveUnixShellEnv(logService: ILogService): Promise<typeof process.env> {
+	const promise = new Promise<typeof process.env>(async (resolve, reject) => {
+		const runAsNode = process.env['ELECTRON_RUN_AS_NODE'];
+		logService.trace('getUnixShellEnvironment#runAsNode', runAsNode);
+
+		const noAttach = process.env['ELECTRON_NO_ATTACH_CONSOLE'];
+		logService.trace('getUnixShellEnvironment#noAttach', noAttach);
+
+		const mark = generateUuid().replace(/-/g, '').substr(0, 12);
+		const regex = new RegExp(mark + '(.*)' + mark);
+
+		const env = {
+			...process.env,
+			ELECTRON_RUN_AS_NODE: '1',
+			ELECTRON_NO_ATTACH_CONSOLE: '1'
+		};
+
+		logService.trace('getUnixShellEnvironment#env', env);
+		const systemShellUnix = await getSystemShell(OS, env);
+		logService.trace('getUnixShellEnvironment#shell', systemShellUnix);
+
+		// handle popular non-POSIX shells
+		const name = path.basename(systemShellUnix);
+		let command: string, shellArgs: Array<string>;
+		if (/^pwsh(-preview)?$/.test(name)) {
+			// Older versions of PowerShell removes double quotes sometimes so we use "double single quotes" which is how
+			// you escape single quotes inside of a single quoted string.
+			command = `& '${process.execPath}' -p '''${mark}'' + JSON.stringify(process.env) + ''${mark}'''`;
+			shellArgs = ['-Login', '-Command'];
+		} else {
+			command = `'${process.execPath}' -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;
+			shellArgs = ['-ilc'];
+		}
+
+		logService.trace('getUnixShellEnvironment#spawn', JSON.stringify(shellArgs), command);
+
+		const child = spawn(systemShellUnix, [...shellArgs, command], {
+			detached: true,
+			stdio: ['ignore', 'pipe', 'pipe'],
+			env
+		});
+
+		child.on('error', err => {
+			logService.error('getUnixShellEnvironment#errorChildProcess', toErrorMessage(err));
+			resolve({});
+		});
+
+		const buffers: Buffer[] = [];
+		child.stdout.on('data', b => buffers.push(b));
+
+		const stderr: Buffer[] = [];
+		child.stderr.on('data', b => stderr.push(b));
+
+		child.on('close', (code, signal) => {
+			const raw = Buffer.concat(buffers).toString('utf8');
+			logService.trace('getUnixShellEnvironment#raw', raw);
+
+			const stderrStr = Buffer.concat(stderr).toString('utf8');
+			if (stderrStr.trim()) {
+				logService.trace('getUnixShellEnvironment#stderr', stderrStr);
+			}
+
+			if (code || signal) {
+				return reject(new Error(`Failed to get environment (code ${code}, signal ${signal})`));
+			}
+
+			const match = regex.exec(raw);
+			const rawStripped = match ? match[1] : '{}';
+
+			try {
+				const env = JSON.parse(rawStripped);
+
+				if (runAsNode) {
+					env['ELECTRON_RUN_AS_NODE'] = runAsNode;
+				} else {
+					delete env['ELECTRON_RUN_AS_NODE'];
+				}
+
+				if (noAttach) {
+					env['ELECTRON_NO_ATTACH_CONSOLE'] = noAttach;
+				} else {
+					delete env['ELECTRON_NO_ATTACH_CONSOLE'];
+				}
+
+				// https://github.com/microsoft/vscode/issues/22593#issuecomment-336050758
+				delete env['XDG_RUNTIME_DIR'];
+
+				logService.trace('getUnixShellEnvironment#result', env);
+				resolve(env);
+			} catch (err) {
+				logService.error('getUnixShellEnvironment#errorCaught', toErrorMessage(err));
+				reject(err);
+			}
+		});
+	});
+
+	try {
+		return await promise;
+	} catch (error) {
+		logService.error('getUnixShellEnvironment#error', toErrorMessage(error));
+
+		return {}; // ignore any errors
+	}
+}

src/vs/platform/environment/node/userDataPath.d.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
+
+/**
+ * Returns the user data path to use with some rules:
+ * - respect portable mode
+ * - respect --user-data-dir CLI argument
+ * - respect VSCODE_APPDATA environment variable
+ */
+export function getUserDataPath(args: NativeParsedArgs): string;

src/vs/platform/environment/node/userDataPath.js

@@ -0,0 +1,122 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path="../../../../typings/require.d.ts" />
+
+//@ts-check
+(function () {
+	'use strict';
+
+	/**
+	 * @typedef {import('../../environment/common/argv').NativeParsedArgs} NativeParsedArgs
+	 *
+	 * @param {typeof import('path')} path
+	 * @param {typeof import('os')} os
+	 * @param {string} productName
+	 * @param {string} cwd
+	 */
+	function factory(path, os, productName, cwd) {
+
+		/**
+		 * @param {NativeParsedArgs} cliArgs
+		 *
+		 * @returns {string}
+		 */
+		function getUserDataPath(cliArgs) {
+			const userDataPath = doGetUserDataPath(cliArgs);
+			const pathsToResolve = [userDataPath];
+
+			// If the user-data-path is not absolute, make
+			// sure to resolve it against the passed in
+			// current working directory. We cannot use the
+			// node.js `path.resolve()` logic because it will
+			// not pick up our `VSCODE_CWD` environment variable
+			// (https://github.com/microsoft/vscode/issues/120269)
+			if (!path.isAbsolute(userDataPath)) {
+				pathsToResolve.unshift(cwd);
+			}
+
+			return path.resolve(...pathsToResolve);
+		}
+
+		/**
+		 * @param {NativeParsedArgs} cliArgs
+		 *
+		 * @returns {string}
+		 */
+		function doGetUserDataPath(cliArgs) {
+
+			// 1. Support portable mode
+			const portablePath = process.env['VSCODE_PORTABLE'];
+			if (portablePath) {
+				return path.join(portablePath, 'user-data');
+			}
+
+			// 2. Support explicit --user-data-dir
+			const cliPath = cliArgs['user-data-dir'];
+			if (cliPath) {
+				return cliPath;
+			}
+
+			// 3. Support global VSCODE_APPDATA environment variable
+			let appDataPath = process.env['VSCODE_APPDATA'];
+
+			// 4. Otherwise check per platform
+			if (!appDataPath) {
+				switch (process.platform) {
+					case 'win32':
+						appDataPath = process.env['APPDATA'];
+						if (!appDataPath) {
+							const userProfile = process.env['USERPROFILE'];
+							if (typeof userProfile !== 'string') {
+								throw new Error('Windows: Unexpected undefined %USERPROFILE% environment variable');
+							}
+
+							appDataPath = path.join(userProfile, 'AppData', 'Roaming');
+						}
+						break;
+					case 'darwin':
+						appDataPath = path.join(os.homedir(), 'Library', 'Application Support');
+						break;
+					case 'linux':
+						appDataPath = process.env['XDG_CONFIG_HOME'] || path.join(os.homedir(), '.config');
+						break;
+					default:
+						throw new Error('Platform not supported');
+				}
+			}
+
+			return path.join(appDataPath, 'azuredatastudio'); // {{SQL CARBON EDIT}} hard-code Azure Data Studio
+		}
+
+		return {
+			getUserDataPath
+		};
+	}
+
+	if (typeof define === 'function') {
+		define(['require', 'path', 'os', 'vs/base/common/network', 'vs/base/common/resources', 'vs/base/common/process'], function (
+			require,
+			/** @type {typeof import('path')} */ path,
+			/** @type {typeof import('os')} */ os,
+			/** @type {typeof import('../../../base/common/network')} */ network,
+			/** @type {typeof import("../../../base/common/resources")} */ resources,
+			/** @type {typeof import("../../../base/common/process")} */ process
+		) {
+			const rootPath = resources.dirname(network.FileAccess.asFileUri('', require));
+			const pkg = require.__$__nodeRequire(resources.joinPath(rootPath, 'package.json').fsPath);
+
+			return factory(path, os, pkg.name, process.cwd());
+		}); // amd
+	} else if (typeof module === 'object' && typeof module.exports === 'object') {
+		const pkg = require('../../../../../package.json');
+		const path = require('path');
+		const os = require('os');
+
+		module.exports = factory(path, os, pkg.name, process.env['VSCODE_CWD'] || process.cwd()); // commonjs
+	} else {
+		throw new Error('Unknown context');
+	}
+}());

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

@@ -3,15 +3,12 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-/**
- * This code is also used by standalone cli's. Avoid adding dependencies to keep the size of the cli small.
- */
-import * as path from 'vs/base/common/path';
-import * as os from 'os';
 import * as fs from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'vs/base/common/path';
 
 export function createWaitMarkerFile(verbose?: boolean): string | undefined {
-	const randomWaitMarkerPath = path.join(os.tmpdir(), Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 10));
+	const randomWaitMarkerPath = join(tmpdir(), Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 10));
 
 	try {
 		fs.writeFileSync(randomWaitMarkerPath, ''); // use built-in fs to avoid dragging in more dependencies