@sussudio/platform
Version:
Internal APIs for VS Code's service injection the base services.
199 lines (198 loc) • 7.5 kB
JavaScript
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { spawn } from 'child_process';
import { basename } from '@sussudio/base/common/path.mjs';
import { localize } from 'vscode-nls.mjs';
import { CancellationTokenSource } from '@sussudio/base/common/cancellation.mjs';
import { toErrorMessage } from '@sussudio/base/common/errorMessage.mjs';
import { CancellationError, isCancellationError } from '@sussudio/base/common/errors.mjs';
import { isWindows, OS } from '@sussudio/base/common/platform.mjs';
import { generateUuid } from '@sussudio/base/common/uuid.mjs';
import { getSystemShell } from '@sussudio/base/node/shell.mjs';
import { isLaunchedFromCli } from '../../environment/node/argvHelper.mjs';
import { Promises } from '@sussudio/base/common/async.mjs';
import { clamp } from '@sussudio/base/common/numbers.mjs';
let unixShellEnvPromise = undefined;
/**
* Resolves the shell environment by spawning a shell. This call will cache
* the shell spawning so that subsequent invocations use that cached result.
*
* Will throw an error if:
* - we hit a timeout of `MAX_SHELL_RESOLVE_TIME`
* - any other error from spawning a shell to figure out the environment
*/
export async function getResolvedShellEnv(configurationService, logService, args, 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)');
}
// Call this only once and cache the promise for
// subsequent calls since this operation can be
// expensive (spawns a process).
if (!unixShellEnvPromise) {
unixShellEnvPromise = Promises.withAsyncBody(async (resolve, reject) => {
const cts = new CancellationTokenSource();
let timeoutValue = 10000; // default to 10 seconds
const configuredTimeoutValue = configurationService.getValue('application.shellEnvironmentResolutionTimeout');
if (typeof configuredTimeoutValue === 'number') {
timeoutValue = clamp(configuredTimeoutValue, 1, 120) * 1000 /* convert from seconds */;
}
// Give up resolving shell env after some time
const timeout = setTimeout(() => {
cts.dispose(true);
reject(
new Error(
localize(
'resolveShellEnvTimeout',
'Unable to resolve your shell environment in a reasonable time. Please review your shell configuration and restart.',
),
),
);
}, timeoutValue);
// Resolve shell env and handle errors
try {
resolve(await doResolveUnixShellEnv(logService, cts.token));
} catch (error) {
if (!isCancellationError(error) && !cts.token.isCancellationRequested) {
reject(
new Error(
localize(
'resolveShellEnvError',
'Unable to resolve your shell environment: {0}',
toErrorMessage(error),
),
),
);
} else {
resolve({});
}
} finally {
clearTimeout(timeout);
cts.dispose();
}
});
}
return unixShellEnvPromise;
}
}
async function doResolveUnixShellEnv(logService, token) {
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',
VSCODE_RESOLVING_ENVIRONMENT: '1',
};
logService.trace('getUnixShellEnvironment#env', env);
const systemShellUnix = await getSystemShell(OS, env);
logService.trace('getUnixShellEnvironment#shell', systemShellUnix);
return new Promise((resolve, reject) => {
if (token.isCancellationRequested) {
return reject(new CancellationError());
}
// handle popular non-POSIX shells
const name = basename(systemShellUnix);
let command, shellArgs;
const extraArgs =
process.versions['electron'] && process.versions['microsoft-build'] ? '--ms-enable-electron-run-as-node' : '';
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}' ${extraArgs} -p '''${mark}'' + JSON.stringify(process.env) + ''${mark}'''`;
shellArgs = ['-Login', '-Command'];
} else {
command = `'${process.execPath}' ${extraArgs} -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;
if (name === 'tcsh' || name === 'csh') {
shellArgs = ['-ic'];
} else {
shellArgs = ['-i', '-l', '-c'];
}
}
logService.trace('getUnixShellEnvironment#spawn', JSON.stringify(shellArgs), command);
const child = spawn(systemShellUnix, [...shellArgs, command], {
detached: true,
stdio: ['ignore', 'pipe', 'pipe'],
env,
});
token.onCancellationRequested(() => {
child.kill();
return reject(new CancellationError());
});
child.on('error', (err) => {
logService.error('getUnixShellEnvironment#errorChildProcess', toErrorMessage(err));
reject(err);
});
const buffers = [];
child.stdout.on('data', (b) => buffers.push(b));
const stderr = [];
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(
localize(
'resolveShellEnvExitError',
'Unexpected exit code from spawned shell (code {0}, signal {1})',
code,
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'];
}
delete env['VSCODE_RESOLVING_ENVIRONMENT'];
// 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);
}
});
});
}