Add support for loading host profile scripts

This change adds support for loading both host-agnostic and host-specific
profile scripts for the current user and all users depending on which of
those scripts are available on the system.  Profile loading behavior is
opt-in and not enabled by default.  Regardless of whether profiles get
loaded, a $profile variable is inserted into the PowerShellContext's
runspace upon initialization.

Resolves #111.

Author: daviwil

src/PowerShellEditorServices.Channel.WebSocket/WebsocketServerChannel.cs

@@ -139,7 +139,7 @@ public class LanguageServerWebSocketConnection : EditorServiceWebSocketConnectio
     {
         public LanguageServerWebSocketConnection()
         {
-            Server = new LanguageServer(Channel);
+            Server = new LanguageServer(null, Channel);
         }
     }
 

src/PowerShellEditorServices.Host/Program.cs

@@ -9,7 +9,6 @@
 using System;
 using System.Diagnostics;
 using System.Linq;
-using System.Threading;
 
 namespace Microsoft.PowerShell.EditorServices.Host
 {
@@ -78,21 +77,28 @@ static void Main(string[] args)
                             "/debugAdapter",
                             StringComparison.InvariantCultureIgnoreCase));
 
-            // Catch unhandled exceptions for logging purposes
-            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+            string hostProfileId = null;
+            string hostProfileIdArgument =
+                args.FirstOrDefault(
+                    arg =>
+                        arg.StartsWith(
+                            "/hostProfileId:",
+                            StringComparison.InvariantCultureIgnoreCase));
 
-            ProtocolEndpoint server = null;
-            if (runDebugAdapter)
+            if (!string.IsNullOrEmpty(hostProfileIdArgument))
             {
-                logPath = logPath ?? "DebugAdapter.log";
-                server = new DebugAdapter();
-            }
-            else
-            {
-                logPath = logPath ?? "EditorServices.log";
-                server = new LanguageServer();
+                hostProfileId = hostProfileIdArgument.Substring(15).Trim('"');
             }
 
+            // Catch unhandled exceptions for logging purposes
+            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+
+            // Use a default log path filename if one isn't specified
+            logPath =
+                runDebugAdapter
+                ? logPath ?? "DebugAdapter.log"
+                : logPath ?? "EditorServices.log";
+
             // Start the logger with the specified log path and level
             Logger.Initialize(logPath, logLevel);
 
@@ -103,9 +109,16 @@ static void Main(string[] args)
             Logger.Write(
                 LogLevel.Normal,
                 string.Format(
-                    "PowerShell Editor Services Host v{0} starting (pid {1})...",
+                    "PowerShell Editor Services Host v{0} starting (pid {1}, hostProfileId '{2}')...",
                     fileVersionInfo.FileVersion,
-                    Process.GetCurrentProcess().Id));
+                    Process.GetCurrentProcess().Id,
+                    hostProfileId));
+
+            // Create the appropriate server type
+            ProtocolEndpoint server =
+                runDebugAdapter
+                ? (ProtocolEndpoint) new DebugAdapter()
+                : (ProtocolEndpoint) new LanguageServer(hostProfileId);
 
             // Start the server
             server.Start().Wait();

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -6,7 +6,6 @@
 using Microsoft.PowerShell.EditorServices.Protocol.LanguageServer;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
-using Microsoft.PowerShell.EditorServices.Protocol.Messages;
 using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Collections.Generic;
