feat: refactor command execution using PersistentShell

- Update command `_executeAndLogCommand` to use `PersistentShell` for executing scripts efficiently.
- Add a new file `persistent_shell.dart` for defining the `PersistentShell` class.
- Import `PersistentShell` in `runner.dart` for using it in the commands.
- Introduce the `PersistentShell` class with methods for starting, sending commands, and stopping the shell.
- Refactor the log handling in `MelosLogger` to complete based on specific markers.
- Modify string manipulation in `utils.dart`, adding a method to prepend a step prefix emoji.
- Update tests for `melos run` commands in `run_test.dart` to reflect the changes in the command execution flow.

packages/melos/lib/src/commands/run.dart

@@ -275,48 +275,24 @@ mixin _RunMixin on _Melos {
     Script script,
     Map<String, String> environment,
   ) async {
-    for (final step in steps) {
-      final scriptCommand = _buildScriptCommand(step, scripts);
-
-      final scriptSourceCode = targetStyle(
-        step.withoutTrailing('\n'),
-      );
-
-      await _executeAndLogCommand(
-        script,
-        scriptSourceCode,
-        scriptCommand,
-        environment,
-      );
-    }
-  }
-
-  Future<void> _executeAndLogCommand(
-    Script script,
-    String scriptSourceCode,
-    String scriptCommand,
-    Map<String, String> environment,
-  ) async {
-    logger.command('melos run ${script.name}');
-    logger.child(scriptSourceCode).child(runningLabel).newLine();
-
-    final exitCode = await startCommand(
-      [scriptCommand],
+    final shell = PersistentShell(
       logger: logger,
-      environment: environment,
       workingDirectory: config.path,
     );
 
-    logger.newLine();
+    await shell.startShell();
     logger.command('melos run ${script.name}');
-    final resultLogger = logger.child(scriptSourceCode);
 
-    if (exitCode != 0) {
-      resultLogger.child(failedLabel);
-    } else {
-      resultLogger.child(successLabel);
+    for (final step in steps) {
+      final scriptCommand = _buildScriptCommand(step, scripts);
+
+      final shouldContinue = await shell.sendCommand(scriptCommand);
+      if (!shouldContinue) {
+        break;
+      }
     }
-    logger.newLine();
+
+    await shell.stopShell();
   }
 }
 

packages/melos/lib/src/commands/runner.dart

@@ -29,6 +29,7 @@ import '../common/glob.dart';
 import '../common/intellij_project.dart';
 import '../common/io.dart';
 import '../common/pending_package_update.dart';
+import '../common/persistent_shell.dart';
 import '../common/platform.dart';
 import '../common/utils.dart' as utils;
 import '../common/utils.dart';

packages/melos/lib/src/common/persistent_shell.dart

@@ -0,0 +1,101 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import '../logging.dart';
+import 'platform.dart';
+import 'utils.dart';
+
+class PersistentShell {
+  PersistentShell({
+    required this.logger,
+    this.workingDirectory,
+  });
+
+  final _isWindows = currentPlatform.isWindows;
+  final MelosLogger logger;
+  final String? workingDirectory;
+  late final Process _process;
+  Completer<void>? _commandCompleter;
+  final String _successEndMarker = '__SUCCESS_COMMAND_END__';
+  final String _failureEndMarker = '__FAILURE_COMMAND_END__';
+
+  Future<void> startShell() async {
+    final executable = _isWindows ? 'cmd.exe' : '/bin/sh';
+
+    _process = await Process.start(
+      executable,
+      [],
+      workingDirectory: workingDirectory,
+    );
+
+    _listenToProcessStream(_process.stdout);
+    _listenToProcessStream(_process.stderr, isError: true);
+  }
+
+  Future<bool> sendCommand(String command) async {
+    assert(_commandCompleter == null, 'A command is already in progress.');
+    _commandCompleter = Completer<void>();
+
+    final fullCommand = _buildFullCommand(command);
+    _process.stdin.writeln(fullCommand);
+
+    return _awaitCommandCompletion();
+  }
+
+  Future<void> stopShell() async {
+    await _process.stdin.close();
+    final exitCode = await _process.exitCode;
+    if (exitCode == 0) {
+      logger.log(successLabel);
+      return;
+    }
+    logger.log(failedLabel);
+  }
+
+  Future<bool> _awaitCommandCompletion() async {
+    try {
+      await _commandCompleter!.future;
+      return true;
+    } catch (e) {
+      return false;
+    } finally {
+      _commandCompleter = null;
+    }
+  }
+
+  void _listenToProcessStream(
+    Stream<List<int>> stream, {
+    bool isError = false,
+  }) {
+    stream.listen((event) {
+      final output = utf8.decode(event, allowMalformed: true);
+      logger.logAndCompleteBasedOnMarkers(
+        output,
+        _successEndMarker,
+        _failureEndMarker,
+        _commandCompleter,
+        isError: isError,
+      );
+    });
+  }
+
+  String _buildFullCommand(String command) {
+    final formattedScriptStep =
+        targetStyle(command.addStepPrefixEmoji().withoutTrailing('\n'));
+    final echoCommand = 'echo "$formattedScriptStep"';
+    final echoSuccess = 'echo $_successEndMarker';
+    final echoFailure = 'echo $_failureEndMarker';
+
+    if (_isWindows) {
+      return '''
+      $echoCommand && $command || VER>NUL && if %ERRORLEVEL% NEQ 0 ($echoFailure) else ($echoSuccess)
+    ''';
+    }
+
+    return '''
+   $echoCommand && $command || true && if [ \$? -ne 0 ]; 
+    then $echoFailure; else $echoSuccess; fi
+  ''';
+  }
+}

packages/melos/lib/src/common/utils.dart

@@ -73,6 +73,10 @@ final melosPackageUri = Uri.parse('package:melos/melos.dart');
 final _camelCasedDelimiterRegExp = RegExp(r'[_\s-]+');
 
 extension StringUtils on String {
+  String addStepPrefixEmoji() {
+    return '➡️ step: $this';
+  }
+
   String indent(String indent) {
     final split = this.split('\n');
 

packages/melos/lib/src/logging.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:ansi_styles/ansi_styles.dart';
 import 'package:cli_util/cli_logging.dart';
 
@@ -67,6 +69,48 @@ class MelosLogger with _DelegateLogger {
     write(message);
   }
 
+  void logAndCompleteBasedOnMarkers(
+    String message,
+    String successMarker,
+    String failureMarker,
+    Completer<void>? completer, {
+    bool isError = false,
+  }) {
+    final modifiedMessage = _processMessageBasedOnMarkers(
+      message,
+      successMarker,
+      failureMarker,
+      completer,
+    );
+    _logMessage(modifiedMessage, isError);
+  }
+
+  String _processMessageBasedOnMarkers(
+    String message,
+    String successMarker,
+    String failureMarker,
+    Completer<void>? completer,
+  ) {
+    if (message.contains(successMarker)) {
+      completer?.complete();
+      return message.replaceAll(successMarker, '');
+    }
+
+    if (message.contains(failureMarker)) {
+      completer?.complete();
+      return message.replaceAll(failureMarker, '');
+    }
+
+    return message;
+  }
+
+  void _logMessage(String message, bool isError) {
+    if (isError) {
+      error(message);
+    }
+    write(message);
+  }
+
   void command(String command, {bool withDollarSign = false}) {
     if (withDollarSign) {
       stdout('${commandColor(r'$')} ${commandStyle(command)}');