🐛 fix powershell dotnet objects output regression issue #4024 (#4100)

* Implement PowerShell formatting fallback with custom formatter detection

Co-authored-by: FH-Inway <[email protected]>

* fix tests by using default text/html mime type

* add handling of formatting objects

* add more specific assertions to show that table formatting is used

* reset formatter after every test

* revert Jupyter test back to expected Stream output

Test was changed in commit 74cd6aa as part of #3912.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>

Author: FH-Inway

src/Microsoft.DotNet.Interactive.Jupyter.Tests/ExecuteRequestHandlerTests.cs

@@ -403,9 +403,9 @@ public async Task sends_InputRequest_message_when_submission_requests_user_passw
 
         JupyterMessageSender.RequestMessages.Should().Contain(r => r.Prompt == prompt && r.Password == true);
         JupyterMessageSender.PubSubMessages
-            .OfType<Protocol.DisplayData>()
+            .OfType<Protocol.Stream>()
             .Should()
-            .Contain(s => s.Data.ContainsKey("text/html") && s.Data["text/html"].ToString().Contains("System.Security.SecureString"));
+            .Contain(s => s.Name == Protocol.Stream.StandardOutput && s.Text.Contains("System.Security.SecureString"));
     }
 
     [Fact]

src/Microsoft.DotNet.Interactive.PowerShell.Tests/PowerShellKernelTests.cs

@@ -77,6 +77,7 @@ public class PowerShellKernelTests : LanguageKernelTestBase
 
     public PowerShellKernelTests(ITestOutputHelper output) : base(output)
     {
+        DisposeAfterTest(() => Formatter.ResetToDefault());
     }
 
     [Theory]
@@ -417,4 +418,70 @@ public async Task Powershell_CustomObject_Is_Formatted_Correctly(string mimeType
               .Should()
               .BeEquivalentHtmlTo(_tableOutputOfCustomObjectTest);
     }
+
+    [Fact]
+    public async Task PowerShell_objects_without_custom_formatters_use_native_formatting()
+    {
+        // Arrange
+        var kernel = CreateKernel(Language.PowerShell);
+        
+        // Act - Get-Process returns objects without custom formatters and should use PowerShell native formatting
+        var result = await kernel.SendAsync(new SubmitCode("Get-Process | Select-Object -First 1"));
+
+        // Assert - Should produce StandardOutputValueProduced (native PowerShell formatting) not DisplayedValueProduced
+        var outputs = result.Events.OfType<StandardOutputValueProduced>().ToList();
+        outputs.Should().NotBeEmpty("Get-Process output should use native PowerShell formatting");
+
+        // The output should contain typical PowerShell table formatting with headers and dashes separator
+        var allOutput = string.Join("", outputs.SelectMany(e => e.FormattedValues.Select(v => v.Value)));
+        allOutput.Should().NotBeEmpty()
+            .And.ContainAny("NPM", "PM", "WS", "CPU", "Id", "SI", "ProcessName") // Common Get-Process column headers
+            .And.Match("*---*"); // PowerShell table separator line
+    }
+
+    [Fact]
+    public async Task PowerShell_objects_with_custom_formatters_use_custom_formatting()
+    {
+        // Arrange
+        var kernel = CreateKernel(Language.PowerShell);
+        
+        // Register a custom formatter for FileInfo
+        // Note: context.Display() produces HTML output by default, so we register for text/html
+        Formatter.Register<FileInfo>((fileInfo, writer) =>
+        {
+            writer.Write($"CUSTOM: {fileInfo.Name}");
+        }, HtmlFormatter.MimeType);
+
+        // Act - Create a FileInfo object which now has a custom formatter
+        var result = await kernel.SendAsync(new SubmitCode("[System.IO.FileInfo]::new('test.txt')"));
+
+        // Assert - Should produce DisplayedValueProduced (custom formatter used)
+        var displayedValues = result.Events.OfType<DisplayedValueProduced>().ToList();
+        displayedValues.Should().ContainSingle("FileInfo with custom formatter should use Display");
+
+        var htmlValue = displayedValues.First().FormattedValues.FirstOrDefault(f => f.MimeType == HtmlFormatter.MimeType);
+        htmlValue.Should().NotBeNull("HTML formatted value should be present");
+        htmlValue.Value.Should().Contain("CUSTOM: test.txt");
+  }
+
+    [Fact]
+    public async Task PowerShell_Format_Table_works_with_native_formatting()
+    {
+        // Arrange
+        var kernel = CreateKernel(Language.PowerShell);
+        
+        // Act - Use Format-Table explicitly
+        var result = await kernel.SendAsync(new SubmitCode(
+            "[pscustomobject]@{ Name='Item1'; Value=10 },[pscustomobject]@{ Name='Item2'; Value=20 } | Format-Table"));
+
+        // Assert - Should produce StandardOutputValueProduced with table formatting
+        var outputs = result.Events.OfType<StandardOutputValueProduced>().ToList();
+        outputs.Should().NotBeEmpty("Format-Table output should use native PowerShell formatting");
+        
+        var allOutput = string.Join("", outputs.SelectMany(e => e.FormattedValues.Select(v => v.Value)));
+        allOutput.Should().Contain("Name")
+            .And.Contain("Value")
+            .And.Match("*---*") // PowerShell table separator line
+            .And.ContainAny("Item1", "Item2"); // Data values
+    }
 }

