@opencode-ai/util 0.0.0-beta-18707 → 0.0.0-beta-18721

package/dist/cross-spawn-spawner.js

@@ -192,19 +192,23 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
             return Effect.as(Effect.forkScoped(Stream.run(cfg.stream, sink)), sink);
         return Effect.succeed(sink);
     });
-    const setupOutput = (command, proc, out, err) => {
-        let stdout = proc.stdout
-            ? NodeStream.fromReadable({
-                evaluate: () => proc.stdout,
-                onError: (cause) => toPlatformError("fromReadable(stdout)", toError(cause), command),
-            })
-            : Stream.empty;
-        let stderr = proc.stderr
-            ? NodeStream.fromReadable({
-                evaluate: () => proc.stderr,
-                onError: (cause) => toPlatformError("fromReadable(stderr)", toError(cause), command),
-            })
-            : Stream.empty;
+    const setupOutput = (command, proc, out, err, stopOutput) => {
+        const capture = (readable, name) => {
+            if (!readable)
+                return Stream.empty;
+            return NodeStream.fromReadable({
+                evaluate: () => readable,
+                onError: (cause) => toPlatformError(`fromReadable(${name})`, toError(cause), command),
+                closeOnDone: false,
+            }).pipe(Stream.interruptWhen(Deferred.await(stopOutput)), Stream.ensuring(Effect.gen(function* () {
+                // Only the capture deadline transfers the reader back to the process scope.
+                if (yield* Deferred.isDone(stopOutput))
+                    return;
+                readable.destroy();
+            })));
+        };
+        let stdout = capture(proc.stdout, "stdout");
+        let stderr = capture(proc.stderr, "stderr");
         if (Sink.isSink(out.stream))
             stdout = Stream.transduce(stdout, out.stream);
         if (Sink.isSink(err.stream))
@@ -212,7 +216,8 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
         return { stdout, stderr, all: Stream.merge(stdout, stderr) };
     };
     const launchProcess = (command, opts) => Effect.callback((resume) => {
-        const signal = Deferred.makeUnsafe();
+        const closed = Deferred.makeUnsafe();
+        const exited = Deferred.makeUnsafe();
         const proc = launch(command.command, command.args, opts);
         let end = false;
         let exit;
@@ -221,15 +226,17 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
         });
         proc.on("exit", (...args) => {
             exit = args;
+            Deferred.doneUnsafe(exited, Exit.succeed(args));
         });
         proc.on("close", (...args) => {
             if (end)
                 return;
             end = true;
-            Deferred.doneUnsafe(signal, Exit.succeed(exit ?? args));
+            Deferred.doneUnsafe(exited, Exit.succeed(exit ?? args));
+            Deferred.doneUnsafe(closed, Exit.succeed(exit ?? args));
         });
         proc.on("spawn", () => {
-            resume(Effect.succeed([proc, signal]));
+            resume(Effect.succeed([proc, closed, exited]));
         });
         return Effect.sync(() => {
             proc.kill("SIGTERM");
@@ -237,8 +244,35 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
     });
     const spawn = Effect.fnUntraced(function* (command, opts) {
         yield* Effect.logInfo("spawning process", { command: command.command, args: command.args, cwd: opts.cwd });
-        return yield* launchProcess(command, opts);
+        const [proc, closed, exited] = yield* launchProcess(command, opts);
+        const stopOutput = yield* Deferred.make();
+        // Register before process release so the deadline remains active during termination.
+        yield* Effect.forkScoped(Effect.gen(function* () {
+            yield* Deferred.await(exited);
+            // Particularly on Windows, some shell calls will cause detached descendants. Inherited stdio can hang the call.
+            // Almost every ecosystem has tried to fix this; there's no single "good" answer here.
+            // Calls that trigger this are e.g. dotnet build with warmed MSBuild processes, agent-browser, etc.
+            // One shared deadline covers stdout and stderr, then the output pump finishes its file.
+            if ((yield* Effect.timeoutOption(Deferred.await(closed), "1 second"))._tag === "Some")
+                return;
+            yield* Deferred.succeed(stopOutput, undefined);
+            discard(proc.stdout);
+            discard(proc.stderr);
+        }));
+        return [proc, closed, exited, stopOutput];
     });
+    const discard = (readable) => {
+        if (!readable || readable.destroyed)
+            return;
+        // read() also drains while a backpressured Effect adapter still has a readable listener.
+        const drain = () => {
+            while (readable.read() !== null) { }
+        };
+        readable.on("readable", drain);
+        readable.once("error", () => { });
+        readable.once("close", () => readable.off("readable", drain));
+        drain();
+    };
     const killGroup = (command, proc, signal) => {
         if (globalThis.process.platform === "win32") {
             return Effect.callback((resume) => {
@@ -261,23 +295,16 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
             return Effect.void;
         return Effect.fail(toPlatformError("kill", new Error("Failed to kill child process"), command));
     });
-    const stop = (command, proc, exit, opts) => {
-        const send = (signal) => Effect.catch(killGroup(command, proc, signal), () => killOne(command, proc, signal));
-        const attempt = send(opts?.killSignal ?? "SIGTERM").pipe(Effect.andThen(Deferred.await(exit)), Effect.asVoid);
-        if (!opts?.forceKillAfter)
+    const stop = (command, proc, closed, stopOutput, opts) => {
+        const terminate = (signal) => Effect.catch(killGroup(command, proc, signal), () => killOne(command, proc, signal)).pipe(Effect.andThen(signal === "SIGKILL"
+            ? Effect.raceFirst(Deferred.await(closed), Deferred.await(stopOutput))
+            : Deferred.await(closed)), Effect.asVoid);
+        const attempt = terminate(opts?.killSignal ?? "SIGTERM");
+        if (opts?.forceKillAfter === undefined)
             return attempt;
         return Effect.timeoutOrElse(attempt, {
             duration: opts.forceKillAfter,
-            orElse: () => send("SIGKILL").pipe(Effect.andThen(Deferred.await(exit)), Effect.asVoid),
-        });
-    };
-    const timeout = (proc, command, opts) => (f) => {
-        const signal = opts?.killSignal ?? "SIGTERM";
-        if (Predicate.isUndefined(opts?.forceKillAfter))
-            return f(command, proc, signal);
-        return Effect.timeoutOrElse(f(command, proc, signal), {
-            duration: opts.forceKillAfter,
-            orElse: () => f(command, proc, "SIGKILL"),
+            orElse: () => terminate("SIGKILL"),
         });
     };
     const source = (handle, from) => {
@@ -303,28 +330,34 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
                 const serr = stdio(command.options, "stderr");
                 const extra = fds(command.options);
                 const dir = yield* cwd(command.options);
-                const [proc, signal] = yield* Effect.acquireRelease(spawn(command, {
+                const [proc, closed, exited, stopOutput] = yield* Effect.acquireRelease(spawn(command, {
                     cwd: dir,
                     env: env(command.options),
                     stdio: stdios(sin, sout, serr, extra),
                     detached: command.options.detached ?? process.platform !== "win32",
                     shell: command.options.shell,
                     windowsHide: process.platform === "win32",
-                }), Effect.fnUntraced(function* ([proc, signal]) {
-                    const done = yield* Deferred.isDone(signal);
-                    const kill = timeout(proc, command, command.options);
+                }), Effect.fnUntraced(function* ([proc, closed, exited, stopOutput]) {
+                    const done = (yield* Deferred.isDone(closed)) || (yield* Deferred.isDone(stopOutput));
                     if (done) {
-                        const [code] = yield* Deferred.await(signal);
+                        const [code] = yield* Deferred.await(exited);
                         if (process.platform === "win32")
-                            return yield* Effect.void;
-                        if (code !== 0 && Predicate.isNotNull(code))
-                            return yield* Effect.ignore(kill(killGroup));
-                        return yield* Effect.void;
+                            return;
+                        if (code === 0 || Predicate.isNull(code))
+                            return;
+                        if (command.options.forceKillAfter === undefined) {
+                            return yield* Effect.ignore(killGroup(command, proc, command.options.killSignal ?? "SIGTERM"));
+                        }
                     }
-                    return yield* Effect.ignore(stop(command, proc, signal, command.options));
-                }));
+                    yield* Effect.ignore(stop(command, proc, closed, stopOutput, command.options));
+                }, (effect, [proc, , , stopOutput]) => effect.pipe(Effect.ensuring(Effect.gen(function* () {
+                    yield* Deferred.succeed(stopOutput, undefined);
+                    proc.stdout?.destroy();
+                    proc.stderr?.destroy();
+                })))));
+                const completion = Effect.raceFirst(Deferred.await(closed), Deferred.await(stopOutput).pipe(Effect.andThen(Deferred.await(exited))));
                 const fd = yield* setupFds(command, proc, extra);
-                const out = setupOutput(command, proc, sout, serr);
+                const out = setupOutput(command, proc, sout, serr, stopOutput);
                 let ref = true;
                 return makeHandle({
                     pid: ProcessId(proc.pid),
@@ -334,13 +367,15 @@ const makeCrossSpawnSpawner = Effect.gen(function* () {
                     all: out.all,
                     getInputFd: fd.getInputFd,
                     getOutputFd: fd.getOutputFd,
-                    isRunning: Effect.map(Deferred.isDone(signal), (done) => !done),
-                    exitCode: Effect.flatMap(Deferred.await(signal), ([code, signal]) => {
+                    isRunning: Effect.gen(function* () {
+                        return !(yield* Deferred.isDone(closed)) && !(yield* Deferred.isDone(stopOutput));
+                    }),
+                    exitCode: Effect.flatMap(completion, ([code, signal]) => {
                         if (Predicate.isNotNull(code))
                             return Effect.succeed(ExitCode(code));
                         return Effect.fail(toPlatformError("exitCode", new Error(`Process interrupted due to receipt of signal: '${signal}'`), command));
                     }),
-                    kill: (opts) => stop(command, proc, signal, opts),
+                    kill: (opts) => stop(command, proc, closed, stopOutput, opts),
                     unref: Effect.sync(() => {
                         if (ref) {
                             proc.unref();

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-beta-18707",
+  "version": "0.0.0-beta-18721",
   "type": "module",
   "license": "MIT",
   "repository": {