test(ssh): wait for server exit during handover

packages/ssh/src/tunnel.test.ts

@@ -1309,26 +1309,17 @@ server.listen(Number(flag("--port")), "127.0.0.1", () => {
       assert.equal(launched.serverKind, "managed");
       return { launched, pid };
     });
-    // An unreaped server runs under a parent that never waits on it, so once it
-    // exits it lingers as a zombie.
-    const startDefaultHomeServer = (
-      flags: ReadonlyArray<string>,
-      options?: { readonly unreaped?: boolean },
-    ) =>
+    const startDefaultHomeServer = (flags: ReadonlyArray<string>) =>
       Effect.gen(function* () {
         const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
         const args = [fakeServer, "serve", "--port", "0", "--base-dir", `${home}/.t3`, ...flags];
-        const server = yield* spawner.spawn(
-          options?.unreaped
-            ? ChildProcess.make("sh", ["-c", 'node "$@" & exec sleep 600', "sh", ...args])
-            : ChildProcess.make("node", args),
-        );
+        const server = yield* spawner.spawn(ChildProcess.make("node", args));
         const port = yield* server.stdout.pipe(
           Stream.decodeText(),
           Stream.splitLines,
           Stream.runHead,
         );
-        return Number(Option.getOrThrow(port));
+        return { port: Number(Option.getOrThrow(port)), exitCode: server.exitCode };
       });
     return {
       home,
@@ -1363,7 +1354,7 @@ server.listen(Number(flag("--port")), "127.0.0.1", () => {
           `${launched.remotePort}`,
         );
 
-        const servicePort = yield* startDefaultHomeServer([]);
+        const { port: servicePort } = yield* startDefaultHomeServer([]);
         assert.deepEqual(yield* runLaunch, {
           remotePort: servicePort,
           serverKind: "external",
@@ -1516,7 +1507,7 @@ server.listen(Number(flag("--port")), "127.0.0.1", () => {
         const fs = yield* FileSystem.FileSystem;
         const { stateDir, runLaunch, startDefaultHomeServer } = yield* prepareLaunch;
         yield* fs.writeFileString(`${stateDir}/managed`, "managed\n");
-        const servicePort = yield* startDefaultHomeServer(["--answer-once"]);
+        const { port: servicePort } = yield* startDefaultHomeServer(["--answer-once"]);
 
         assert.deepEqual(yield* runLaunch, { remotePort: servicePort, serverKind: "external" });
         assert.isFalse(yield* fs.exists(`${stateDir}/pid`));
@@ -1528,13 +1519,36 @@ server.listen(Number(flag("--port")), "127.0.0.1", () => {
     "launches a replacement when the adopted server exits during the handover",
     () =>
       Effect.gen(function* () {
-        const { readManagedPid, runLaunch, launchManaged, startDefaultHomeServer } =
+        const fs = yield* FileSystem.FileSystem;
+        const { home, launch, readManagedPid, launchManaged, startDefaultHomeServer } =
           yield* prepareLaunch;
         const { pid: previousPid } = yield* launchManaged;
-        yield* startDefaultHomeServer(["--exit-after-answer"], { unreaped: true });
+        const server = yield* startDefaultHomeServer(["--exit-after-answer"]);
+        const adopted = yield* Deferred.make<void>();
+        const script = yield* fs.readFileString(launch);
+        const adoption = 'ADOPTED_PID="$DEFAULT_RUNTIME_PID"';
+        assert.include(script, adoption);
+        // A flushed response can arrive before process exit. Hold the launcher at
+        // adoption until the fixture has exited, then test its handover check.
+        yield* fs.writeFileString(
+          launch,
+          script.replace(adoption, `${adoption}\n    echo adopted >&2\n    read -r release`),
+        );
 
-        const result = yield* runLaunch;
-        assert.equal(result.serverKind, "managed");
+        const result = yield* runScript(home, [launch, "test-state"], {
+          stdin: Stream.fromEffect(
+            Deferred.await(adopted).pipe(
+              Effect.andThen(server.exitCode.pipe(Effect.orDie)),
+              Effect.as(new TextEncoder().encode("release\n")),
+            ),
+          ),
+          onStderrLine: (line) =>
+            line === "adopted"
+              ? Deferred.succeed(adopted, undefined).pipe(Effect.asVoid)
+              : Effect.void,
+        });
+        assert.equal(result.exitCode, 0, result.stderr);
+        assert.equal(launchResult(result.stdout).serverKind, "managed");
         const replacementPid = yield* readManagedPid;
         assert.notEqual(replacementPid, previousPid);
         assert.isTrue(isAlive(replacementPid));