src/Microsoft.DotNet.Interactive.PowerShell/PowerShellKernel.cs

@@ -378,6 +378,35 @@ private async Task RunInAzShell(string code)
         }
     }
 
+    private bool HasCustomFormatter(object value)
+    {
+        if (value is null)
+        {
+            return false;
+        }
+
+        var valueType = value.GetType();
+        var userFormatters = Formatter.RegisteredFormatters(includeDefaults: false);
+        var interfaces = valueType.GetInterfaces();
+        
+        return userFormatters.Any(f => 
+            f.Type == valueType || 
+            f.Type.IsAssignableFrom(valueType) || 
+            Array.IndexOf(interfaces, f.Type) >= 0);
+    }
+
+    private static bool IsFormattingObject(PSObject psObject)
+    {
+        // Check if this is a formatting object from Format-Table, Format-List, etc.
+        // These objects are in the Microsoft.PowerShell.Commands.Internal.Format namespace
+        if (psObject?.BaseObject != null)
+        {
+            var typeName = psObject.BaseObject.GetType().FullName;
+            return typeName?.StartsWith("Microsoft.PowerShell.Commands.Internal.Format.") == true;
+        }
+        return false;
+    }
+
     internal bool RunLocally(string code, out string errorMessage, bool suppressOutput = false, KernelInvocationContext context = null)
     {
         var command = new Command(code, isScript: true);
@@ -398,18 +427,53 @@ internal bool RunLocally(string code, out string errorMessage, bool suppressOutp
 
             if (!suppressOutput && context is not null)
             {
-                foreach (var item in result)
+                // Check if the result contains formatting objects (from Format-Table, Format-List, etc.)
+                // These need to be processed as a complete pipeline, not individually
+                if (result.Count > 0 && IsFormattingObject(result[0]))
                 {
-                    var value = item is PSObject ps ? ps.Unwrap() : item;
+                    // Pass all formatting objects to Out-String at once
+                    Pwsh.AddCommand("Out-String");
+                    var formattedResult = Pwsh.Invoke(result);
+                    Pwsh.Commands.Clear();
 
-                    if (item.TypeNames[0] == "System.String")
+                    if (formattedResult.Count > 0)
                     {
-                        var formatted = new FormattedValue("text/plain", value + Environment.NewLine);
-                        context.Publish(new StandardOutputValueProduced(context.Command, new[] { formatted } ));
+                        var output = string.Concat(formattedResult);
+                        var formatted = new FormattedValue("text/plain", output);
+                        context.Publish(new StandardOutputValueProduced(context.Command, new[] { formatted }));
                     }
-                    else
+                }
+                else
+                {
+                    // Process each item individually
+                    foreach (var item in result)
                     {
-                        context.Display(value);
+                        var value = item is PSObject ps ? ps.Unwrap() : item;
+
+                        if (item.TypeNames[0] == "System.String")
+                        {
+                            var formatted = new FormattedValue("text/plain", value + Environment.NewLine);
+                            context.Publish(new StandardOutputValueProduced(context.Command, new[] { formatted } ));
+                        }
+                        else if (HasCustomFormatter(value))
+                        {
+                            // Use custom formatter
+                            context.Display(value);
+                        }
+                        else
+                        {
+                            // Use PowerShell native formatting
+                            Pwsh.AddCommand(_outDefaultCommand)
+                                .AddParameter("InputObject", item);
+                            Pwsh.AddCommand("Out-String");
+                            var formattedResult = Pwsh.InvokeAndClear();
+                            if (formattedResult.Count > 0)
+                            {
+                                var output = string.Concat(formattedResult);
+                                var formatted = new FormattedValue("text/plain", output);
+                                context.Publish(new StandardOutputValueProduced(context.Command, new[] { formatted }));
+                            }
+                        }
                     }
                 }
             }