@@ -24,18 +23,33 @@ public class LanguageServer : LanguageServerBase
     {
         private static CancellationTokenSource existingRequestCancellation;
 
+        private bool profilesLoaded;
         private EditorSession editorSession;
         private OutputDebouncer outputDebouncer;
         private LanguageServerSettings currentSettings = new LanguageServerSettings();
 
-        public LanguageServer() : this(new StdioServerChannel())
+        /// <param name="hostProfileId">
+        /// The identifier of the PowerShell host to use for its profile path.
+        /// loaded. Used to resolve a profile path of the form 'X_profile.ps1'
+        /// where 'X' represents the value of hostProfileId.  If null, a default
+        /// will be used.
+        /// </param>
+        public LanguageServer(string hostProfileId)
+            : this(hostProfileId, new StdioServerChannel())
         {
         }
 
-        public LanguageServer(ChannelBase serverChannel) : base(serverChannel)
+        /// <param name="hostProfileId">
+        /// The identifier of the PowerShell host to use for its profile path.
+        /// loaded. Used to resolve a profile path of the form 'X_profile.ps1'
+        /// where 'X' represents the value of hostProfileId.  If null, a default
+        /// will be used.
+        /// </param>
+        public LanguageServer(string hostProfileId, ChannelBase serverChannel)
+            : base(serverChannel)
         {
             this.editorSession = new EditorSession();
-            this.editorSession.StartSession();
+            this.editorSession.StartSession(hostProfileId);
             this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
 
             // Always send console prompts through the UI in the language service
@@ -59,7 +73,7 @@ protected override void Initialize()
             this.SetEventHandler(DidOpenTextDocumentNotification.Type, this.HandleDidOpenTextDocumentNotification);
             this.SetEventHandler(DidCloseTextDocumentNotification.Type, this.HandleDidCloseTextDocumentNotification);
             this.SetEventHandler(DidChangeTextDocumentNotification.Type, this.HandleDidChangeTextDocumentNotification);
-            this.SetEventHandler(DidChangeConfigurationNotification<SettingsWrapper>.Type, this.HandleDidChangeConfigurationNotification);
+            this.SetEventHandler(DidChangeConfigurationNotification<LanguageServerSettingsWrapper>.Type, this.HandleDidChangeConfigurationNotification);
 
             this.SetRequestHandler(DefinitionRequest.Type, this.HandleDefinitionRequest);
             this.SetRequestHandler(ReferencesRequest.Type, this.HandleReferencesRequest);
@@ -287,15 +301,24 @@ protected Task HandleDidChangeTextDocumentNotification(
         }
 
         protected async Task HandleDidChangeConfigurationNotification(
-            DidChangeConfigurationParams<SettingsWrapper> configChangeParams,
+            DidChangeConfigurationParams<LanguageServerSettingsWrapper> configChangeParams,
             EventContext eventContext)
         {
+            bool oldLoadProfiles = this.currentSettings.LoadProfiles;
             bool oldScriptAnalysisEnabled =
                 this.currentSettings.ScriptAnalysis.Enable.HasValue;
 
             this.currentSettings.Update(
                 configChangeParams.Settings.Powershell);
 
+            if (!this.profilesLoaded &&
+                this.currentSettings.LoadProfiles &&
+                oldLoadProfiles != this.currentSettings.LoadProfiles)
+            {
+                await this.editorSession.PowerShellContext.LoadProfilesForHost();
+                this.profilesLoaded = true;
+            }
+
             if (oldScriptAnalysisEnabled != this.currentSettings.ScriptAnalysis.Enable)
             {
                 // If the user just turned off script analysis, send a diagnostics

src/PowerShellEditorServices.Protocol/Server/LanguageServerSettings.cs

@@ -7,6 +7,8 @@ namespace Microsoft.PowerShell.EditorServices.Protocol.Server
 {
     public class LanguageServerSettings
     {
+        public bool LoadProfiles { get; set; }
+
         public ScriptAnalysisSettings ScriptAnalysis { get; set; }
 
         public LanguageServerSettings()
@@ -18,6 +20,7 @@ public void Update(LanguageServerSettings settings)
         {
             if (settings != null)
             {
+                this.LoadProfiles = settings.LoadProfiles;
                 this.ScriptAnalysis.Update(settings.ScriptAnalysis);
             }
         }
@@ -41,7 +44,7 @@ public void Update(ScriptAnalysisSettings settings)
         }
     }
 
-    public class SettingsWrapper
+    public class LanguageServerSettingsWrapper
     {
         // NOTE: This property is capitalized as 'Powershell' because the
         // mode name sent from the client is written as 'powershell' and

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -107,6 +107,7 @@
     <Compile Include="Session\PowerShellExecutionResult.cs" />
     <Compile Include="Session\PowerShellContext.cs" />
     <Compile Include="Session\PowerShellContextState.cs" />
+    <Compile Include="Session\ProfilePaths.cs" />
     <Compile Include="Session\ProgressDetails.cs" />
     <Compile Include="Session\RunspaceHandle.cs" />
     <Compile Include="Session\SessionPSHost.cs" />

src/PowerShellEditorServices/Session/EditorSession.cs

@@ -5,12 +5,7 @@
 
 using Microsoft.PowerShell.EditorServices.Console;
 using Microsoft.PowerShell.EditorServices.Utility;
-using System;
 using System.IO;
-using System.Management.Automation;
-using System.Management.Automation.Runspaces;
-using System.Reflection;
-using System.Threading;
 
 namespace Microsoft.PowerShell.EditorServices
 {
@@ -61,9 +56,24 @@ public class EditorSession
         /// for the ConsoleService.
         /// </summary>
         public void StartSession()
+        {
+            this.StartSession(null);
+        }
+
+        /// <summary>
+        /// Starts the session using the provided IConsoleHost implementation
+        /// for the ConsoleService.
+        /// </summary>
+        /// <param name="hostProfileId">
+        /// The identifier of the PowerShell host to use for its profile path.
+        /// loaded. Used to resolve a profile path of the form 'X_profile.ps1'
+        /// where 'X' represents the value of hostProfileId.  If null, a default
+        /// will be used.
+        /// </param>
+        public void StartSession(string hostProfileId)
         {
             // Initialize all services
-            this.PowerShellContext = new PowerShellContext();
+            this.PowerShellContext = new PowerShellContext(hostProfileId);
             this.LanguageService = new LanguageService(this.PowerShellContext);
             this.DebugService = new DebugService(this.PowerShellContext);
             this.ConsoleService = new ConsoleService(this.PowerShellContext);

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -37,6 +37,7 @@ public class PowerShellContext : IDisposable
         private bool ownsInitialRunspace;
         private Runspace initialRunspace;
         private Runspace currentRunspace;
+        private ProfilePaths profilePaths;
         private ConsoleServicePSHost psHost;
         private InitialSessionState initialSessionState;
         private IVersionSpecificOperations versionSpecificOperations;
@@ -104,7 +105,21 @@ internal IConsoleHost ConsoleHost
         /// Initializes a new instance of the PowerShellContext class and
         /// opens a runspace to be used for the session.
         /// </summary>
-        public PowerShellContext()
+        public PowerShellContext() : this(null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the PowerShellContext class and
+        /// opens a runspace to be used for the session.
+        /// </summary>
+        /// <param name="hostProfileId">
+        /// The identifier of the PowerShell host to use for its profile path.
+        /// loaded. Used to resolve a profile path of the form 'X_profile.ps1'
+        /// where 'X' represents the value of hostProfileId.  If null, a default
+        /// will be used.
+        /// </param>
+        public PowerShellContext(string hostProfileId)
         {
             this.psHost = new ConsoleServicePSHost();
             this.initialSessionState = InitialSessionState.CreateDefault2();
@@ -116,7 +131,7 @@ public PowerShellContext()
 
             this.ownsInitialRunspace = true;
 
-            this.Initialize(runspace);
+            this.Initialize(hostProfileId, runspace);
 
             // Use reflection to execute ConsoleVisibility.AlwaysCaptureApplicationIO = true;
             Type consoleVisibilityType =
@@ -142,12 +157,23 @@ public PowerShellContext()
         /// an existing runspace for the session.
         /// </summary>
         /// <param name="initialRunspace"></param>
-        public PowerShellContext(Runspace initialRunspace)
+        /// <param name="hostProfileId">
+        /// The identifier of the PowerShell host to use for its profile path.
+        /// loaded. Used to resolve a profile path of the form 'X_profile.ps1'
+        /// where 'X' represents the value of hostProfileId.  If null, a default
+        /// will be used.
+        /// </param>
+        public PowerShellContext(string hostProfileId, Runspace initialRunspace)
         {
-            this.Initialize(initialRunspace);
+            this.Initialize(hostProfileId, initialRunspace);
         }
 
         private void Initialize(Runspace initialRunspace)
+        {
+            this.Initialize(null, initialRunspace);
+        }
+
+        private void Initialize(string hostProfileId, Runspace initialRunspace)
         {
             Validate.IsNotNull("initialRunspace", initialRunspace);
 
@@ -160,7 +186,6 @@ private void Initialize(Runspace initialRunspace)
             this.currentRunspace.Debugger.DebuggerStop += OnDebuggerStop;
 
             this.powerShell = PowerShell.Create();
-            this.powerShell.InvocationStateChanged += powerShell_InvocationStateChanged;
             this.powerShell.Runspace = this.currentRunspace;
 
             // TODO: Should this be configurable?
@@ -199,6 +224,14 @@ private void Initialize(Runspace initialRunspace)
             this.versionSpecificOperations.ConfigureDebugger(
                 this.currentRunspace);
 
+            // Set the $profile variable in the runspace
+            this.profilePaths =
+                this.SetProfileVariableInCurrentRunspace(
+                    hostProfileId ?? ProfilePaths.DefaultHostProfileId);
+
+            // Now that initialization is complete we can watch for InvocationStateChanged
+            this.powerShell.InvocationStateChanged += powerShell_InvocationStateChanged;
+
             this.SessionState = PowerShellContextState.Ready;
 
             // Now that the runspace is ready, enqueue it for first use
@@ -493,6 +526,24 @@ public async Task ExecuteScriptAtPath(string scriptPath, string arguments = null
             await this.ExecuteCommand<object>(command, true);
         }
 
+        /// <summary>
+        /// Loads PowerShell profiles for the host from the
+        /// standard system locations.  Only the profile paths which
+        /// exist are loaded.
+        /// </summary>
+        /// <returns>A Task that can be awaited for completion.</returns>
+        public async Task LoadProfilesForHost()
+        {
+            // Load any of the profile paths that exist
+            PSCommand command = null;
+            foreach (var profilePath in this.profilePaths.GetLoadableProfilePaths())
+            {
+                command = new PSCommand();
+                command.AddCommand(profilePath, false);
+                await this.ExecuteCommand(command);
+            }
+        }
+
         /// <summary>
         /// Causes the current execution to be aborted no matter what state
         /// it is currently in.
@@ -970,6 +1021,56 @@ private void WritePromptWithNestedPipeline()
                     });
             }
         }
+
+        private ProfilePaths SetProfileVariableInCurrentRunspace(string hostProfileId)
+        {
+            // Get the profile paths for the host name
+            ProfilePaths profilePaths =
+                new ProfilePaths(
+                    hostProfileId,
+                    this.currentRunspace);
+
+            // Create the $profile variable
+            PSObject profile = new PSObject(profilePaths.CurrentUserCurrentHost);
+
+            profile.Members.Add(
+                new PSNoteProperty(
+                    nameof(profilePaths.AllUsersAllHosts),
+                    profilePaths.AllUsersAllHosts));
+
+            profile.Members.Add(
+                new PSNoteProperty(
+                    nameof(profilePaths.AllUsersCurrentHost),
+                    profilePaths.AllUsersCurrentHost));
+
+            profile.Members.Add(
+                new PSNoteProperty(
+                    nameof(profilePaths.CurrentUserAllHosts),
+                    profilePaths.CurrentUserAllHosts));
+
+            profile.Members.Add(
+                new PSNoteProperty(
+                    nameof(profilePaths.CurrentUserCurrentHost),
+                    profilePaths.CurrentUserCurrentHost));
+
+            Logger.Write(
+                LogLevel.Verbose,
+                string.Format(
+                    "Setting $profile variable in runspace.  Current user host profile path: {0}",
+                    profilePaths.CurrentUserCurrentHost));
+
+            // Set the variable in the runspace
+            this.powerShell.Commands.Clear();
+            this.powerShell
+                .AddCommand("Set-Variable")
+                .AddParameter("Name", "profile")
+                .AddParameter("Value", profile)
+                .AddParameter("Option", "None");
+            this.powerShell.Invoke();
+            this.powerShell.Commands.Clear();
+
+            return profilePaths;
+        }
 
         #endregion