@effectionx/process 0.5.0

package/esm/src/exec.js

@@ -0,0 +1,75 @@
+import { split } from "shellwords";
+import { spawn } from "effection";
+import { createPosixProcess } from "./exec/posix.js";
+import { createWin32Process, isWin32 } from "./exec/win32.js";
+export * from "./exec/api.js";
+export * from "./exec/error.js";
+const createProcess = (cmd, opts) => {
+    if (isWin32()) {
+        return createWin32Process(cmd, opts);
+    }
+    else {
+        return createPosixProcess(cmd, opts);
+    }
+};
+/**
+ * Execute `command` with `options`. You should use this operation for processes
+ * that have a finite lifetime and on which you may wish to synchronize on the
+ * exit status. If you want to start a process like a server that spins up and runs
+ * forever, consider using `daemon()`
+ */
+export function exec(command, options = {}) {
+    let [cmd, ...args] = options.shell ? [command] : split(command);
+    let opts = { ...options, arguments: args.concat(options.arguments || []) };
+    return {
+        *[Symbol.iterator]() {
+            return yield* createProcess(cmd, opts);
+        },
+        *join() {
+            const process = yield* createProcess(cmd, opts);
+            let stdout = "";
+            let stderr = "";
+            yield* spawn(function* () {
+                let subscription = yield* process.stdout;
+                let next = yield* subscription.next();
+                while (!next.done) {
+                    stdout += next.value;
+                    next = yield* subscription.next();
+                }
+            });
+            yield* spawn(function* () {
+                let subscription = yield* process.stderr;
+                let next = yield* subscription.next();
+                while (!next.done) {
+                    stderr += next.value;
+                    next = yield* subscription.next();
+                }
+            });
+            let status = yield* process.join();
+            return { ...status, stdout, stderr };
+        },
+        *expect() {
+            const process = yield* createProcess(cmd, opts);
+            let stdout = "";
+            let stderr = "";
+            yield* spawn(function* () {
+                let subscription = yield* process.stdout;
+                let next = yield* subscription.next();
+                while (!next.done) {
+                    stdout += next.value;
+                    next = yield* subscription.next();
+                }
+            });
+            yield* spawn(function* () {
+                let subscription = yield* process.stderr;
+                let next = yield* subscription.next();
+                while (!next.done) {
+                    stderr += next.value;
+                    next = yield* subscription.next();
+                }
+            });
+            let status = yield* process.expect();
+            return { ...status, stdout, stderr };
+        },
+    };
+}

package/esm/src/helpers.d.ts

@@ -0,0 +1,12 @@
+import { type Operation, type Result, type Stream } from "effection";
+import type { Readable } from "node:stream";
+export type OutputStream = Stream<Uint8Array, void>;
+export declare function useReadable(target: Readable | null): Stream<Uint8Array, void>;
+interface Remainder<T> {
+    remainder: string;
+    result: T;
+}
+export declare function lines(): <T extends Uint8Array, TReturn>(stream: Stream<T, TReturn>) => Stream<string, Remainder<TReturn>>;
+export declare function box<T>(op: () => Operation<T>): Operation<Result<T>>;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/esm/src/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EAEd,KAAK,MAAM,EACX,KAAK,MAAM,EACZ,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;AAEpD,wBAAgB,WAAW,CACzB,MAAM,EAAE,QAAQ,GAAG,IAAI,GACtB,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAoB1B;AAED,UAAU,SAAS,CAAC,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,CAAC,CAAC;CACX;AAED,wBAAgB,KAAK,IAAI,CAAC,CAAC,SAAS,UAAU,EAAE,OAAO,EACrD,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,KACvB,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAyCtC;AAED,wBAAiB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAOpE"}

package/esm/src/helpers.js

