cache

Author: chen08209

lib/core/desktop/helper_client.dart

@@ -358,7 +358,19 @@ final class HelperCoreLease implements CoreProcessLease {
 
   @override
   Future<CoreProcessStopResult> stop(Duration timeout) {
-    return _stopOperation ??= _stop();
+    final stopOperation = _stopOperation;
+    if (stopOperation != null) {
+      return stopOperation;
+    }
+    final nextOperation = _stop().onError((
+      Object error,
+      StackTrace stackTrace,
+    ) {
+      _stopOperation = null;
+      Error.throwWithStackTrace(error, stackTrace);
+    });
+    _stopOperation = nextOperation;
+    return nextOperation;
   }
 
   Future<CoreProcessStopResult> _stop() async {

lib/core/desktop/launcher.dart

@@ -69,7 +69,18 @@ final class DirectCoreLease implements CoreProcessLease {
 
   @override
   Future<CoreProcessStopResult> stop(Duration timeout) {
-    return _stopOperation ??= _stop(timeout);
+    final stopOperation = _stopOperation;
+    if (stopOperation != null) {
+      return stopOperation;
+    }
+    final nextOperation = _stop(timeout).then((result) {
+      if (!result.exitConfirmed) {
+        _stopOperation = null;
+      }
+      return result;
+    });
+    _stopOperation = nextOperation;
+    return nextOperation;
   }
 
   Future<CoreProcessStopResult> _stop(Duration timeout) async {

test/core/desktop/helper_client_test.dart

@@ -151,6 +151,50 @@ void main() {
     expect(result.exitConfirmed, isTrue);
   });
 
+  test('Helper lease retries stop after a transport failure', () async {
+    var stopRequests = 0;
+    final client = _client(
+      _ResponseAdapter((options) {
+        if (options.path.endsWith('/start')) {
+          return _jsonResponse({'sessionId': _sessionId, 'pid': 6456});
+        }
+        stopRequests++;
+        if (stopRequests == 1) {
+          throw DioException(
+            requestOptions: options,
+            type: DioExceptionType.connectionError,
+          );
+        }
+        return _jsonResponse({
+          'sessionId': _sessionId,
+          'stopped': false,
+          'reason': 'notRunning',
+        });
+      }),
+    );
+    final launcher = WindowsHelperLauncher(client);
+    final lease = await launcher.start(
+      sessionId: _sessionId,
+      address: 'test-address',
+    );
+
+    await expectLater(
+      lease.stop(const Duration(seconds: 1)),
+      throwsA(
+        isA<WindowsHelperException>().having(
+          (error) => error.code,
+          'code',
+          'transportError',
+        ),
+      ),
+    );
+    final result = await lease.stop(const Duration(seconds: 1));
+
+    expect(stopRequests, 2);
+    expect(result.stopped, isFalse);
+    expect(result.exitConfirmed, isTrue);
+  });
+
   test(
     'Helper launcher compensates an uncertain start with exact stop',
     () async {

test/core/desktop/launcher_test.dart

@@ -56,6 +56,26 @@ void main() {
     expect(result.stopped, isTrue);
     expect(result.exitConfirmed, isFalse);
   });
+
+  test('direct lease rechecks exit after an unconfirmed timeout', () async {
+    final exitCode = Completer<int>();
+    final process = _FakeProcess(pid: 42, exitCode: exitCode.future);
+    final launcher = DirectCoreLauncher(
+      startProcess: (_, _) async => process,
+      corePath: 'FlClashCore',
+    );
+    final lease = await launcher.start(
+      sessionId: '0123456789abcdef0123456789abcdef',
+      address: 'test-address',
+    );
+
+    final firstResult = await lease.stop(Duration.zero);
+    exitCode.complete(0);
+    final secondResult = await lease.stop(const Duration(seconds: 1));
+
+    expect(firstResult.exitConfirmed, isFalse);
+    expect(secondResult.exitConfirmed, isTrue);
+  });
 }
 
 class _FakeProcess implements Process {