Fix macOS hang in pipe operations by removing PTY terminal usage (#1382)

* Fix macOS hang in pipe operations by removing PTY terminal usage

- Remove PTY terminal creation in CommandOutputStream.open() method
- Use simple Java streams instead of TerminalBuilder for pipe operations
- Add unit test to verify pipe operations don't hang with timeout
- Clean up unused imports (TerminalBuilder, Attributes, InputFlag, etc.)

Fixes #1361 and #1360 where pipe operations would hang on macOS due to
PTY terminal creation. The fix follows the recommendation from PR #1367
discussion to use simple Java piped streams instead of PTY terminals
for command pipes.

The CommandOutputStream now reuses the original terminal for input and
uses redirected streams for output, avoiding the problematic PTY
terminal creation that caused hangs on BSD/macOS platforms.

* Fix variable assignment test syntax

- Use correct syntax 'variable=command' without spaces around equals
- Test now properly triggers CommandOutputStream.open() method
- Verifies that variable assignments don't hang on macOS with timeout

Author: gnodet

console/src/main/java/org/jline/console/impl/SystemRegistryImpl.java

@@ -8,12 +8,10 @@
  */
 package org.jline.console.impl;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.nio.file.Path;
@@ -40,14 +38,9 @@
 import org.jline.reader.impl.completer.NullCompleter;
 import org.jline.reader.impl.completer.StringsCompleter;
 import org.jline.reader.impl.completer.SystemCompleter;
-import org.jline.terminal.Attributes;
-import org.jline.terminal.Attributes.InputFlag;
 import org.jline.terminal.Terminal;
-import org.jline.terminal.TerminalBuilder;
 import org.jline.utils.*;
 
-import static org.jline.keymap.KeyMap.ctrl;
-
 /**
  * Aggregate command registries.
  *
@@ -494,36 +487,24 @@ public void open(boolean redirectColor) throws IOException {
             PrintStream out = new PrintStream(outputStream);
             System.setOut(out);
             System.setErr(out);
-            String input = ctrl('X') + "q";
-            InputStream in = new ByteArrayInputStream(input.getBytes());
-            Attributes attrs = new Attributes();
-            if (OSUtils.IS_WINDOWS) {
-                attrs.setInputFlag(InputFlag.IGNCR, true);
-            }
-            try {
-                terminal = TerminalBuilder.builder()
-                        .streams(in, outputStream)
-                        .attributes(attrs)
-                        .type((redirectColor ? Terminal.TYPE_DUMB_COLOR : Terminal.TYPE_DUMB))
-                        .build();
-                this.commandSession = new CommandRegistry.CommandSession(terminal, terminal.input(), out, out);
-                redirecting = true;
-            } catch (IOException e) {
-                reset();
-                throw e;
-            }
+
+            // Use simple streams instead of creating a PTY terminal to avoid hangs on macOS
+            // Create a command session that uses the original terminal for input but redirected streams for output
+            this.commandSession = new CommandRegistry.CommandSession(origTerminal, origTerminal.input(), out, out);
+            redirecting = true;
         }
 
         public void close() {
             if (!redirecting) {
                 return;
             }
             try {
-                terminal.flush();
+                // Flush the original terminal since we're using it for input
+                origTerminal.flush();
                 if (outputStream instanceof ByteArrayOutputStream) {
                     output = outputStream.toString();
                 }
-                terminal.close();
+                // No need to close a separate terminal since we're reusing the original one
             } catch (Exception e) {
                 // ignore
             }
@@ -538,7 +519,6 @@ private void reset() {
             outputStream = null;
             System.setOut(origOut);
             System.setErr(origErr);
-            terminal = null;
             terminal = origTerminal;
             PrintStream ps = new PrintStream(terminal.output());
             this.commandSession = new CommandRegistry.CommandSession(terminal, terminal.input(), ps, ps);

console/src/test/java/org/jline/console/impl/SystemRegistryImplTest.java

@@ -16,6 +16,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.function.Supplier;
 
 import org.jline.builtins.ConfigurationPath;
@@ -79,6 +82,59 @@ public void testOverrideBuiltinCommand() throws Exception {
         assertEquals("Custom exit command executed", output.toString().trim());
     }
 
+    /**
+     * Test that variable assignment operations don't hang on macOS.
+     *
+     * This test verifies the fix for issues #1361 and #1360 where variable assignments
+     * would hang on macOS due to PTY terminal creation in CommandOutputStream.
+     * The fix removes PTY terminal usage and uses simple Java streams instead.
+     *
+     * Variable assignments trigger CommandOutputStream.open() which previously created
+     * PTY terminals that could hang on BSD/macOS platforms.
+     */
+    @Test
+    public void testVariableAssignmentDoesNotHang() throws Exception {
+        // Add a test command that outputs some text
+        TestCommandRegistry echoRegistry = new TestCommandRegistry(output);
+        echoRegistry.addCommand("echo", (input) -> {
+            if (input.args().length > 0) {
+                StringBuilder sb = new StringBuilder();
+                for (Object arg : input.args()) {
+                    if (sb.length() > 0) sb.append(" ");
+                    sb.append(arg.toString());
+                }
+                // Print to System.out which will be captured by CommandOutputStream
+                System.out.print(sb.toString());
+            }
+            return null;
+        });
+
+        registry.setCommandRegistries(echoRegistry);
+
+        // Test variable assignment with a timeout to ensure it doesn't hang
+        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+            try {
+                // This command uses variable assignment which triggers CommandOutputStream.open()
+                // and previously could hang on macOS due to PTY terminal creation
+                registry.execute("result=echo hello world");
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        try {
+            // If the operation hangs, this will throw TimeoutException
+            future.get(5, TimeUnit.SECONDS);
+        } catch (TimeoutException e) {
+            future.cancel(true);
+            throw new AssertionError(
+                    "Variable assignment operation hung - this indicates the macOS hang bug is present", e);
+        }
+
+        // If we get here, the operation completed without hanging
+        // The exact output doesn't matter as much as the fact that it didn't hang
+    }
+
     /**
      * A test command registry that provides a custom implementation of the "exit" command.
      */
@@ -92,6 +148,10 @@ public TestCommandRegistry(StringBuilder output) {
             commandExecute.put("exit", new CommandMethods(this::exit, this::defaultCompleter));
         }
 
+        public void addCommand(String name, java.util.function.Function<CommandInput, Object> executor) {
+            commandExecute.put(name, new CommandMethods(executor, this::defaultCompleter));
+        }
+
         private Object exit(CommandInput input) {
             output.append("Custom exit command executed");
             return null;