Fix merge conflict with develop

Author: Kapil Borle

README.md

@@ -39,17 +39,10 @@ how to use this project. You can also read our plans for future feature developm
 
 ## Cloning the Code
 
-To clone the repository and initialize all the submodules at once you can run:
+To clone the repository execute:
 
 ```
-git clone --recursive https://github.com/PowerShell/PowerShellEditorServices.git
-```
-
-If you have already cloned the repository without `--recursive` option, you can run following commands to initialize the submodules:
-
-```
-git submodule init
-git submodule update
+git clone https://github.com/PowerShell/PowerShellEditorServices.git
 ```
 
 ## Contributions Welcome!
@@ -65,4 +58,4 @@ contribute code, documentation, tests, or bug reports, please read our [Contribu
 
 ## License
 
-This project is [licensed under the MIT License](LICENSE).
+This project is [licensed under the MIT License](LICENSE).

src/PowerShellEditorServices.Protocol/DebugAdapter/AttachRequest.cs

@@ -18,7 +18,7 @@ public class AttachRequestArguments
     {
         public string ComputerName { get; set; }
 
-        public int ProcessId { get; set; }
+        public string ProcessId { get; set; }
 
         public int RunspaceId { get; set; }
     }

src/PowerShellEditorServices.Protocol/LanguageServer/GetPSHostProcessesRequest.cs

@@ -0,0 +1,27 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.LanguageServer
+{
+    public class GetPSHostProcessesRequest
+    {
+        public static readonly
+            RequestType<object, GetPSHostProcessesResponse[]> Type =
+                RequestType<object, GetPSHostProcessesResponse[]>.Create("powerShell/getPSHostProcesses");
+    }
+
+    public class GetPSHostProcessesResponse
+    {
+        public string ProcessName { get; set; }
+
+        public int ProcessId { get; set; }
+
+        public string AppDomainName { get; set; }
+
+        public string MainWindowTitle { get; set; }
+    }
+}

src/PowerShellEditorServices.Protocol/MessageProtocol/Serializers/V8MessageSerializer.cs

@@ -34,8 +34,11 @@ public JObject SerializeMessage(Message message)
             }
             else if (message.MessageType == MessageType.Response)
             {
+                int messageId = 0;
+                int.TryParse(message.Id, out messageId);
+
                 messageObject.Add("type", JToken.FromObject("response"));
-                messageObject.Add("request_seq", JToken.FromObject(message.Id));
+                messageObject.Add("request_seq", JToken.FromObject(messageId));
                 messageObject.Add("command", message.Method);
 
                 if (message.Error != null)

src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj

@@ -56,6 +56,7 @@
     <Compile Include="DebugAdapter\ContinueRequest.cs" />
     <Compile Include="DebugAdapter\SetFunctionBreakpointsRequest.cs" />
     <Compile Include="DebugAdapter\SetVariableRequest.cs" />
+    <Compile Include="LanguageServer\GetPSHostProcessesRequest.cs" />
     <Compile Include="LanguageServer\GetPSSARulesRequest.cs" />
     <Compile Include="LanguageServer\EditorCommands.cs" />
     <Compile Include="LanguageServer\CodeAction.cs" />

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -207,6 +207,22 @@ protected async Task HandleAttachRequest(
             AttachRequestArguments attachParams,
             RequestContext<object> requestContext)
         {
+            // If there are no host processes to attach to or the user cancels selection, we get a null for the process id.
+            // This is not an error, just a request to stop the original "attach to" request.
+            // Testing against "undefined" is a HACK because I don't know how to make "Cancel" on quick pick loading 
+            // to cancel on the VSCode side without sending an attachRequest with processId set to "undefined".
+            if (string.IsNullOrEmpty(attachParams.ProcessId) || (attachParams.ProcessId == "undefined"))
+            {
+                Logger.Write(
+                    LogLevel.Normal,
+                    $"Attach request aborted, received {attachParams.ProcessId} for processId.");
+
+                await requestContext.SendError(
+                    "User aborted attach to PowerShell host process.");
+
+                return;
+            }
+
             StringBuilder errorMessages = new StringBuilder();
 
             if (attachParams.ComputerName != null)
@@ -235,7 +251,8 @@ await requestContext.SendError(
                 }
             }
 
-            if (attachParams.ProcessId > 0)
+            int processId;
+            if (int.TryParse(attachParams.ProcessId, out processId) && (processId > 0))
             {
                 PowerShellVersionDetails runspaceVersion =
                     this.editorSession.PowerShellContext.CurrentRunspace.PowerShellVersion;
@@ -249,13 +266,13 @@ await requestContext.SendError(
                 }
 
                 await this.editorSession.PowerShellContext.ExecuteScriptString(
-                    $"Enter-PSHostProcess -Id {attachParams.ProcessId}",
+                    $"Enter-PSHostProcess -Id {processId}",
                     errorMessages);
 
                 if (errorMessages.Length > 0)
                 {
                     await requestContext.SendError(
-                        $"Could not attach to process '{attachParams.ProcessId}'");
+                        $"Could not attach to process '{processId}'");
 
                     return;
                 }
@@ -272,6 +289,10 @@ await requestContext.SendError(
             }
             else
             {
+                Logger.Write(
+                    LogLevel.Error,
+                    $"Attach request failed, '{attachParams.ProcessId}' is an invalid value for the processId.");
+
                 await requestContext.SendError(
                     "A positive integer must be specified for the processId field.");
 

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -126,6 +126,8 @@ protected override void Initialize()
 
             this.SetRequestHandler(ScriptFileMarkersRequest.Type, this.HandleScriptFileMarkersRequest);
 
+            this.SetRequestHandler(GetPSHostProcessesRequest.Type, this.HandleGetPSHostProcessesRequest);
+
             // Initialize the extension service
             // TODO: This should be made awaited once Initialize is async!
             this.editorSession.ExtensionService.Initialize(
@@ -939,6 +941,42 @@ await requestContext.SendResult(
                     this.editorSession.PowerShellContext.LocalPowerShellVersion));
         }
 
+        protected async Task HandleGetPSHostProcessesRequest(
+            object noParams,
+            RequestContext<GetPSHostProcessesResponse[]> requestContext)
+        {
+            var psHostProcesses = new List<GetPSHostProcessesResponse>();
+
+            if (this.editorSession.PowerShellContext.LocalPowerShellVersion.Version.Major >= 5)
+            {
+                int processId = System.Diagnostics.Process.GetCurrentProcess().Id;
+                var psCommand = new PSCommand();
+                psCommand.AddCommand("Get-PSHostProcessInfo");
+                psCommand.AddCommand("Where-Object")
+                    .AddParameter("Property", "ProcessId")
+                    .AddParameter("NE")
+                    .AddParameter("Value", processId.ToString());
+
+                var processes = await editorSession.PowerShellContext.ExecuteCommand<PSObject>(psCommand);
+                if (processes != null)
+                {
+                    foreach (dynamic p in processes)
+                    {
+                        psHostProcesses.Add(
+                            new GetPSHostProcessesResponse
+                            {
+                                ProcessName = p.ProcessName,
+                                ProcessId = p.ProcessId,
+                                AppDomainName = p.AppDomainName,
+                                MainWindowTitle = p.MainWindowTitle
+                            });
+                    }
+                }
+            }
+
+            await requestContext.SendResult(psHostProcesses.ToArray());
+        }
+
         private bool IsQueryMatch(string query, string symbolName)
         {
             return symbolName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -12,7 +12,6 @@
 using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Debugging;
 using Microsoft.PowerShell.EditorServices.Utility;
-using System.IO;
 using Microsoft.PowerShell.EditorServices.Session;
 
 namespace Microsoft.PowerShell.EditorServices
@@ -26,6 +25,7 @@ public class DebugService
         #region Fields
 
         private const string PsesGlobalVariableNamePrefix = "__psEditorServices_";
+        private const string TemporaryScriptFileName = "TemporaryScript.ps1";
 
         private PowerShellContext powerShellContext;
         private RemoteFileManager remoteFileManager;
@@ -35,6 +35,7 @@ public class DebugService
             new Dictionary<string, List<Breakpoint>>();
 
         private int nextVariableId;
+        private string temporaryScriptListingPath;
         private List<VariableDetailsBase> variables;
         private VariableContainerDetails globalScopeVariables;
         private VariableContainerDetails scriptScopeVariables;
@@ -93,8 +94,8 @@ public DebugService(
         /// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param>
         /// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
         public async Task<BreakpointDetails[]> SetLineBreakpoints(
-            ScriptFile scriptFile, 
-            BreakpointDetails[] breakpoints, 
+            ScriptFile scriptFile,
+            BreakpointDetails[] breakpoints,
             bool clearExisting = true)
         {
             var resultBreakpointDetails = new List<BreakpointDetails>();
@@ -111,22 +112,32 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
                 if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
                     this.remoteFileManager != null)
                 {
-                    string mappedPath =
-                        this.remoteFileManager.GetMappedPath(
-                            scriptPath,
-                            this.powerShellContext.CurrentRunspace);
-
-                    if (mappedPath == null)
+                    if (!this.remoteFileManager.IsUnderRemoteTempPath(scriptPath))
                     {
                         Logger.Write(
-                            LogLevel.Error,
-                            $"Could not map local path '{scriptPath}' to a remote path.");
+                            LogLevel.Verbose,
+                            $"Could not set breakpoints for local path '{scriptPath}' in a remote session.");
 
                         return resultBreakpointDetails.ToArray();
                     }
 
+                    string mappedPath =
+                        this.remoteFileManager.GetMappedPath(
+                            scriptPath,
+                            this.powerShellContext.CurrentRunspace);
+
                     scriptPath = mappedPath;
                 }
+                else if (
+                    this.temporaryScriptListingPath != null &&
+                    this.temporaryScriptListingPath.Equals(scriptPath, StringComparison.CurrentCultureIgnoreCase))
+                {
+                    Logger.Write(
+                        LogLevel.Verbose,
+                        $"Could not set breakpoint on temporary script listing path '{scriptPath}'.");
+
+                    return resultBreakpointDetails.ToArray();
+                }
 
                 // Fix for issue #123 - file paths that contain wildcard chars [ and ] need to
                 // quoted and have those wildcard chars escaped.
@@ -622,7 +633,7 @@ private async Task ClearCommandBreakpoints()
             await this.powerShellContext.ExecuteCommand<object>(psCommand);
         }
 
-        private async Task FetchStackFramesAndVariables()
+        private async Task FetchStackFramesAndVariables(string scriptNameOverride)
         {
             this.nextVariableId = VariableDetailsBase.FirstVariableId;
             this.variables = new List<VariableDetailsBase>();
@@ -633,7 +644,7 @@ private async Task FetchStackFramesAndVariables()
             // Must retrieve global/script variales before stack frame variables
             // as we check stack frame variables against globals.
             await FetchGlobalAndScriptVariables();
-            await FetchStackFrames();
+            await FetchStackFrames(scriptNameOverride);
         }
 
         private async Task FetchGlobalAndScriptVariables()
@@ -750,7 +761,7 @@ private bool AddToAutoVariables(PSObject psvariable, string scope)
             return true;
         }
 
