Add multi-root choice experience to powershell.cwd

src/features/UpdatePowerShell.ts

@@ -164,9 +164,9 @@ export async function InvokePowerShellUpdateCheck(
                 // Invoke the MSI via cmd.
                 const msi = spawn("msiexec", ["/i", msiDownloadPath]);
 
-                msi.on("close", (code) => {
+                msi.on("close", async () => {
                     // Now that the MSI is finished, start the Integrated Console session.
-                    sessionManager.start();
+                    await sessionManager.start();
                     fs.unlinkSync(msiDownloadPath);
                 });
 

src/main.ts

@@ -52,19 +52,25 @@ const documentSelector: DocumentSelector = [
     { language: "powershell", scheme: "untitled" },
 ];
 
-export function activate(context: vscode.ExtensionContext): IPowerShellExtensionClient {
-    // create telemetry reporter on extension activation
+// NOTE: Now that this is async, we can probably improve a lot!
+export async function activate(context: vscode.ExtensionContext): Promise<IPowerShellExtensionClient> {
     telemetryReporter = new TelemetryReporter(PackageJSON.name, PackageJSON.version, AI_KEY);
 
-    // If both extensions are enabled, this will cause unexpected behavior since both register the same commands
+    // If both extensions are enabled, this will cause unexpected behavior since both register the same commands.
+    // TODO: Merge extensions and use preview channel in marketplace instead.
     if (PackageJSON.name.toLowerCase() === "powershell-preview"
         && vscode.extensions.getExtension("ms-vscode.powershell")) {
         vscode.window.showWarningMessage(
             "'PowerShell' and 'PowerShell Preview' are both enabled. Please disable one for best performance.");
     }
 
+    // This displays a popup and a changelog after an update.
     checkForUpdatedVersion(context, PackageJSON.version);
 
+    // Load and validate settings (will prompt for 'cwd' if necessary).
+    await Settings.validateCwdSetting();
+    const extensionSettings = Settings.load();
+
     vscode.languages.setLanguageConfiguration(
         PowerShellLanguageId,
         {
@@ -118,11 +124,8 @@ export function activate(context: vscode.ExtensionContext): IPowerShellExtension
             ],
         });
 
-    // Create the logger
+    // Setup the logger.
     logger = new Logger();
-
-    // Set the log level
-    const extensionSettings = Settings.load();
     logger.MinimumLogLevel = LogLevel[extensionSettings.developer.editorServicesLogLevel];
 
     sessionManager =
@@ -169,7 +172,7 @@ export function activate(context: vscode.ExtensionContext): IPowerShellExtension
     sessionManager.setLanguageClientConsumers(languageClientConsumers);
 
     if (extensionSettings.startAutomatically) {
-        sessionManager.start();
+        await sessionManager.start();
     }
 
     return {

src/session.ts

@@ -103,8 +103,10 @@ export class SessionManager implements Middleware {
         this.languageClientConsumers = languageClientConsumers;
     }
 
-    public start(exeNameOverride?: string) {
+    public async start(exeNameOverride?: string) {
+        await Settings.validateCwdSetting();
         this.sessionSettings = Settings.load();
+
         if (exeNameOverride) {
             this.sessionSettings.powerShellDefaultVersion = exeNameOverride;
         }
@@ -240,9 +242,9 @@ export class SessionManager implements Middleware {
         this.sessionStatus = SessionStatus.NotStarted;
     }
 
-    public restartSession(exeNameOverride?: string) {
+    public async restartSession(exeNameOverride?: string) {
         this.stop();
-        this.start(exeNameOverride);
+        await this.start(exeNameOverride);
     }
 
     public getSessionDetails(): utils.IEditorServicesSessionDetails {
@@ -387,14 +389,16 @@ export class SessionManager implements Middleware {
         }
     }
 
-    private onConfigurationUpdated() {
+    private async onConfigurationUpdated() {
         const settings = Settings.load();
 
         this.focusConsoleOnExecute = settings.integratedConsole.focusConsoleOnExecute;
 
         // Detect any setting changes that would affect the session
         if (!this.suppressRestartPrompt &&
-            (settings.powerShellDefaultVersion.toLowerCase() !==
+            (settings.cwd.toLowerCase() !==
+                this.sessionSettings.cwd.toLowerCase() ||
+                settings.powerShellDefaultVersion.toLowerCase() !==
                 this.sessionSettings.powerShellDefaultVersion.toLowerCase() ||
              settings.developer.editorServicesLogLevel.toLowerCase() !==
                 this.sessionSettings.developer.editorServicesLogLevel.toLowerCase() ||
@@ -403,14 +407,13 @@ export class SessionManager implements Middleware {
             settings.integratedConsole.useLegacyReadLine !==
                 this.sessionSettings.integratedConsole.useLegacyReadLine)) {
 
-            vscode.window.showInformationMessage(
+            const response: string = await vscode.window.showInformationMessage(
                 "The PowerShell runtime configuration has changed, would you like to start a new session?",
-                "Yes", "No")
-                .then((response) => {
+                "Yes", "No");
+
                     if (response === "Yes") {
-                        this.restartSession();
+                        await this.restartSession();
                     }
-                });
         }
     }
 
@@ -433,7 +436,7 @@ export class SessionManager implements Middleware {
         this.registeredCommands = [
             vscode.commands.registerCommand("PowerShell.RestartSession", () => { this.restartSession(); }),
             vscode.commands.registerCommand(this.ShowSessionMenuCommandName, () => { this.showSessionMenu(); }),
-            vscode.workspace.onDidChangeConfiguration(() => this.onConfigurationUpdated()),
+            vscode.workspace.onDidChangeConfiguration(async () => { await this.onConfigurationUpdated(); }),
             vscode.commands.registerCommand(
                 "PowerShell.ShowSessionConsole", (isExecute?: boolean) => { this.showSessionConsole(isExecute); }),
         ];
@@ -457,10 +460,10 @@ export class SessionManager implements Middleware {
                 this.sessionSettings);
 
         this.languageServerProcess.onExited(
-            () => {
+            async () => {
                 if (this.sessionStatus === SessionStatus.Running) {
                     this.setSessionStatus("Session Exited", SessionStatus.Failed);
-                    this.promptForRestart();
+                    await this.promptForRestart();
                 }
             });
 
@@ -503,11 +506,14 @@ export class SessionManager implements Middleware {
             });
     }
 
-    private promptForRestart() {
-        vscode.window.showErrorMessage(
+    private async promptForRestart() {
+        const response: string = await vscode.window.showErrorMessage(
             "The PowerShell Integrated Console (PSIC) has stopped, would you like to restart it? (IntelliSense will not work unless the PSIC is active and unblocked.)",
-            "Yes", "No")
-            .then((answer) => { if (answer === "Yes") { this.restartSession(); }});
+            "Yes", "No");
+
+        if (response === "Yes") {
+            await this.restartSession();
+        }
     }
 
     private startLanguageClient(sessionDetails: utils.IEditorServicesSessionDetails) {
@@ -756,7 +762,7 @@ export class SessionManager implements Middleware {
         // rather than pull from the settings. The issue we prevent here is when a
         // workspace setting is defined which gets priority over user settings which
         // is what the change above sets.
-        this.restartSession(exePath.displayName);
+        await this.restartSession(exePath.displayName);
     }
 
     private showSessionConsole(isExecute?: boolean) {
@@ -817,10 +823,10 @@ export class SessionManager implements Middleware {
 
             new SessionMenuItem(
                 "Restart Current Session",
-                () => {
+                async () => {
                     // We pass in the display name so we guarantee that the session
                     // will be the same PowerShell.
-                    this.restartSession(this.PowerShellExeDetails.displayName);
+                    await this.restartSession(this.PowerShellExeDetails.displayName);
                 }),
 
             new SessionMenuItem(

src/settings.ts

@@ -5,6 +5,7 @@
 
 import vscode = require("vscode");
 import utils = require("./utils");
+import os = require("os");
 
 enum CodeFormattingPreset {
     Custom,
@@ -134,10 +135,10 @@ export interface INotebooksSettings {
     saveMarkdownCellsAs?: CommentType;
 }
 
+// TODO: This could probably be async, and call `validateCwdSetting()` directly.
 export function load(): ISettings {
     const configuration: vscode.WorkspaceConfiguration =
-        vscode.workspace.getConfiguration(
-            utils.PowerShellLanguageId);
+        vscode.workspace.getConfiguration(utils.PowerShellLanguageId);
 
     const defaultBugReportingSettings: IBugReportingSettings = {
         project: "https://github.com/PowerShell/vscode-powershell",
@@ -265,17 +266,17 @@ export function load(): ISettings {
             //   is the reason terminals on macOS typically run login shells by default which set up
             //   the environment. See http://unix.stackexchange.com/a/119675/115410"
             configuration.get<IStartAsLoginShellSettings>("startAsLoginShell", defaultStartAsLoginShellSettings),
-        cwd: // TODO: Should we resolve this path and/or default to a workspace folder?
-            configuration.get<string>("cwd", null),
+        cwd: // NOTE: This must be validated at startup via `validateCwdSetting()`. There's probably a better way to do this.
+            configuration.get<string>("cwd", undefined),
     };
 }
 
 // Get the ConfigurationTarget (read: scope) of where the *effective* setting value comes from
 export async function getEffectiveConfigurationTarget(settingName: string): Promise<vscode.ConfigurationTarget> {
     const configuration = vscode.workspace.getConfiguration(utils.PowerShellLanguageId);
-
     const detail = configuration.inspect(settingName);
     let configurationTarget = null;
+
     if (typeof detail.workspaceFolderValue !== "undefined") {
         configurationTarget = vscode.ConfigurationTarget.WorkspaceFolder;
     }
@@ -294,7 +295,6 @@ export async function change(
     configurationTarget?: vscode.ConfigurationTarget | boolean): Promise<void> {
 
     const configuration = vscode.workspace.getConfiguration(utils.PowerShellLanguageId);
-
     await configuration.update(settingName, newValue, configurationTarget);
 }
 
@@ -312,3 +312,30 @@ function getWorkspaceSettingsWithDefaults<TSettings>(
     }
     return defaultSettings;
 }
+
+export async function validateCwdSetting(): Promise<string> {
+    let cwd: string = vscode.workspace.getConfiguration(utils.PowerShellLanguageId).get<string>("cwd", null);
+
+    // Only use the cwd setting if it exists.
+    if (utils.checkIfDirectoryExists(cwd)) {
+        return cwd;
+    } else {
+        // Otherwise use a workspace folder, prompting if necessary.
+        if (vscode.workspace.workspaceFolders?.length > 1) {
+            const options: vscode.WorkspaceFolderPickOptions = {
+                placeHolder: "Select a folder to use as the PowerShell extension's working directory.",
+            }
+            cwd = (await vscode.window.showWorkspaceFolderPick(options))?.uri.fsPath;
+            // Save the picked 'cwd' to the workspace settings.
+            await change("cwd", cwd);
+        } else {
+            cwd = vscode.workspace.workspaceFolders?.[0].uri.fsPath;
+        }
+        // If there were no workspace folders, or somehow they don't exist, use
+        // the home directory.
+        if (cwd === undefined || !utils.checkIfDirectoryExists(cwd)) {
+            return os.homedir();
+        }
+        return cwd;
+    }
+}

src/utils.ts

@@ -109,6 +109,16 @@ export function checkIfFileExists(filePath: string): boolean {
     }
 }
 
+export function checkIfDirectoryExists(directoryPath: string): boolean {
+    try {
+        // tslint:disable-next-line:no-bitwise
+        fs.accessSync(directoryPath, fs.constants.R_OK | fs.constants.O_DIRECTORY);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
 export function getTimestampString() {
     const time = new Date();
     return `[${time.getHours()}:${time.getMinutes()}:${time.getSeconds()}]`;