Add attach to local runspace. (PowerShell#875)

* Add attach to local runspace.

* Remove comment.

* Use single runspaceId property.

* Remove unnecessary processId check.

* Factored if.

* Update src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

It's neat that we can just commit a suggestion.

Co-Authored-By: adamdriscoll <[email protected]>

* Use runspace rather than dynamic.

* Accept process ID for GetRunspaceRequest.

* Clean up.

Author: adamdriscoll

src/PowerShellEditorServices.Protocol/DebugAdapter/AttachRequest.cs

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

src/PowerShellEditorServices.Protocol/LanguageServer/GetRunspaceRequest.cs

@@ -0,0 +1,25 @@
+//
+// 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 GetRunspaceRequest
+    {
+        public static readonly
+            RequestType<string, GetRunspaceResponse[], object, object> Type =
+                RequestType<string, GetRunspaceResponse[], object, object>.Create("powerShell/getRunspace");
+    }
+
+    public class GetRunspaceResponse
+    {
+        public int Id { get; set; }
+
+        public string Name { get; set; }
+
+        public string Availability { get; set; }
+    }
+}

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -444,7 +444,7 @@ await requestContext.SendError(
                     return;
                 }
             }
-            else
+            else if (attachParams.ProcessId != "current")
             {
                 Logger.Write(
                     LogLevel.Error,
@@ -463,7 +463,20 @@ await requestContext.SendError(
             // will block the debug adapter initialization process.  The
             // InitializedEvent will be sent as soon as the RunspaceChanged
             // event gets fired with the attached runspace.
-            int runspaceId = attachParams.RunspaceId > 0 ? attachParams.RunspaceId : 1;
+
+            var runspaceId = 1;
+            if (!int.TryParse(attachParams.RunspaceId, out runspaceId) || runspaceId <= 0)
+            {
+                Logger.Write(
+                    LogLevel.Error,
+                    $"Attach request failed, '{attachParams.RunspaceId}' is an invalid value for the processId.");
+
+                await requestContext.SendErrorAsync(
+                    "A positive integer must be specified for the RunspaceId field.");
+
+                return;
+            }
+
             _waitingForAttach = true;
             Task nonAwaitedTask = _editorSession.PowerShellContext
                 .ExecuteScriptString($"\nDebug-Runspace -Id {runspaceId}")

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -18,6 +18,7 @@
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
+using System.Management.Automation.Runspaces;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -162,6 +163,8 @@ public void Start()
             this.messageHandlers.SetRequestHandler(GetPSHostProcessesRequest.Type, this.HandleGetPSHostProcessesRequest);
             this.messageHandlers.SetRequestHandler(CommentHelpRequest.Type, this.HandleCommentHelpRequest);
 
+            this.messageHandlers.SetRequestHandler(GetRunspaceRequest.Type, this.HandleGetRunspaceRequestAsync);
+
             // Initialize the extension service
             // TODO: This should be made awaited once Initialize is async!
             this.editorSession.ExtensionService.Initialize(
@@ -1231,6 +1234,54 @@ protected async Task HandleCommentHelpRequest(
             await requestContext.SendResult(result);
         }
 
+        protected async Task HandleGetRunspaceRequestAsync(
+            string processId,
+            RequestContext<GetRunspaceResponse[]> requestContext)
+        {
+            var runspaceResponses = new List<GetRunspaceResponse>();
+
+            if (this.editorSession.PowerShellContext.LocalPowerShellVersion.Version.Major >= 5)
+            {
+                if (processId == null) {
+                    processId = "current";
+                }
+
+                var isNotCurrentProcess = processId != null && processId != "current";
+
+                var psCommand = new PSCommand();
+
+                if (isNotCurrentProcess) {
+                    psCommand.AddCommand("Enter-PSHostProcess").AddParameter("Id", processId).AddStatement();
+                }
+
+                psCommand.AddCommand("Get-Runspace");
+
+                StringBuilder sb = new StringBuilder();
+                IEnumerable<Runspace> runspaces = await editorSession.PowerShellContext.ExecuteCommandAsync<Runspace>(psCommand, sb);
+                if (runspaces != null)
+                {
+                    foreach (var p in runspaces)
+                    {
+                        runspaceResponses.Add(
+                            new GetRunspaceResponse
+                            {
+                                Id = p.Id,
+                                Name = p.Name,
+                                Availability = p.RunspaceAvailability.ToString()
+                            });
+                    }
+                }
+
+                if (isNotCurrentProcess) {
+                    var exitCommand = new PSCommand();
+                    exitCommand.AddCommand("Exit-PSHostProcess");
+                    await editorSession.PowerShellContext.ExecuteCommandAsync(exitCommand);
+                }
+            }
+
+            await requestContext.SendResultAsync(runspaceResponses.ToArray());
+        }
+
         private bool IsQueryMatch(string query, string symbolName)
         {
             return symbolName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;