@effectionx/process 0.5.0 → 0.6.1

package/README.md

@@ -1,12 +1,201 @@
-# @effection/process
+# Process
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Created by Frontside](https://img.shields.io/badge/created%20by-frontside-26abe8.svg)](https://frontside.com)
-[![Chat on Discord](https://img.shields.io/discord/700803887132704931?Label=Discord)](https://discord.gg/Ug5nWH8)
+Execute and manage system processes with structured concurrency. A library for
+spawning and controlling child processes in Effection programs.
 
-[Effection][Effection] is the structured concurrency toolkit for JavaScript. You
-can find detailed information about using effection to manage system process in
-node in the
-[spawning processes guide](https://frontside.com/effection/docs/guides/processes)
+---
 
-[Effection]: https://frontside.com/effection
+This package provides two main functions: `exec()` for running processes with a
+finite lifetime, and `daemon()` for long-running processes like servers.
+
+## Features
+
+- Stream-based access to stdout and stderr
+- Writable stdin for sending input to processes
+- Proper signal handling and cleanup on both POSIX and Windows
+- Shell mode for complex commands with glob expansion
+- Structured error handling with `join()` and `expect()` methods
+
+## Basic Usage
+
+### Running a Command
+
+Use `exec()` to run a command and wait for it to complete:
+
+```typescript
+import { main } from "effection";
+import { exec } from "@effectionx/process";
+
+await main(function* () {
+  // Run a command and get the result
+  let result = yield* exec("echo 'Hello World'").join();
+
+  console.log(result.stdout); // "Hello World\n"
+  console.log(result.code); // 0
+});
+```
+
+### Streaming Output
+
+Access stdout and stderr as streams for real-time output processing:
+
+```typescript
+import { each, main, spawn } from "effection";
+import { exec } from "@effectionx/process";
+
+await main(function* () {
+  let process = yield* exec("npm install");
+
+  // Stream stdout in real-time
+  yield* spawn(function* () {
+    for (let chunk of yield* each(yield* process.stdout)) {
+      console.log(chunk);
+      yield* each.next();
+    }
+  });
+
+  // Wait for the process to complete
+  yield* process.expect();
+});
+```
+
+### Sending Input to stdin
+
+Write to a process's stdin:
+
+```typescript
+import { main } from "effection";
+import { exec } from "@effectionx/process";
+
+await main(function* () {
+  let process = yield* exec("cat");
+
+  process.stdin.send("Hello from stdin!\n");
+
+  let result = yield* process.join();
+  console.log(result.stdout); // "Hello from stdin!\n"
+});
+```
+
+## join() vs expect()
+
+Both methods wait for the process to complete and collect stdout/stderr, but
+they differ in error handling:
+
+- **`join()`** - Always returns the result, regardless of exit code
+- **`expect()`** - Throws an `ExecError` if the process exits with a non-zero
+  code
+
+```typescript
+import { main } from "effection";
+import { exec, ExecError } from "@effectionx/process";
+
+await main(function* () {
+  // join() returns result even on failure
+  let result = yield* exec("exit 1", { shell: true }).join();
+  console.log(result.code); // 1
+
+  // expect() throws on non-zero exit
+  try {
+    yield* exec("exit 1", { shell: true }).expect();
+  } catch (error) {
+    if (error instanceof ExecError) {
+      console.log(error.message); // Command failed with exit code 1
+    }
+  }
+});
+```
+
+## Running Daemons
+
+Use `daemon()` for long-running processes like servers. Unlike `exec()`, a
+daemon is expected to run forever - if it exits prematurely, it raises an error:
+
+```typescript
+import { main, suspend } from "effection";
+import { daemon } from "@effectionx/process";
+
+await main(function* () {
+  // Start a web server
+  let server = yield* daemon("node server.js");
+
+  console.log(`Server started with PID: ${server.pid}`);
+
+  // The server will be automatically terminated when this scope exits
+  yield* suspend();
+});
+```
+
+## Options
+
+The `exec()` and `daemon()` functions accept an options object:
+
+```typescript
+interface ExecOptions {
+  // Additional arguments to pass to the command
+  arguments?: string[];
+
+  // Environment variables for the process
+  env?: Record<string, string>;
+
+  // Use shell to interpret the command (enables glob expansion, pipes, etc.)
+  // Can be true for default shell or a path to a specific shell
+  shell?: boolean | string;
+
+  // Working directory for the process
+  cwd?: string;
+}
+```
+
+### Examples
+
+```typescript
+import { main } from "effection";
+import { exec } from "@effectionx/process";
+
+await main(function* () {
+  // Pass arguments
+  yield* exec("git", {
+    arguments: ["commit", "-m", "Initial commit"],
+  }).expect();
+
+  // Set environment variables
+  yield* exec("node app.js", {
+    env: { NODE_ENV: "production", PORT: "3000" },
+  }).expect();
+
+  // Use shell mode for complex commands
+  yield* exec("ls *.ts | wc -l", {
+    shell: true,
+  }).expect();
+
+  // Set working directory
+  yield* exec("npm install", {
+    cwd: "./packages/my-package",
+  }).expect();
+});
+```
+
+## Process Interface
+
+The `Process` object returned by `exec()` provides:
+
+```typescript
+interface Process {
+  // Process ID
+  readonly pid: number;
+
+  // Output streams
+  stdout: Stream<string>;
+  stderr: Stream<string>;
+
+  // Input stream
+  stdin: Writable<string>;
+
+  // Wait for completion (returns exit status)
+  join(): Operation<ExitStatus>;
+
+  // Wait for successful completion (throws on non-zero exit)
+  expect(): Operation<ExitStatus>;
+}
+```

package/esm/src/exec/posix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"posix.d.ts","sourceRoot":"","sources":["../../../src/src/exec/posix.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAKtE,eAAO,MAAM,kBAAkB,EAAE,eAkHhC,CAAC"}
+{"version":3,"file":"posix.d.ts","sourceRoot":"","sources":["../../../src/src/exec/posix.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAKtE,eAAO,MAAM,kBAAkB,EAAE,eAkHhC,CAAC"}

package/esm/src/exec/posix.js

@@ -1,69 +1,97 @@
 import { spawn as spawnProcess } from "node:child_process";
-import { all, createSignal, Err, Ok, spawn, withResolvers, } from "effection";
+import { all, createSignal, Err, Ok, resource, spawn, withResolvers, } from "effection";
 import process from "node:process";
 import { once } from "../eventemitter.js";
 import { useReadable } from "../helpers.js";
 import { ExecError } from "./error.js";
-export const createPosixProcess = function* createPosixProcess(command, options) {
-    let processResult = withResolvers();
-    // Killing all child processes started by this command is surprisingly
-    // tricky. If a process spawns another processes and we kill the parent,
-    // then the child process is NOT automatically killed. Instead we're using
-    // the `detached` option to force the child into its own process group,
-    // which all of its children in turn will inherit. By sending the signal to
-    // `-pid` rather than `pid`, we are sending it to the entire process group
-    // instead. This will send the signal to all processes started by the child
-    // process.
-    //
-    // More information here: https://unix.stackexchange.com/questions/14815/process-descendants
-    let childProcess = spawnProcess(command, options.arguments || [], {
-        detached: true,
-        shell: options.shell,
-        env: options.env,
-        cwd: options.cwd,
-        stdio: "pipe",
-    });
-    let { pid } = childProcess;
-    let io = {
-        stdout: yield* useReadable(childProcess.stdout),
-        stderr: yield* useReadable(childProcess.stderr),
-        stdoutDone: withResolvers(),
-        stderrDone: withResolvers(),
-    };
-    let stdout = createSignal();
-    let stderr = createSignal();
-    yield* spawn(function* () {
-        let next = yield* io.stdout.next();
-        while (!next.done) {
-            stdout.send(next.value);
-            next = yield* io.stdout.next();
+export const createPosixProcess = (command, options) => {
+    return resource(function* (provide) {
+        let processResult = withResolvers();
+        // Killing all child processes started by this command is surprisingly
+        // tricky. If a process spawns another processes and we kill the parent,
+        // then the child process is NOT automatically killed. Instead we're using
+        // the `detached` option to force the child into its own process group,
+        // which all of its children in turn will inherit. By sending the signal to
+        // `-pid` rather than `pid`, we are sending it to the entire process group
+        // instead. This will send the signal to all processes started by the child
+        // process.
+        //
+        // More information here: https://unix.stackexchange.com/questions/14815/process-descendants
+        let childProcess = spawnProcess(command, options.arguments || [], {
+            detached: true,
+            shell: options.shell,
+            env: options.env,
+            cwd: options.cwd,
+            stdio: "pipe",
+        });
+        let { pid } = childProcess;
+        let io = {
+            stdout: yield* useReadable(childProcess.stdout),
+            stderr: yield* useReadable(childProcess.stderr),
+            stdoutDone: withResolvers(),
+            stderrDone: withResolvers(),
+        };
+        let stdout = createSignal();
+        let stderr = createSignal();
+        yield* spawn(function* () {
+            let next = yield* io.stdout.next();
+            while (!next.done) {
+                stdout.send(next.value);
+                next = yield* io.stdout.next();
+            }
+            stdout.close();
+            io.stdoutDone.resolve();
+        });
+        yield* spawn(function* () {
+            let next = yield* io.stderr.next();
+            while (!next.done) {
+                stderr.send(next.value);
+                next = yield* io.stderr.next();
+            }
+            stderr.close();
+            io.stderrDone.resolve();
+        });
+        let stdin = {
+            send(data) {
+                childProcess.stdin.write(data);
+            },
+        };
+        yield* spawn(function* trapError() {
+            let [error] = yield* once(childProcess, "error");
+            processResult.resolve(Err(error));
+        });
+        yield* spawn(function* () {
+            let value = yield* once(childProcess, "close");
+            processResult.resolve(Ok(value));
+        });
+        function* join() {
+            let result = yield* processResult.operation;
+            if (result.ok) {
+                let [code, signal] = result.value;
+                return { command, options, code, signal };
+            }
+            else {
+                throw result.error;
+            }
         }
-        stdout.close();
-        io.stdoutDone.resolve();
-    });
-    yield* spawn(function* () {
-        let next = yield* io.stderr.next();
-        while (!next.done) {
-            stderr.send(next.value);
-            next = yield* io.stderr.next();
+        function* expect() {
+            let status = yield* join();
+            if (status.code != 0) {
+                throw new ExecError(status, command, options);
+            }
+            else {
+                return status;
+            }
         }
-        stderr.close();
-        io.stderrDone.resolve();
-    });
-    yield* spawn(function* trapError() {
-        let [error] = yield* once(childProcess, "error");
-        processResult.resolve(Err(error));
-    });
-    let stdin = {
-        send(data) {
-            childProcess.stdin.write(data);
-        },
-    };
-    yield* spawn(function* () {
         try {
-            let value = yield* once(childProcess, "close");
-            yield* all([io.stdoutDone.operation, io.stderrDone.operation]);
-            processResult.resolve(Ok(value));
+            yield* provide({
+                pid: pid,
+                stdin,
+                stdout,
+                stderr,
+                join,
+                expect,
+            });
         }
         finally {
             try {
@@ -79,32 +107,4 @@ export const createPosixProcess = function* createPosixProcess(command, options)
             }
         }
     });
-    function* join() {
-        let result = yield* processResult.operation;
-        if (result.ok) {
-            let [code, signal] = result.value;
-            return { command, options, code, signal };
-        }
-        else {
-            throw result.error;
-        }
-    }
-    function* expect() {
-        let status = yield* join();
-        if (status.code != 0) {
-            throw new ExecError(status, command, options);
-        }
-        else {
-            return status;
-        }
-    }
-    // FYI: this function starts a process and returns without blocking
-    return {
-        pid: pid,
-        stdin,
-        stdout,
-        stderr,
-        join,
-        expect,
-    };
 };

package/esm/src/exec/win32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"win32.d.ts","sourceRoot":"","sources":["../../../src/src/exec/win32.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAkBtE,eAAO,MAAM,kBAAkB,EAAE,eA8KhC,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,OAAiC,CAAC"}
+{"version":3,"file":"win32.d.ts","sourceRoot":"","sources":["../../../src/src/exec/win32.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAkBtE,eAAO,MAAM,kBAAkB,EAAE,eA4KhC,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,OAAiC,CAAC"}

package/esm/src/exec/win32.js

@@ -1,5 +1,5 @@
 import { platform } from "node:os";
-import { all, createSignal, Err, Ok, race, sleep, spawn, withResolvers, } from "effection";
+import { all, createSignal, Err, Ok, resource, spawn, withResolvers, } from "effection";
 // @ts-types="npm:@types/cross-spawn@6.0.6"
 import { spawn as spawnProcess } from "cross-spawn";
 import { ctrlc } from "ctrlc-windows";
@@ -15,69 +15,98 @@ function* killTree(pid) {
         // best-effort; ignore errors
     }
 }
-export const createWin32Process = function* createWin32Process(command, options) {
-    let processResult = withResolvers();
-    // Windows-specific process spawning with different options than POSIX
-    let childProcess = spawnProcess(command, options.arguments || [], {
-        // We lose exit information and events if this is detached in windows
-        // and it opens a window in windows+powershell.
-        detached: false,
-        // The `shell` option is passed to `cross-spawn` to control whether a shell is used.
-        // On Windows, `shell: true` is necessary to run command strings, as it uses
-        // `cmd.exe` to parse the command and find executables in the PATH.
-        // Using a boolean `true` was previously disabled, causing ENOENT errors for
-        // commands that were not a direct path to an executable.
-        shell: options.shell || false,
-        // With stdio as pipe, windows gets stuck where neither the child nor the
-        // parent wants to close the stream, so we call it ourselves in the exit event.
-        stdio: "pipe",
-        // Hide the child window so that killing it will not block the parent
-        // with a Terminate Batch Process (Y/n)
-        windowsHide: true,
-        env: options.env,
-        cwd: options.cwd,
-    });
-    let { pid } = childProcess;
-    let io = {
-        stdout: yield* useReadable(childProcess.stdout),
-        stderr: yield* useReadable(childProcess.stderr),
-        stdoutDone: withResolvers(),
-        stderrDone: withResolvers(),
-    };
-    const stdout = createSignal();
-    const stderr = createSignal();
-    yield* spawn(function* () {
-        let next = yield* io.stdout.next();
-        while (!next.done) {
-            stdout.send(next.value);
-            next = yield* io.stdout.next();
-        }
-        stdout.close();
-        io.stdoutDone.resolve();
-    });
-    yield* spawn(function* () {
-        let next = yield* io.stderr.next();
-        while (!next.done) {
-            stderr.send(next.value);
-            next = yield* io.stderr.next();
-        }
-        stderr.close();
-        io.stderrDone.resolve();
-    });
-    yield* spawn(function* trapError() {
-        const [error] = yield* once(childProcess, "error");
-        processResult.resolve(Err(error));
-    });
-    let stdin = {
-        send(data) {
-            childProcess.stdin.write(data);
-        },
-    };
-    yield* spawn(function* () {
-        try {
+export const createWin32Process = (command, options) => {
+    return resource(function* (provide) {
+        let processResult = withResolvers();
+        // Windows-specific process spawning with different options than POSIX
+        let childProcess = spawnProcess(command, options.arguments || [], {
+            // We lose exit information and events if this is detached in windows
+            // and it opens a window in windows+powershell.
+            detached: false,
+            // The `shell` option is passed to `cross-spawn` to control whether a shell is used.
+            // On Windows, `shell: true` is necessary to run command strings, as it uses
+            // `cmd.exe` to parse the command and find executables in the PATH.
+            // Using a boolean `true` was previously disabled, causing ENOENT errors for
+            // commands that were not a direct path to an executable.
+            shell: options.shell || false,
+            // With stdio as pipe, windows gets stuck where neither the child nor the
+            // parent wants to close the stream, so we call it ourselves in the exit event.
+            stdio: "pipe",
+            // Hide the child window so that killing it will not block the parent
+            // with a Terminate Batch Process (Y/n)
+            windowsHide: true,
+            env: options.env,
+            cwd: options.cwd,
+        });
+        let { pid } = childProcess;
+        let io = {
+            stdout: yield* useReadable(childProcess.stdout),
+            stderr: yield* useReadable(childProcess.stderr),
+            stdoutDone: withResolvers(),
+            stderrDone: withResolvers(),
+        };
+        const stdout = createSignal();
+        const stderr = createSignal();
+        yield* spawn(function* () {
+            let next = yield* io.stdout.next();
+            while (!next.done) {
+                stdout.send(next.value);
+                next = yield* io.stdout.next();
+            }
+            stdout.close();
+            io.stdoutDone.resolve();
+        });
+        yield* spawn(function* () {
+            let next = yield* io.stderr.next();
+            while (!next.done) {
+                stderr.send(next.value);
+                next = yield* io.stderr.next();
+            }
+            stderr.close();
+            io.stderrDone.resolve();
+        });
+        let stdin = {
+            send(data) {
+                childProcess.stdin.write(data);
+            },
+        };
+        yield* spawn(function* trapError() {
+            const [error] = yield* once(childProcess, "error");
+            processResult.resolve(Err(error));
+        });
+        yield* spawn(function* () {
             let value = yield* once(childProcess, "close");
             yield* all([io.stdoutDone.operation, io.stderrDone.operation]);
             processResult.resolve(Ok(value));
+        });
+        function* join() {
+            let result = yield* processResult.operation;
+            if (result.ok) {
+                let [code, signal] = result.value;
+                return { command, options, code, signal };
+            }
+            else {
+                throw result.error;
+            }
+        }
+        function* expect() {
+            let status = yield* join();
+            if (status.code != 0) {
+                throw new ExecError(status, command, options);
+            }
+            else {
+                return status;
+            }
+        }
+        try {
+            yield* provide({
+                pid: pid,
+                stdin,
+                stdout,
+                stderr,
+                join,
+                expect,
+            });
         }
         finally {
             try {
@@ -112,8 +141,6 @@ export const createWin32Process = function* createWin32Process(command, options)
                     catch (_err) {
                         // stdin might already be closed
                     }
-                    // Wait for graceful exit with a timeout
-                    yield* race([processResult.operation, sleep(300)]);
                     // If process still hasn't exited, escalate
                     if (childProcess.exitCode === null &&
                         childProcess.signalCode === null) {
@@ -141,33 +168,5 @@ export const createWin32Process = function* createWin32Process(command, options)
             }
         }
     });
-    function* join() {
-        let result = yield* processResult.operation;
-        if (result.ok) {
-            let [code, signal] = result.value;
-            return { command, options, code, signal };
-        }
-        else {
-            throw result.error;
-        }
-    }
-    function* expect() {
-        let status = yield* join();
-        if (status.code != 0) {
-            throw new ExecError(status, command, options);
-        }
-        else {
-            return status;
-        }
-    }
-    // FYI: this function starts a process and returns without blocking
-    return {
-        pid: pid,
-        stdin,
-        stdout,
-        stderr,
-        join,
-        expect,
-    };
 };
 export const isWin32 = () => platform() === "win32";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectionx/process",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "author": "engineering@frontside.com",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
     "@types/cross-spawn": "6.0.6",
     "cross-spawn": "7.0.6",
     "ctrlc-windows": "2.2.0",
-    "effection": "^3",
+    "effection": "^3 || ^4.0.0-0",
     "shellwords": "^1.1.1"
   },
   "_generatedBy": "dnt@dev"

package/script/src/exec/posix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"posix.d.ts","sourceRoot":"","sources":["../../../src/src/exec/posix.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAKtE,eAAO,MAAM,kBAAkB,EAAE,eAkHhC,CAAC"}
+{"version":3,"file":"posix.d.ts","sourceRoot":"","sources":["../../../src/src/exec/posix.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAKtE,eAAO,MAAM,kBAAkB,EAAE,eAkHhC,CAAC"}

package/script/src/exec/posix.js

@@ -10,66 +10,94 @@ const node_process_1 = __importDefault(require("node:process"));
 const eventemitter_js_1 = require("../eventemitter.js");
 const helpers_js_1 = require("../helpers.js");
 const error_js_1 = require("./error.js");
-const createPosixProcess = function* createPosixProcess(command, options) {
-    let processResult = (0, effection_1.withResolvers)();
-    // Killing all child processes started by this command is surprisingly
-    // tricky. If a process spawns another processes and we kill the parent,
-    // then the child process is NOT automatically killed. Instead we're using
-    // the `detached` option to force the child into its own process group,
-    // which all of its children in turn will inherit. By sending the signal to
-    // `-pid` rather than `pid`, we are sending it to the entire process group
-    // instead. This will send the signal to all processes started by the child
-    // process.
-    //
-    // More information here: https://unix.stackexchange.com/questions/14815/process-descendants
-    let childProcess = (0, node_child_process_1.spawn)(command, options.arguments || [], {
-        detached: true,
-        shell: options.shell,
-        env: options.env,
-        cwd: options.cwd,
-        stdio: "pipe",
-    });
-    let { pid } = childProcess;
-    let io = {
-        stdout: yield* (0, helpers_js_1.useReadable)(childProcess.stdout),
-        stderr: yield* (0, helpers_js_1.useReadable)(childProcess.stderr),
-        stdoutDone: (0, effection_1.withResolvers)(),
-        stderrDone: (0, effection_1.withResolvers)(),
-    };
-    let stdout = (0, effection_1.createSignal)();
-    let stderr = (0, effection_1.createSignal)();
-    yield* (0, effection_1.spawn)(function* () {
-        let next = yield* io.stdout.next();
-        while (!next.done) {
-            stdout.send(next.value);
-            next = yield* io.stdout.next();
+const createPosixProcess = (command, options) => {
+    return (0, effection_1.resource)(function* (provide) {
+        let processResult = (0, effection_1.withResolvers)();
+        // Killing all child processes started by this command is surprisingly
+        // tricky. If a process spawns another processes and we kill the parent,
+        // then the child process is NOT automatically killed. Instead we're using
+        // the `detached` option to force the child into its own process group,
+        // which all of its children in turn will inherit. By sending the signal to
+        // `-pid` rather than `pid`, we are sending it to the entire process group
+        // instead. This will send the signal to all processes started by the child
+        // process.
+        //
+        // More information here: https://unix.stackexchange.com/questions/14815/process-descendants
+        let childProcess = (0, node_child_process_1.spawn)(command, options.arguments || [], {
+            detached: true,
+            shell: options.shell,
+            env: options.env,
+            cwd: options.cwd,
+            stdio: "pipe",
+        });
+        let { pid } = childProcess;
+        let io = {
+            stdout: yield* (0, helpers_js_1.useReadable)(childProcess.stdout),
+            stderr: yield* (0, helpers_js_1.useReadable)(childProcess.stderr),
+            stdoutDone: (0, effection_1.withResolvers)(),
+            stderrDone: (0, effection_1.withResolvers)(),
+        };
+        let stdout = (0, effection_1.createSignal)();
+        let stderr = (0, effection_1.createSignal)();
+        yield* (0, effection_1.spawn)(function* () {
+            let next = yield* io.stdout.next();
+            while (!next.done) {
+                stdout.send(next.value);
+                next = yield* io.stdout.next();
+            }
+            stdout.close();
+            io.stdoutDone.resolve();
+        });
+        yield* (0, effection_1.spawn)(function* () {
+            let next = yield* io.stderr.next();
+            while (!next.done) {
+                stderr.send(next.value);
+                next = yield* io.stderr.next();
+            }
+            stderr.close();
+            io.stderrDone.resolve();
+        });
+        let stdin = {
+            send(data) {
+                childProcess.stdin.write(data);
+            },
+        };
+        yield* (0, effection_1.spawn)(function* trapError() {
+            let [error] = yield* (0, eventemitter_js_1.once)(childProcess, "error");
+            processResult.resolve((0, effection_1.Err)(error));
+        });
+        yield* (0, effection_1.spawn)(function* () {
+            let value = yield* (0, eventemitter_js_1.once)(childProcess, "close");
+            processResult.resolve((0, effection_1.Ok)(value));
+        });
+        function* join() {
+            let result = yield* processResult.operation;
+            if (result.ok) {
+                let [code, signal] = result.value;
+                return { command, options, code, signal };
+            }
+            else {
+                throw result.error;
+            }
         }
-        stdout.close();
-        io.stdoutDone.resolve();
-    });
-    yield* (0, effection_1.spawn)(function* () {
-        let next = yield* io.stderr.next();
-        while (!next.done) {
-            stderr.send(next.value);
-            next = yield* io.stderr.next();
+        function* expect() {
+            let status = yield* join();
+            if (status.code != 0) {
+                throw new error_js_1.ExecError(status, command, options);
+            }
+            else {
+                return status;
+            }
         }
-        stderr.close();
-        io.stderrDone.resolve();
-    });
-    yield* (0, effection_1.spawn)(function* trapError() {
-        let [error] = yield* (0, eventemitter_js_1.once)(childProcess, "error");
-        processResult.resolve((0, effection_1.Err)(error));
-    });
-    let stdin = {
-        send(data) {
-            childProcess.stdin.write(data);
-        },
-    };
-    yield* (0, effection_1.spawn)(function* () {
         try {
-            let value = yield* (0, eventemitter_js_1.once)(childProcess, "close");
-            yield* (0, effection_1.all)([io.stdoutDone.operation, io.stderrDone.operation]);
-            processResult.resolve((0, effection_1.Ok)(value));
+            yield* provide({
+                pid: pid,
+                stdin,
+                stdout,
+                stderr,
+                join,
+                expect,
+            });
         }
         finally {
             try {
@@ -85,33 +113,5 @@ const createPosixProcess = function* createPosixProcess(command, options) {
             }
         }
     });
-    function* join() {
-        let result = yield* processResult.operation;
-        if (result.ok) {
-            let [code, signal] = result.value;
-            return { command, options, code, signal };
-        }
-        else {
-            throw result.error;
-        }
-    }
-    function* expect() {
-        let status = yield* join();
-        if (status.code != 0) {
-            throw new error_js_1.ExecError(status, command, options);
-        }
-        else {
-            return status;
-        }
-    }
-    // FYI: this function starts a process and returns without blocking
-    return {
-        pid: pid,
-        stdin,
-        stdout,
-        stderr,
-        join,
-        expect,
-    };
 };
 exports.createPosixProcess = createPosixProcess;

package/script/src/exec/win32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"win32.d.ts","sourceRoot":"","sources":["../../../src/src/exec/win32.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAkBtE,eAAO,MAAM,kBAAkB,EAAE,eA8KhC,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,OAAiC,CAAC"}
+{"version":3,"file":"win32.d.ts","sourceRoot":"","sources":["../../../src/src/exec/win32.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,UAAU,CAAC;AAkBtE,eAAO,MAAM,kBAAkB,EAAE,eA4KhC,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,OAAiC,CAAC"}

package/script/src/exec/win32.js

@@ -18,69 +18,98 @@ function* killTree(pid) {
         // best-effort; ignore errors
     }
 }
-const createWin32Process = function* createWin32Process(command, options) {
-    let processResult = (0, effection_1.withResolvers)();
-    // Windows-specific process spawning with different options than POSIX
-    let childProcess = (0, cross_spawn_1.spawn)(command, options.arguments || [], {
-        // We lose exit information and events if this is detached in windows
-        // and it opens a window in windows+powershell.
-        detached: false,
-        // The `shell` option is passed to `cross-spawn` to control whether a shell is used.
-        // On Windows, `shell: true` is necessary to run command strings, as it uses
-        // `cmd.exe` to parse the command and find executables in the PATH.
-        // Using a boolean `true` was previously disabled, causing ENOENT errors for
-        // commands that were not a direct path to an executable.
-        shell: options.shell || false,
-        // With stdio as pipe, windows gets stuck where neither the child nor the
-        // parent wants to close the stream, so we call it ourselves in the exit event.
-        stdio: "pipe",
-        // Hide the child window so that killing it will not block the parent
-        // with a Terminate Batch Process (Y/n)
-        windowsHide: true,
-        env: options.env,
-        cwd: options.cwd,
-    });
-    let { pid } = childProcess;
-    let io = {
-        stdout: yield* (0, helpers_js_1.useReadable)(childProcess.stdout),
-        stderr: yield* (0, helpers_js_1.useReadable)(childProcess.stderr),
-        stdoutDone: (0, effection_1.withResolvers)(),
-        stderrDone: (0, effection_1.withResolvers)(),
-    };
-    const stdout = (0, effection_1.createSignal)();
-    const stderr = (0, effection_1.createSignal)();
-    yield* (0, effection_1.spawn)(function* () {
-        let next = yield* io.stdout.next();
-        while (!next.done) {
-            stdout.send(next.value);
-            next = yield* io.stdout.next();
-        }
-        stdout.close();
-        io.stdoutDone.resolve();
-    });
-    yield* (0, effection_1.spawn)(function* () {
-        let next = yield* io.stderr.next();
-        while (!next.done) {
-            stderr.send(next.value);
-            next = yield* io.stderr.next();
-        }
-        stderr.close();
-        io.stderrDone.resolve();
-    });
-    yield* (0, effection_1.spawn)(function* trapError() {
-        const [error] = yield* (0, eventemitter_js_1.once)(childProcess, "error");
-        processResult.resolve((0, effection_1.Err)(error));
-    });
-    let stdin = {
-        send(data) {
-            childProcess.stdin.write(data);
-        },
-    };
-    yield* (0, effection_1.spawn)(function* () {
-        try {
+const createWin32Process = (command, options) => {
+    return (0, effection_1.resource)(function* (provide) {
+        let processResult = (0, effection_1.withResolvers)();
+        // Windows-specific process spawning with different options than POSIX
+        let childProcess = (0, cross_spawn_1.spawn)(command, options.arguments || [], {
+            // We lose exit information and events if this is detached in windows
+            // and it opens a window in windows+powershell.
+            detached: false,
+            // The `shell` option is passed to `cross-spawn` to control whether a shell is used.
+            // On Windows, `shell: true` is necessary to run command strings, as it uses
+            // `cmd.exe` to parse the command and find executables in the PATH.
+            // Using a boolean `true` was previously disabled, causing ENOENT errors for
+            // commands that were not a direct path to an executable.
+            shell: options.shell || false,
+            // With stdio as pipe, windows gets stuck where neither the child nor the
+            // parent wants to close the stream, so we call it ourselves in the exit event.
+            stdio: "pipe",
+            // Hide the child window so that killing it will not block the parent
+            // with a Terminate Batch Process (Y/n)
+            windowsHide: true,
+            env: options.env,
+            cwd: options.cwd,
+        });
+        let { pid } = childProcess;
+        let io = {
+            stdout: yield* (0, helpers_js_1.useReadable)(childProcess.stdout),
+            stderr: yield* (0, helpers_js_1.useReadable)(childProcess.stderr),
+            stdoutDone: (0, effection_1.withResolvers)(),
+            stderrDone: (0, effection_1.withResolvers)(),
+        };
+        const stdout = (0, effection_1.createSignal)();
+        const stderr = (0, effection_1.createSignal)();
+        yield* (0, effection_1.spawn)(function* () {
+            let next = yield* io.stdout.next();
+            while (!next.done) {
+                stdout.send(next.value);
+                next = yield* io.stdout.next();
+            }
+            stdout.close();
+            io.stdoutDone.resolve();
+        });
+        yield* (0, effection_1.spawn)(function* () {
+            let next = yield* io.stderr.next();
+            while (!next.done) {
+                stderr.send(next.value);
+                next = yield* io.stderr.next();
+            }
+            stderr.close();
+            io.stderrDone.resolve();
+        });
+        let stdin = {
+            send(data) {
+                childProcess.stdin.write(data);
+            },
+        };
+        yield* (0, effection_1.spawn)(function* trapError() {
+            const [error] = yield* (0, eventemitter_js_1.once)(childProcess, "error");
+            processResult.resolve((0, effection_1.Err)(error));
+        });
+        yield* (0, effection_1.spawn)(function* () {
             let value = yield* (0, eventemitter_js_1.once)(childProcess, "close");
             yield* (0, effection_1.all)([io.stdoutDone.operation, io.stderrDone.operation]);
             processResult.resolve((0, effection_1.Ok)(value));
+        });
+        function* join() {
+            let result = yield* processResult.operation;
+            if (result.ok) {
+                let [code, signal] = result.value;
+                return { command, options, code, signal };
+            }
+            else {
+                throw result.error;
+            }
+        }
+        function* expect() {
+            let status = yield* join();
+            if (status.code != 0) {
+                throw new error_js_1.ExecError(status, command, options);
+            }
+            else {
+                return status;
+            }
+        }
+        try {
+            yield* provide({
+                pid: pid,
+                stdin,
+                stdout,
+                stderr,
+                join,
+                expect,
+            });
         }
         finally {
             try {
@@ -115,8 +144,6 @@ const createWin32Process = function* createWin32Process(command, options) {
                     catch (_err) {
                         // stdin might already be closed
                     }
-                    // Wait for graceful exit with a timeout
-                    yield* (0, effection_1.race)([processResult.operation, (0, effection_1.sleep)(300)]);
                     // If process still hasn't exited, escalate
                     if (childProcess.exitCode === null &&
                         childProcess.signalCode === null) {
@@ -144,34 +171,6 @@ const createWin32Process = function* createWin32Process(command, options) {
             }
         }
     });
-    function* join() {
-        let result = yield* processResult.operation;
-        if (result.ok) {
-            let [code, signal] = result.value;
-            return { command, options, code, signal };
-        }
-        else {
-            throw result.error;
-        }
-    }
-    function* expect() {
-        let status = yield* join();
-        if (status.code != 0) {
-            throw new error_js_1.ExecError(status, command, options);
-        }
-        else {
-            return status;
-        }
-    }
-    // FYI: this function starts a process and returns without blocking
-    return {
-        pid: pid,
-        stdin,
-        stdout,
-        stderr,
-        join,
-        expect,
-    };
 };
 exports.createWin32Process = createWin32Process;
 const isWin32 = () => (0, node_os_1.platform)() === "win32";