@@ -0,0 +1,71 @@
+import { createSignal, Err, Ok, resource, } from "effection";
+export function useReadable(target) {
+    return resource(function* (provide) {
+        let signal = createSignal();
+        let listener = (chunk) => {
+            signal.send(chunk);
+        };
+        target?.on("data", listener);
+        target?.on("end", signal.close);
+        try {
+            yield* provide(yield* signal);
+        }
+        finally {
+            target?.off("data", listener);
+            target?.off("end", signal.close);
+            signal.close();
+        }
+    });
+}
+export function lines() {
+    const decoder = new TextDecoder();
+    return function (stream) {
+        return {
+            *[Symbol.iterator]() {
+                let subscription = yield* stream;
+                let buffer = [];
+                let remainder = "";
+                return {
+                    *next() {
+                        while (buffer.length === 0) {
+                            let next = yield* subscription.next();
+                            if (next.done) {
+                                return {
+                                    done: true,
+                                    value: {
+                                        remainder,
+                                        result: next.value,
+                                    },
+                                };
+                            }
+                            else {
+                                let current = remainder + decoder.decode(next.value);
+                                let lines = current.split("\n");
+                                if (lines.length > 0) {
+                                    buffer.push(...lines.slice(0, -1));
+                                    remainder = lines.slice(-1)[0];
+                                }
+                                else {
+                                    remainder = current;
+                                }
+                            }
+                        }
+                        return {
+                            done: false,
+                            value: buffer.pop(),
+                        };
+                    },
+                };
+            },
+        };
+    };
+}
+export function* box(op) {
+    try {
+        let value = yield* op();
+        return Ok(value);
+    }
+    catch (e) {
+        return Err(e);
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@effectionx/process",
+  "version": "0.5.0",
+  "author": "engineering@frontside.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thefrontside/effectionx.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thefrontside/effectionx/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">= 16"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@types/cross-spawn": "6.0.6",
+    "cross-spawn": "7.0.6",
+    "ctrlc-windows": "2.2.0",
+    "effection": "^3",
+    "shellwords": "^1.1.1"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/mod.d.ts

@@ -0,0 +1,3 @@
+export * from "./src/exec.js";
+export { type Daemon, daemon } from "./src/daemon.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC"}

package/script/mod.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemon = void 0;
+__exportStar(require("./src/exec.js"), exports);
+var daemon_js_1 = require("./src/daemon.js");
+Object.defineProperty(exports, "daemon", { enumerable: true, get: function () { return daemon_js_1.daemon; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/src/daemon.d.ts

@@ -0,0 +1,11 @@
+import { type Operation } from "effection";
+import { type ExecOptions, type Process } from "./exec.js";
+export interface Daemon extends Operation<void>, Process {
+}
+/**
+ * Start a long-running process, like a web server that run perpetually.
+ * Daemon operations are expected to run forever, and if they exit pre-maturely
+ * before the operation containing them passes out of scope it raises an error.
+ */
+export declare function daemon(command: string, options?: ExecOptions): Operation<Daemon>;
+//# sourceMappingURL=daemon.d.ts.map

package/script/src/daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/src/daemon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAY,MAAM,WAAW,CAAC;AAErD,OAAO,EAGL,KAAK,WAAW,EAEhB,KAAK,OAAO,EACb,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,MAAO,SAAQ,SAAS,CAAC,IAAI,CAAC,EAAE,OAAO;CACvD;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CACpB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,WAAgB,GACxB,SAAS,CAAC,MAAM,CAAC,CAanB"}

package/script/src/daemon.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemon = daemon;
+const effection_1 = require("effection");
+const exec_js_1 = require("./exec.js");
+/**
+ * Start a long-running process, like a web server that run perpetually.
+ * Daemon operations are expected to run forever, and if they exit pre-maturely
+ * before the operation containing them passes out of scope it raises an error.
+ */
+function daemon(command, options = {}) {
+    return (0, effection_1.resource)(function* (provide) {
+        // TODO: should we be able to terminate the process from here?
+        let process = yield* (0, exec_js_1.exec)(command, options);
+        yield* provide({
+            *[Symbol.iterator]() {
+                let status = yield* process.join();
+                throw new exec_js_1.DaemonExitError(status, command, options);
+            },
+            ...process,
+        });
+    });
+}

package/script/src/eventemitter.d.ts

@@ -0,0 +1,22 @@
+import type { Operation, Stream } from "effection";
+import type { EventEmitter } from "node:stream";
+/**
+ * Create a {@link Stream} of events from any EventEmitter.
+ *
+ * See the guide on [Streams and Subscriptions](https://frontside.com/effection/docs/collections)
+ * for details on how to use streams.
+ *
+ * @param target - the event target whose events will be streamed
+ * @param name - the name of the event to stream. E.g. "click"
+ * @returns a stream that will see one item for each event
+ */
+export declare function on<T extends unknown[]>(target: EventEmitter | null, eventName: string): Stream<T, never>;
+/**
+ * Create an {@link Operation} that yields the next event to be emitted by an EventEmitter.
+ *
+ * @param target - the event target to be watched
+ * @param name - the name of the event to watch. E.g. "click"
+ * @returns an Operation that yields the next emitted event
+ */
+export declare function once<TArgs extends unknown[] = unknown[]>(source: EventEmitter | null, eventName: string): Operation<TArgs>;
+//# sourceMappingURL=eventemitter.d.ts.map

package/script/src/eventemitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventemitter.d.ts","sourceRoot":"","sources":["../../src/src/eventemitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAgB,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,EAAE,CAChB,CAAC,SAAS,OAAO,EAAE,EACnB,MAAM,EAAE,YAAY,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAkBlE;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,KAAK,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,EACtD,MAAM,EAAE,YAAY,GAAG,IAAI,EAC3B,SAAS,EAAE,MAAM,GAChB,SAAS,CAAC,KAAK,CAAC,CAWlB"}

package/script/src/eventemitter.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.on = on;
+exports.once = once;
+const effection_1 = require("effection");
+/**
+ * Create a {@link Stream} of events from any EventEmitter.
+ *
+ * See the guide on [Streams and Subscriptions](https://frontside.com/effection/docs/collections)
+ * for details on how to use streams.
+ *
+ * @param target - the event target whose events will be streamed
+ * @param name - the name of the event to stream. E.g. "click"
+ * @returns a stream that will see one item for each event
+ */
+function on(target, eventName) {
+    return (0, effection_1.resource)(function* (provide) {
+        let signal = (0, effection_1.createSignal)();
+        let listener = (...args) => signal.send(args);
+        target?.on(eventName, listener);
+        try {
+            yield* provide(yield* signal);
+        }
+        finally {
+            target?.off(eventName, listener);
+        }
+    });
+}
+/**
+ * Create an {@link Operation} that yields the next event to be emitted by an EventEmitter.
+ *
+ * @param target - the event target to be watched
+ * @param name - the name of the event to watch. E.g. "click"
+ * @returns an Operation that yields the next emitted event
+ */
+function once(source, eventName) {
+    const result = (0, effection_1.withResolvers)();
+    let listener = (...args) => {
+        result.resolve(args);
+        source?.off(eventName, listener);
+    };
+    source?.on(eventName, listener);
+    return result.operation;
+}

package/script/src/exec/api.d.ts

@@ -0,0 +1,70 @@
+import type { Operation } from "effection";
+import type { OutputStream } from "../helpers.js";
+export interface Writable<T> {
+    send(message: T): void;
+}
+/**
+ * The process type is what is returned by the `exec` operation. It has all of
+ * standard io handles, and methods for synchronizing on return.
+ */
+export interface Process extends StdIO {
+    readonly pid: number;
+    /**
+     * Completes once the process has finished regardless of whether it was
+     * successful or not.
+     */
+    join(): Operation<ExitStatus>;
+    /**
+     * Completes once the process has finished successfully. If the process does
+     * not complete successfully, it will raise an ExecError.
+     */
+    expect(): Operation<ExitStatus>;
+}
+export interface ExecOptions {
+    /**
+     * When not using passing the `shell` option all arguments must be passed
+     * as an array.
+     */
+    arguments?: string[];
+    /**
+     * Map of environment variables to use for the process.
+     */
+    env?: Record<string, string>;
+    /**
+     * Create an intermediate shell process; defaults to `false`. Useful if you
+     * need to handle glob expansion or passing environment variables. A truthy value
+     * will use an intermediate shell to interpret the command using the default system shell.
+     * However, if the value is a string, that will be used as the executable path
+     * for the intermediate shell.
+     */
+    shell?: boolean | string;
+    /**
+     * Sets the working directory of the process
+     */
+    cwd?: string;
+}
+export interface StdIO {
+    stdout: OutputStream;
+    stderr: OutputStream;
+    stdin: Writable<string>;
+}
+export interface ExitStatus {
+    /**
+     * exit code
+     * //TODO: is this pertinent on Windows? Do we need an 'OK' flag
+     */
+    code?: number;
+    /**
+     * If the process exited with a signal instead of an exit code, it
+     * is recorded here.
+     */
+    signal?: string;
+}
+export interface ProcessResult extends ExitStatus {
+    stdout: string;
+    stderr: string;
+}
+export interface CreateOSProcess {
+    (command: string, options: ExecOptions): Operation<Process>;
+}
+//# sourceMappingURL=api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/src/exec/api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,OAAQ,SAAQ,KAAK;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,IAAI,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC;IAE9B;;;OAGG;IACH,MAAM,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IAErB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAEzB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AACD,MAAM,WAAW,eAAe;IAC9B,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;CAC7D"}

package/script/src/exec/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/src/exec/error.d.ts

@@ -0,0 +1,14 @@
+import type { ExecOptions, ExitStatus } from "./api.js";
+export declare class ExecError extends Error {
+    status: ExitStatus;
+    command: string;
+    options: ExecOptions;
+    constructor(status: ExitStatus, command: string, options: ExecOptions);
+    name: string;
+    get message(): string;
+}
+export declare class DaemonExitError extends ExecError {
+    name: string;
+    get message(): string;
+}
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/src/exec/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAExD,qBAAa,SAAU,SAAQ,KAAK;IAEzB,MAAM,EAAE,UAAU;IAClB,OAAO,EAAE,MAAM;IACf,OAAO,EAAE,WAAW;gBAFpB,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW;IAKpB,IAAI,SAAe;IAE5B,IAAa,OAAO,IAAI,MAAM,CAgB7B;CACF;AAED,qBAAa,eAAgB,SAAQ,SAAS;IACnC,IAAI,SAAqB;IAElC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/script/src/exec/error.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonExitError = exports.ExecError = void 0;
+class ExecError extends Error {
+    constructor(status, command, options) {
+        super();
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: status
+        });
+        Object.defineProperty(this, "command", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: command
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ExecError"
+        });
+    }
+    get message() {
+        let code = this.status.code ? `code: ${this.status.code}` : null;
+        let signal = this.status.signal ? `signal: ${this.status.signal}` : null;
+        let env = `env: ${JSON.stringify(this.options.env || {})}`;
+        let shell = this.options.shell ? `shell: ${this.options.shell}` : null;
+        let cwd = this.options.cwd ? `cwd: ${this.options.cwd}` : null;
+        let command = `$ ${this.command} ${this.options.arguments?.join(" ")}`
+            .trim();
+        return [code, signal, env, shell, cwd, command].filter((item) => !!item)
+            .join("\n");
+    }
+}
+exports.ExecError = ExecError;
+class DaemonExitError extends ExecError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DaemonExitError"
+        });
+    }
+    get message() {
+        return `daemon process quit unexpectedly\n${super.message}`;
+    }
+}
+exports.DaemonExitError = DaemonExitError;

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

@@ -0,0 +1,3 @@
+import type { CreateOSProcess } from "./api.js";
+export declare const createPosixProcess: CreateOSProcess;
+//# sourceMappingURL=posix.d.ts.map

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

@@ -0,0 +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"}

package/script/src/exec/posix.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPosixProcess = void 0;
+const node_child_process_1 = require("node:child_process");
+const effection_1 = require("effection");
+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();
+        }
+        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() {
+        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));
+        }
+        finally {
+            try {
+                if (typeof childProcess.pid === "undefined") {
+                    // deno-lint-ignore no-unsafe-finally
+                    throw new Error("no pid for childProcess");
+                }
+                node_process_1.default.kill(-childProcess.pid, "SIGTERM");
+                yield* (0, effection_1.all)([io.stdoutDone.operation, io.stderrDone.operation]);
+            }
+            catch (_e) {
+                // do nothing, process is probably already dead
+            }
+        }
+    });
+    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

@@ -0,0 +1,4 @@
+import type { CreateOSProcess } from "./api.js";
+export declare const createWin32Process: CreateOSProcess;
+export declare const isWin32: () => boolean;
+//# sourceMappingURL=win32.d.ts.map

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

@@ -0,0 +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"}