@effectionx/process 0.5.0

package/script/src/exec/win32.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWin32 = exports.createWin32Process = void 0;
+const node_os_1 = require("node:os");
+const effection_1 = require("effection");
+// @ts-types="npm:@types/cross-spawn@6.0.6"
+const cross_spawn_1 = require("cross-spawn");
+const ctrlc_windows_1 = require("ctrlc-windows");
+const eventemitter_js_1 = require("../eventemitter.js");
+const helpers_js_1 = require("../helpers.js");
+const error_js_1 = require("./error.js");
+function* killTree(pid) {
+    try {
+        const killer = (0, cross_spawn_1.spawn)("cmd.exe", ["/c", "taskkill", "/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+        yield* (0, eventemitter_js_1.once)(killer, "close");
+    }
+    catch (_) {
+        // 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 {
+            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 {
+                // Only try to kill the process if it hasn't exited yet
+                if (childProcess.exitCode === null &&
+                    childProcess.signalCode === null) {
+                    if (typeof childProcess.pid === "undefined") {
+                        // deno-lint-ignore no-unsafe-finally
+                        throw new Error("no pid for childProcess");
+                    }
+                    let stdinStream = childProcess.stdin;
+                    // Try graceful shutdown with ctrlc
+                    try {
+                        (0, ctrlc_windows_1.ctrlc)(childProcess.pid);
+                        if (stdinStream.writable) {
+                            try {
+                                // Terminate batch process (Y/N)
+                                stdinStream.write("Y\n");
+                            }
+                            catch (_err) {
+                                // not much we can do here
+                            }
+                        }
+                    }
+                    catch (_err) {
+                        // ctrlc might fail
+                    }
+                    // Close stdin to allow process to exit cleanly
+                    try {
+                        stdinStream.end();
+                    }
+                    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) {
+                        // Try regular kill first
+                        try {
+                            childProcess.kill();
+                        }
+                        catch (_err) {
+                            // process might already be dead
+                        }
+                        // If still alive after kill, force-kill entire process tree
+                        // This is necessary for bash on Windows where ctrlc doesn't work
+                        // and child.kill() only kills the shell, leaving grandchildren alive
+                        if (childProcess.exitCode === null &&
+                            childProcess.signalCode === null) {
+                            yield* killTree(childProcess.pid);
+                        }
+                    }
+                    // Wait for streams to finish
+                    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.createWin32Process = createWin32Process;
+const isWin32 = () => (0, node_os_1.platform)() === "win32";
+exports.isWin32 = isWin32;

package/script/src/exec.d.ts

@@ -0,0 +1,16 @@
+import { type Operation } from "effection";
+import type { ExecOptions, Process, ProcessResult } from "./exec/api.js";
+export * from "./exec/api.js";
+export * from "./exec/error.js";
+export interface Exec extends Operation<Process> {
+    join(): Operation<ProcessResult>;
+    expect(): Operation<ProcessResult>;
+}
+/**
+ * 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 declare function exec(command: string, options?: ExecOptions): Exec;
+//# sourceMappingURL=exec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/src/exec.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAS,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAEV,WAAW,EAEX,OAAO,EACP,aAAa,EACd,MAAM,eAAe,CAAC;AAIvB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAEhC,MAAM,WAAW,IAAK,SAAQ,SAAS,CAAC,OAAO,CAAC;IAC9C,IAAI,IAAI,SAAS,CAAC,aAAa,CAAC,CAAC;IACjC,MAAM,IAAI,SAAS,CAAC,aAAa,CAAC,CAAC;CACpC;AAUD;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI,CAiErE"}

package/script/src/exec.js

@@ -0,0 +1,92 @@
+"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.exec = exec;
+const shellwords_1 = require("shellwords");
+const effection_1 = require("effection");
+const posix_js_1 = require("./exec/posix.js");
+const win32_js_1 = require("./exec/win32.js");
+__exportStar(require("./exec/api.js"), exports);
+__exportStar(require("./exec/error.js"), exports);
+const createProcess = (cmd, opts) => {
+    if ((0, win32_js_1.isWin32)()) {
+        return (0, win32_js_1.createWin32Process)(cmd, opts);
+    }
+    else {
+        return (0, posix_js_1.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()`
+ */
+function exec(command, options = {}) {
+    let [cmd, ...args] = options.shell ? [command] : (0, shellwords_1.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* (0, effection_1.spawn)(function* () {
+                let subscription = yield* process.stdout;
+                let next = yield* subscription.next();
+                while (!next.done) {
+                    stdout += next.value;
+                    next = yield* subscription.next();
+                }
+            });
+            yield* (0, effection_1.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* (0, effection_1.spawn)(function* () {
+                let subscription = yield* process.stdout;
+                let next = yield* subscription.next();
+                while (!next.done) {
+                    stdout += next.value;
+                    next = yield* subscription.next();
+                }
+            });
+            yield* (0, effection_1.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/script/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/script/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/script/src/helpers.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReadable = useReadable;
+exports.lines = lines;
+exports.box = box;
+const effection_1 = require("effection");
+function useReadable(target) {
+    return (0, effection_1.resource)(function* (provide) {
+        let signal = (0, effection_1.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();
+        }
+    });
+}
+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(),
+                        };
+                    },
+                };
+            },
+        };
+    };
+}
+function* box(op) {
+    try {
+        let value = yield* op();
+        return (0, effection_1.Ok)(value);
+    }
+    catch (e) {
+        return (0, effection_1.Err)(e);
+    }
+}