Expose shell's environment - pwsh

src/vs/platform/extensions/common/extensionsApiProposals.ts

@@ -356,6 +356,9 @@ const _allApiProposals = {
 	terminalSelection: {
 		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.terminalSelection.d.ts',
 	},
+	terminalShellEnv: {
+		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.terminalShellEnv.d.ts',
+	},
 	testObserver: {
 		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.testObserver.d.ts',
 	},

src/vs/platform/terminal/common/capabilities/capabilities.ts

@@ -70,7 +70,11 @@ export const enum TerminalCapability {
 	 * the request (task, debug, etc) provides an ID, optional marker, hoverMessage, and hidden property. When
 	 * hidden is not provided, a generic decoration is added to the buffer and overview ruler.
 	 */
-	BufferMarkDetection
+	BufferMarkDetection,
+
+	// TODO: Shell Environment --> listen to from
+	ShellEnvDetection,
+
 }
 
 /**
@@ -133,6 +137,7 @@ export interface ITerminalCapabilityImplMap {
 	[TerminalCapability.NaiveCwdDetection]: INaiveCwdDetectionCapability;
 	[TerminalCapability.PartialCommandDetection]: IPartialCommandDetectionCapability;
 	[TerminalCapability.BufferMarkDetection]: IBufferMarkCapability;
+	[TerminalCapability.ShellEnvDetection]: IShellEnvDetectionCapability;
 }
 
 export interface ICwdDetectionCapability {
@@ -143,6 +148,14 @@ export interface ICwdDetectionCapability {
 	updateCwd(cwd: string): void;
 }
 
+export interface IShellEnvDetectionCapability {
+	readonly type: TerminalCapability.ShellEnvDetection;
+	readonly onDidChangeEnv: Event<Map<string, string>>;
+	get envs(): Map<string, string>;
+	setEnvironment(envs: { [key: string]: string | undefined } | undefined, isTrusted: boolean): void;
+	applyEnvironmentDiff(envs: { [key: string]: string | undefined } | undefined): void;
+}
+
 export const enum CommandInvalidationReason {
 	Windows = 'windows',
 	NoProblemsReported = 'noProblemsReported'

src/vs/platform/terminal/common/capabilities/shellEnvDetectionCapability.ts

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IShellEnvDetectionCapability, TerminalCapability } from './capabilities.js';
+import { Emitter } from '../../../../base/common/event.js';
+
+export class ShellEnvDetectionCapability extends Disposable implements IShellEnvDetectionCapability {
+	readonly type = TerminalCapability.ShellEnvDetection;
+	private readonly _env: Map<string, string> = new Map();
+	get envs(): Map<string, string> { return this._env; }
+
+	private readonly _onDidChangeEnv = this._register(new Emitter<Map<string, string>>());
+	readonly onDidChangeEnv = this._onDidChangeEnv.event;
+
+	constructor() {
+		super();
+	}
+
+	setEnvironment(env: { [key: string]: string | undefined }, isTrusted: boolean): void {
+		if (!isTrusted) {
+			return;
+		}
+
+		this._env.clear();
+		for (const [key, value] of Object.entries(env)) {
+			if (value !== undefined) {
+				this._env.set(key, value);
+			}
+		}
+
+		// Convert to event and fire event
+		this._onDidChangeEnv.fire(this._env);
+	}
+
+	applyEnvironmentDiff(env: { [key: string]: string | undefined }): void {
+		// TODO: Implement
+		throw new Error('Method not implemented.');
+		//look at every key, fire event after applying everything.
+	}
+}
+
+// bash, pwsh => capability (env change =>) main thread (env change =>)
+// extension host [(new or changed) .cwd, .env, .shellIntegration SI Change event => ] Extension

src/vs/platform/terminal/common/xterm/shellIntegrationAddon.ts

@@ -8,7 +8,7 @@ import { Disposable, dispose, IDisposable, toDisposable } from '../../../../base
 import { TerminalCapabilityStore } from '../capabilities/terminalCapabilityStore.js';
 import { CommandDetectionCapability } from '../capabilities/commandDetectionCapability.js';
 import { CwdDetectionCapability } from '../capabilities/cwdDetectionCapability.js';
-import { IBufferMarkCapability, ICommandDetectionCapability, ICwdDetectionCapability, ISerializedCommandDetectionCapability, TerminalCapability } from '../capabilities/capabilities.js';
+import { IBufferMarkCapability, ICommandDetectionCapability, ICwdDetectionCapability, ISerializedCommandDetectionCapability, IShellEnvDetectionCapability, TerminalCapability } from '../capabilities/capabilities.js';
 import { PartialCommandDetectionCapability } from '../capabilities/partialCommandDetectionCapability.js';
 import { ILogService } from '../../../log/common/log.js';
 import { ITelemetryService } from '../../../telemetry/common/telemetry.js';
@@ -18,6 +18,7 @@ import type { ITerminalAddon, Terminal } from '@xterm/headless';
 import { URI } from '../../../../base/common/uri.js';
 import { sanitizeCwd } from '../terminalEnvironment.js';
 import { removeAnsiEscapeCodesFromPrompt } from '../../../../base/common/strings.js';
+import { ShellEnvDetectionCapability } from '../capabilities/shellEnvDetectionCapability.js';
 
 
 /**
@@ -224,6 +225,21 @@ const enum VSCodeOscPt {
 	 * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
 	 */
 	SetMark = 'SetMark',
+
+	/**
+	 * Sends the shell's environment.
+	 *
+	 * Format: `OSC 633 ; Env ; <Environment> ; <Nonce>`
+	 *
+	 *	`Environment` - A JSON string containing the shell's environment variables.
+	 *   TODO: Encoding information for commandline sequence.
+	 *  `Nonce` -  An optional nonce can be provided which is may be required by the terminal in order enable
+	 *   some features. This helps ensure no malicious command injection has occurred.
+	 *
+	 * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
+	 */
+	Env = 'Env',
+
 }
 
 /**
@@ -418,6 +434,23 @@ export class ShellIntegrationAddon extends Disposable implements IShellIntegrati
 				this._createOrGetCommandDetection(this._terminal).handleContinuationEnd();
 				return true;
 			}
+			// TODO: Name EnvJson
+			case VSCodeOscPt.Env: {
+				const arg0 = args[0];
+				const arg1 = args[1];
+				if (arg0 !== undefined) {
+					try {
+						const env = JSON.parse(deserializeMessage(arg0));
+						console.log('In zsh I want to see if arg1 is nonce ---> arg1', arg1);
+						console.log('In zsh I want to see if nonce matches ---> nonce', this._nonce);
+						this._createOrGetShellEnvDetection().setEnvironment(env, arg1 === this._nonce);
+					} catch (e) {
+						console.log('JSON.parse throw', { e, arg0 });
+						this._logService.warn('Failed to parse environment from shell integration sequence', arg0);
+					} // TODO: issue with double quotes. Dont worry about encoding variable name. Just escape the value
+				}
+				return true;
+			}
 			case VSCodeOscPt.RightPromptStart: {
 				this._createOrGetCommandDetection(this._terminal).handleRightPromptStart();
 				return true;
@@ -614,6 +647,15 @@ export class ShellIntegrationAddon extends Disposable implements IShellIntegrati
 		}
 		return bufferMarkDetection;
 	}
+
+	protected _createOrGetShellEnvDetection(): IShellEnvDetectionCapability {
+		let shellEnvDetection = this.capabilities.get(TerminalCapability.ShellEnvDetection);
+		if (!shellEnvDetection) {
+			shellEnvDetection = this._register(new ShellEnvDetectionCapability());
+			this.capabilities.add(TerminalCapability.ShellEnvDetection, shellEnvDetection);
+		}
+		return shellEnvDetection;
+	}
 }
 
 export function deserializeMessage(message: string): string {

src/vs/workbench/api/browser/mainThreadTerminalShellIntegration.ts

@@ -43,6 +43,20 @@ export class MainThreadTerminalShellIntegration extends Disposable implements Ma
 		})).event;
 		this._store.add(onDidAddCommandDetection(e => this._proxy.$shellIntegrationChange(e.instanceId)));
 
+
+		// TODO: Listen to environment changes on our new capability, send to extension host via a $... method
+		// onDidChangeTerminalShellIntegrationEnvironment
+		const envChangeEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.ShellEnvDetection, e => e.onDidChangeEnv));
+		this._store.add(envChangeEvent.event(e => {
+			console.log('True');
+
+			// convert map into keys and values
+			const keysArr = Array.from(e.data.keys());
+			const valuesArr = Array.from(e.data.values());
+			this._proxy.$shellEnvChange(e.instance.instanceId, keysArr, valuesArr);  // sending to ext host via $ method
+		}));
+
+
 		// onDidStartTerminalShellExecution
 		const commandDetectionStartEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandExecuted));
 		let currentCommand: ITerminalCommand | undefined;

src/vs/workbench/api/common/extHost.protocol.ts

@@ -2408,7 +2408,8 @@ export interface ExtHostTerminalShellIntegrationShape {
 	$shellExecutionStart(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, cwd: UriComponents | undefined): void;
 	$shellExecutionEnd(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, exitCode: number | undefined): void;
 	$shellExecutionData(instanceId: number, data: string): void;
-	$cwdChange(instanceId: number, cwd: UriComponents | undefined): void;
+	$shellEnvChange(instanceId: number, shellEnvKeys: string[], shellEnvValues: string[]): void;
+	$cwdChange(instanceId: number, cwd: UriComponents | undefined): void; // Question: MainThread vs. extHost
 	$closeTerminal(instanceId: number): void;
 }
 

src/vs/workbench/api/common/extHostTerminalShellIntegration.ts

@@ -55,30 +55,30 @@ export class ExtHostTerminalShellIntegration extends Disposable implements IExtH
 		}));
 
 		// Convenient test code:
-		// this.onDidChangeTerminalShellIntegration(e => {
-		// 	console.log('*** onDidChangeTerminalShellIntegration', e);
-		// });
-		// this.onDidStartTerminalShellExecution(async e => {
-		// 	console.log('*** onDidStartTerminalShellExecution', e);
-		// 	// new Promise<void>(r => {
-		// 	// 	(async () => {
-		// 	// 		for await (const d of e.execution.read()) {
-		// 	// 			console.log('data2', d);
-		// 	// 		}
-		// 	// 	})();
-		// 	// });
-		// 	for await (const d of e.execution.read()) {
-		// 		console.log('data', d);
-		// 	}
-		// });
-		// this.onDidEndTerminalShellExecution(e => {
-		// 	console.log('*** onDidEndTerminalShellExecution', e);
-		// });
-		// setTimeout(() => {
-		// 	console.log('before executeCommand(\"echo hello\")');
-		// 	Array.from(this._activeShellIntegrations.values())[0].value.executeCommand('echo hello');
-		// 	console.log('after executeCommand(\"echo hello\")');
-		// }, 4000);
+		this.onDidChangeTerminalShellIntegration(e => {
+			console.log('*** onDidChangeTerminalShellIntegration env', e.shellIntegration.env);
+		});
+		this.onDidStartTerminalShellExecution(async e => {
+			console.log('*** onDidStartTerminalShellExecution', e);
+			// new Promise<void>(r => {
+			// 	(async () => {
+			// 		for await (const d of e.execution.read()) {
+			// 			console.log('data2', d);
+			// 		}
+			// 	})();
+			// });
+			for await (const d of e.execution.read()) {
+				console.log('data', d);
+			}
+		});
+		this.onDidEndTerminalShellExecution(e => {
+			console.log('*** onDidEndTerminalShellExecution', e);
+		});
+		setTimeout(() => {
+			console.log('before executeCommand(\"echo hello\")');
+			Array.from(this._activeShellIntegrations.values())[0].value.executeCommand('echo hello');
+			console.log('after executeCommand(\"echo hello\")');
+		}, 4000);
 	}
 
 	public $shellIntegrationChange(instanceId: number): void {
@@ -131,6 +131,10 @@ export class ExtHostTerminalShellIntegration extends Disposable implements IExtH
 		this._activeShellIntegrations.get(instanceId)?.emitData(data);
 	}
 
+	public $shellEnvChange(instanceId: number, shellEnvKeys: string[], shellEnvValues: string[]): void {
+		this._activeShellIntegrations.get(instanceId)?.setEnv(shellEnvKeys, shellEnvValues);
+	}
+
 	public $cwdChange(instanceId: number, cwd: UriComponents | undefined): void {
 		this._activeShellIntegrations.get(instanceId)?.setCwd(URI.revive(cwd));
 	}
@@ -147,6 +151,7 @@ class InternalTerminalShellIntegration extends Disposable {
 	get currentExecution(): InternalTerminalShellExecution | undefined { return this._currentExecution; }
 
 	private _ignoreNextExecution: boolean = false;
+	private _env: { [key: string]: string | undefined } | undefined;
 	private _cwd: URI | undefined;
 
 	readonly store: DisposableStore = this._register(new DisposableStore());
@@ -171,6 +176,9 @@ class InternalTerminalShellIntegration extends Disposable {
 			get cwd(): URI | undefined {
 				return that._cwd;
 			},
+			get env(): { [key: string]: string | undefined } | undefined {
+				return that._env;
+			},
 			// executeCommand(commandLine: string): vscode.TerminalShellExecution;
 			// executeCommand(executable: string, args: string[]): vscode.TerminalShellExecution;
 			executeCommand(commandLineOrExecutable: string, args?: string[]): vscode.TerminalShellExecution {
@@ -232,6 +240,16 @@ class InternalTerminalShellIntegration extends Disposable {
 		}
 	}
 
+	setEnv(keys: string[], values: string[]): void {
+		const env: { [key: string]: string | undefined } = {};
+		for (let i = 0; i < keys.length; i++) {
+			env[keys[i]] = values[i];
+		}
+		this._env = env;
+		// TODO: Make sure env changed. If env doesnt change, dont fire event.
+		this._fireChangeEvent();
+	}
+
 	setCwd(cwd: URI | undefined): void {
 		let wasChanged = false;
 		if (URI.isUri(this._cwd)) {
@@ -241,9 +259,12 @@ class InternalTerminalShellIntegration extends Disposable {
 		}
 		if (wasChanged) {
 			this._cwd = cwd;
-			this._onDidRequestChangeShellIntegration.fire({ terminal: this._terminal, shellIntegration: this.value });
+			this._fireChangeEvent();
 		}
 	}
+	private _fireChangeEvent() {
+		this._onDidRequestChangeShellIntegration.fire({ terminal: this._terminal, shellIntegration: this.value });
+	}
 }
 
 class InternalTerminalShellExecution {

src/vs/workbench/contrib/terminal/common/scripts/shellIntegration-rc.zsh

@@ -140,7 +140,6 @@ __vsc_command_complete() {
 	fi
 	__vsc_update_cwd
 }
-
 if [[ -o NOUNSET ]]; then
 	if [ -z "${RPROMPT-}" ]; then
 		RPROMPT=""
@@ -173,6 +172,7 @@ __vsc_precmd() {
 		# non null
 		__vsc_update_prompt
 	fi
+
 }
 
 __vsc_preexec() {

src/vs/workbench/contrib/terminal/common/scripts/shellIntegration.ps1

@@ -63,6 +63,7 @@ function Global:__VSCode-Escape-Value([string]$value) {
 		})
 }
 
+
 function Global:Prompt() {
 	$FakeCode = [int]!$global:?
 	# NOTE: We disable strict mode for the scope of this function because it unhelpfully throws an
@@ -88,6 +89,16 @@ function Global:Prompt() {
 	# Current working directory
 	# OSC 633 ; <Property>=<Value> ST
 	$Result += if ($pwd.Provider.Name -eq 'FileSystem') { "$([char]0x1b)]633;P;Cwd=$(__VSCode-Escape-Value $pwd.ProviderPath)`a" }
+
+	# Send current environment variables as JSON
+	# OSC 633 ; Env ; <Environment> ; <Nonce>
+	if ($isStable -eq "0") {
+		$envMap = @{}
+		Get-ChildItem Env: | ForEach-Object { $envMap[$_.Name] = $_.Value }
+		$envJson = $envMap | ConvertTo-Json -Compress
+		$Result += "$([char]0x1b)]633;Env;$(__VSCode-Escape-Value $envJson);$Nonce`a"
+	}
+
 	# Before running the original prompt, put $? back to what it was:
 	if ($FakeCode -ne 0) {
 		Write-Error "failure" -ea ignore

src/vs/workbench/contrib/terminal/test/browser/xterm/shellIntegrationAddon.test.ts

@@ -287,6 +287,8 @@ suite('ShellIntegrationAddon', () => {
 			['escaped newline (upper hex)', `${Backslash}x0A`, Newline],
 			['escaped backslash followed by literal "x0a" is not a newline', `${Backslash}${Backslash}x0a`, `${Backslash}x0a`],
 			['non-initial escaped backslash followed by literal "x0a" is not a newline', `foo${Backslash}${Backslash}x0a`, `foo${Backslash}x0a`],
+			['PS1 simple', '[\\u@\\h \\W]\\$', '[\\u@\\h \\W]\\$'],
+			['PS1 VSC SI', `${Backslash}x1b]633;A${Backslash}x07\\[${Backslash}x1b]0;\\u@\\h:\\w\\a\\]${Backslash}x1b]633;B${Backslash}x07`, '\x1b]633;A\x07\\[\x1b]0;\\u@\\h:\\w\\a\\]\x1b]633;B\x07']
 		];
 
 		cases.forEach(([title, input, expected]) => {

src/vscode-dts/vscode.proposed.terminalShellEnv.d.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+	// @anthonykim1 @tyriar https://github.com/microsoft/vscode/issues/227467
+
+	// Expose the terminal's actual shell environment to extensions
+	export interface TerminalShellIntegration {
+		// The shell environment
+		// undefined means we don't know anything about the env
+		// NOTE: This is similar to command line in that it's verified with a nonce, however we just ignore when there's no nonce, so we don't need the trust flag like `TerminalShellExecutionCommandLine.isTrusted`
+		readonly env: { [key: string]: string | undefined } | undefined;
+	}
+
+	export namespace window {
+		// Fires when TerminalShellIntegration.env changes
+		// TODO: Should this just use `onDidChangeTerminalShellIntegration` like `TerminalShellIntegration.cwd` does?
+		export const onDidChangeTerminalShellIntegrationEnvironment: Event<TerminalShellIntegration>;
+	}
+}