-        private async Task FetchStackFrames()
+        private async Task FetchStackFrames(string scriptNameOverride)
         {
             PSCommand psCommand = new PSCommand();
 
@@ -782,7 +793,12 @@ private async Task FetchStackFrames()
                     StackFrameDetails.Create(callStackFrames[i], autoVariables, localVariables);
 
                 string stackFrameScriptPath = this.stackFrameDetails[i].ScriptPath;
-                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
+                if (scriptNameOverride != null &&
+                    string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
+                {
+                    this.stackFrameDetails[i].ScriptPath = scriptNameOverride;
+                }
+                else if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
                     this.remoteFileManager != null &&
                     !string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
                 {
@@ -979,6 +995,25 @@ private string FormatInvalidBreakpointConditionMessage(string condition, string
             return $"'{condition}' is not a valid PowerShell expression. {message}";
         }
 
+        private string TrimScriptListingLine(PSObject scriptLineObj, ref int prefixLength)
+        {
+            string scriptLine = scriptLineObj.ToString();
+
+            if (!string.IsNullOrWhiteSpace(scriptLine))
+            {
+                if (prefixLength == 0)
+                {
+                    // The prefix is a padded integer ending with ':', an asterisk '*'
+                    // if this is the current line, and one character of padding
+                    prefixLength = scriptLine.IndexOf(':') + 2;
+                }
+
+                return scriptLine.Substring(prefixLength);
+            }
+
+            return null;
+        }
+
         #endregion
 
         #region Events
@@ -990,11 +1025,56 @@ private string FormatInvalidBreakpointConditionMessage(string condition, string
 
         private async void OnDebuggerStop(object sender, DebuggerStopEventArgs e)
         {
+            bool noScriptName = false;
+            string localScriptPath = e.InvocationInfo.ScriptName;
+
+            // If there's no ScriptName, get the "list" of the current source
+            if (this.remoteFileManager != null && string.IsNullOrEmpty(localScriptPath))
+            {
+                // Get the current script listing and create the buffer
+                PSCommand command = new PSCommand();
+                command.AddScript($"list 1 {int.MaxValue}");
+
+                IEnumerable<PSObject> scriptListingLines =
+                    await this.powerShellContext.ExecuteCommand<PSObject>(
+                        command, false, false);
+
+                if (scriptListingLines != null)
+                {
+                    int linePrefixLength = 0;
+
+                    string scriptListing =
+                        string.Join(
+                            Environment.NewLine,
+                            scriptListingLines
+                                .Select(o => this.TrimScriptListingLine(o, ref linePrefixLength))
+                                .Where(s => s != null));
+
+                    this.temporaryScriptListingPath =
+                        this.remoteFileManager.CreateTemporaryFile(
+                            TemporaryScriptFileName,
+                            scriptListing,
+                            this.powerShellContext.CurrentRunspace);
+
+                    localScriptPath =
+                        this.temporaryScriptListingPath
+                        ?? StackFrameDetails.NoFileScriptPath;
+
+                    noScriptName = localScriptPath != null;
+                }
+                else
+                {
+                    Logger.Write(
+                        LogLevel.Warning,
+                        $"Could not load script context");
+                }
+            }
+
             // Get call stack and variables.
-            await this.FetchStackFramesAndVariables();
+            await this.FetchStackFramesAndVariables(
+                noScriptName ? localScriptPath : null);
 
             // If this is a remote connection, get the file content
-            string localScriptPath = e.InvocationInfo.ScriptName;
             if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
                 this.remoteFileManager != null)
             {