@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-OXNGN5H7.js

@@ -0,0 +1,81 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeSink.js
+var NodeSink_exports = {};
+__export(NodeSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Sink from "effect/Sink";
+var fromWritable = (options) => Sink.fromChannel(Channel.mapDone(fromWritableChannel(options), (_) => [_]));
+var fromWritableChannel = (options) => Channel.fromTransform((pull) => {
+  const writable = options.evaluate();
+  return Effect.succeed(pullIntoWritable({
+    ...options,
+    writable,
+    pull
+  }));
+});
+var pullIntoWritable = (options) => options.pull.pipe(Effect.flatMap((chunk) => {
+  let i = 0;
+  return Effect.callback((resume) => {
+    let cancelled = false;
+    const loop = () => {
+      for (; i < chunk.length; ) {
+        if (cancelled) {
+          return;
+        }
+        const success = options.writable.write(chunk[i++], options.encoding);
+        if (!success) {
+          if (!cancelled) {
+            options.writable.once("drain", loop);
+          }
+          return;
+        }
+      }
+      if (!cancelled) {
+        resume(Effect.void);
+      }
+    };
+    loop();
+    return Effect.sync(() => {
+      cancelled = true;
+      options.writable.off("drain", loop);
+    });
+  });
+}), Effect.forever({
+  disableYield: true
+}), options.endOnDone !== false ? Pull.catchDone((_) => {
+  if ("closed" in options.writable && options.writable.closed) {
+    return Cause.done(_);
+  }
+  return Effect.callback((resume) => {
+    const onFinish = () => resume(Cause.done(_));
+    options.writable.once("finish", onFinish);
+    options.writable.end();
+    return Effect.sync(() => {
+      options.writable.off("finish", onFinish);
+    });
+  });
+}) : identity, Effect.raceFirst(Effect.callback((resume) => {
+  const onError = (error) => resume(Effect.fail(options.onError(error)));
+  options.writable.once("error", onError);
+  return Effect.sync(() => {
+    options.writable.off("error", onError);
+  });
+})));
+
+export {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable,
+  NodeSink_exports
+};

package/dist/vendor/chunk-QPLDT6A6.js

@@ -0,0 +1,564 @@
+import {
+  buildSpawnOptions
+} from "./chunk-EGBNVEEW.js";
+import {
+  handleErrnoException
+} from "./chunk-42QKY6T6.js";
+import {
+  fromReadable
+} from "./chunk-XH4U3JSV.js";
+import {
+  fromWritable
+} from "./chunk-OXNGN5H7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
+var NodeChildProcessSpawner_exports = {};
+__export(NodeChildProcessSpawner_exports, {
+  flattenCommand: () => flattenCommand,
+  layer: () => layer
+});
+import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Predicate from "effect/Predicate";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import { ChildProcessSpawner, ExitCode, make as makeSpawner, makeHandle, ProcessId } from "effect/unstable/process/ChildProcessSpawner";
+import * as NodeChildProcess from "node:child_process";
+import { PassThrough } from "node:stream";
+var toError = (error) => error instanceof globalThis.Error ? error : new globalThis.Error(String(error));
+var toPlatformError = (method, error, command) => {
+  const {
+    commands
+  } = flattenCommand(command);
+  const commandStr = commands.reduce((acc, curr) => {
+    const cmd = `${curr.command} ${curr.args.join(" ")}`;
+    return acc.length === 0 ? cmd : `${acc} | ${cmd}`;
+  }, "");
+  return handleErrnoException("ChildProcess", method)(error, [commandStr]);
+};
+var processGroupGraceMillis = 1e3;
+var processGroupPollIntervalMillis = 10;
+var isProcessAlive = (childProcess, exitSignal) => {
+  if (!Deferred.isDoneUnsafe(exitSignal)) {
+    return true;
+  }
+  if (globalThis.process.platform === "win32") {
+    return false;
+  }
+  try {
+    globalThis.process.kill(-childProcess.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var taskkill = (childProcess, onExit = () => {
+}) => NodeChildProcess.execFile("taskkill", ["/pid", String(childProcess.pid), "/T", "/F"], {
+  windowsHide: true
+}, onExit);
+var make2 = /* @__PURE__ */ Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const resolveWorkingDirectory = Effect.fnUntraced(function* (options) {
+    if (Predicate.isUndefined(options.cwd)) return void 0;
+    yield* fs.access(options.cwd);
+    return path.resolve(options.cwd);
+  });
+  const resolveEnvironment = (options) => {
+    return options.extendEnv ? {
+      ...globalThis.process.env,
+      ...options.env
+    } : options.env;
+  };
+  const inputToStdioOption = (input) => Stream.isStream(input) ? "pipe" : input;
+  const outputToStdioOption = (input) => Sink.isSink(input) ? "pipe" : input;
+  const resolveStdinOption = (options) => {
+    const defaultConfig = {
+      stream: "pipe",
+      encoding: "utf-8",
+      endOnDone: true
+    };
+    if (Predicate.isUndefined(options.stdin)) {
+      return defaultConfig;
+    }
+    if (typeof options.stdin === "string") {
+      return {
+        ...defaultConfig,
+        stream: options.stdin
+      };
+    }
+    if (Stream.isStream(options.stdin)) {
+      return {
+        ...defaultConfig,
+        stream: options.stdin
+      };
+    }
+    return {
+      stream: options.stdin.stream,
+      encoding: options.stdin.encoding ?? defaultConfig.encoding,
+      endOnDone: options.stdin.endOnDone ?? defaultConfig.endOnDone
+    };
+  };
+  const resolveOutputOption = (options, streamName) => {
+    const option = options[streamName];
+    if (Predicate.isUndefined(option)) {
+      return {
+        stream: "pipe"
+      };
+    }
+    if (typeof option === "string") {
+      return {
+        stream: option
+      };
+    }
+    if (Sink.isSink(option)) {
+      return {
+        stream: option
+      };
+    }
+    return {
+      stream: option.stream
+    };
+  };
+  const resolveAdditionalFds = (options) => {
+    if (Predicate.isUndefined(options.additionalFds)) {
+      return [];
+    }
+    const result = [];
+    for (const [name, config] of Object.entries(options.additionalFds)) {
+      const fd = ChildProcess.parseFdName(name);
+      if (Predicate.isNotUndefined(fd)) {
+        result.push({
+          fd,
+          config
+        });
+      }
+    }
+    return result.sort((a, b) => a.fd - b.fd);
+  };
+  const buildStdioArray = (stdinConfig, stdoutConfig, stderrConfig, additionalFds) => {
+    const stdio = [inputToStdioOption(stdinConfig.stream), outputToStdioOption(stdoutConfig.stream), outputToStdioOption(stderrConfig.stream)];
+    if (additionalFds.length === 0) {
+      return stdio;
+    }
+    const maxFd = additionalFds.reduce((max, {
+      fd
+    }) => Math.max(max, fd), 2);
+    for (let i = 3; i <= maxFd; i++) {
+      stdio[i] = "ignore";
+    }
+    for (const {
+      fd
+    } of additionalFds) {
+      stdio[fd] = "pipe";
+    }
+    return stdio;
+  };
+  const setupAdditionalFds = Effect.fnUntraced(function* (command, childProcess, additionalFds) {
+    if (additionalFds.length === 0) {
+      return {
+        getInputFd: () => Sink.drain,
+        getOutputFd: () => Stream.empty
+      };
+    }
+    const inputSinks = /* @__PURE__ */ new Map();
+    const outputStreams = /* @__PURE__ */ new Map();
+    for (const {
+      config,
+      fd
+    } of additionalFds) {
+      const nodeStream = childProcess.stdio[fd];
+      switch (config.type) {
+        case "input": {
+          let sink = Sink.drain;
+          if (nodeStream && "write" in nodeStream) {
+            sink = fromWritable({
+              evaluate: () => nodeStream,
+              onError: (error) => toPlatformError(`fromWritable(fd${fd})`, toError(error), command)
+            });
+          }
+          if (config.stream) {
+            yield* Effect.forkScoped(Stream.run(config.stream, sink));
+          }
+          inputSinks.set(fd, sink);
+          break;
+        }
+        case "output": {
+          let stream = Stream.empty;
+          if (nodeStream && "read" in nodeStream) {
+            const passThrough = new PassThrough();
+            nodeStream.on("error", (error) => passThrough.destroy(error));
+            nodeStream.pipe(passThrough);
+            stream = fromReadable({
+              evaluate: () => passThrough,
+              onError: (error) => toPlatformError(`fromReadable(fd${fd})`, toError(error), command)
+            });
+          }
+          if (config.sink) {
+            stream = Stream.transduce(stream, config.sink);
+          }
+          outputStreams.set(fd, stream);
+          break;
+        }
+      }
+    }
+    return {
+      getInputFd: (fd) => inputSinks.get(fd) ?? Sink.drain,
+      getOutputFd: (fd) => outputStreams.get(fd) ?? Stream.empty
+    };
+  });
+  const setupChildStdin = (command, childProcess, config) => Effect.suspend(() => {
+    let sink = Sink.drain;
+    if (Predicate.isNotNull(childProcess.stdin)) {
+      sink = fromWritable({
+        evaluate: () => childProcess.stdin,
+        onError: (error) => toPlatformError("fromWritable(stdin)", toError(error), command),
+        endOnDone: config.endOnDone,
+        encoding: config.encoding
+      });
+    }
+    if (Stream.isStream(config.stream)) {
+      return Effect.as(Effect.forkScoped(Stream.run(config.stream, sink)), sink);
+    }
+    return Effect.succeed(sink);
+  });
+  const setupChildOutputStreams = (command, childProcess, stdoutConfig, stderrConfig) => {
+    let stdout = childProcess.stdout ? (() => {
+      const passThrough = new PassThrough();
+      childProcess.stdout.on("error", (error) => passThrough.destroy(error));
+      childProcess.stdout.pipe(passThrough);
+      return fromReadable({
+        evaluate: () => passThrough,
+        onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
+      });
+    })() : Stream.empty;
+    let stderr = childProcess.stderr ? (() => {
+      const passThrough = new PassThrough();
+      childProcess.stderr.on("error", (error) => passThrough.destroy(error));
+      childProcess.stderr.pipe(passThrough);
+      return fromReadable({
+        evaluate: () => passThrough,
+        onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
+      });
+    })() : Stream.empty;
+    if (Sink.isSink(stdoutConfig.stream)) {
+      stdout = Stream.transduce(stdout, stdoutConfig.stream);
+    }
+    if (Sink.isSink(stderrConfig.stream)) {
+      stderr = Stream.transduce(stderr, stderrConfig.stream);
+    }
+    const all = Stream.merge(stdout, stderr);
+    return {
+      stdout,
+      stderr,
+      all
+    };
+  };
+  const spawn2 = (command, spawnOptions) => Effect.callback((resume) => {
+    const deferred = Deferred.makeUnsafe();
+    const handle = NodeChildProcess.spawn(command.command, command.args, spawnOptions);
+    handle.on("error", (error) => {
+      resume(Effect.fail(toPlatformError("spawn", error, command)));
+    });
+    handle.on("exit", (...args) => {
+      Deferred.doneUnsafe(deferred, Exit.succeed(args));
+    });
+    handle.on("spawn", () => {
+      resume(Effect.succeed([handle, deferred]));
+    });
+    return Effect.sync(() => {
+      handle.kill("SIGTERM");
+    });
+  });
+  const killProcessGroup = (command, childProcess, signal) => {
+    if (globalThis.process.platform === "win32") {
+      return Effect.callback((resume) => {
+        taskkill(childProcess, (error) => {
+          if (error) {
+            resume(Effect.fail(toPlatformError("kill", toError(error), command)));
+          } else {
+            resume(Effect.void);
+          }
+        });
+      });
+    }
+    return Effect.try({
+      try: () => {
+        globalThis.process.kill(-childProcess.pid, signal);
+      },
+      catch: (error) => toPlatformError("kill", toError(error), command)
+    });
+  };
+  const killProcessGroupOnExit = (childProcess, signal) => {
+    if (globalThis.process.platform === "win32") {
+      taskkill(childProcess);
+      return;
+    }
+    try {
+      globalThis.process.kill(-childProcess.pid, signal);
+    } catch {
+    }
+  };
+  const killProcess = (command, childProcess, signal) => Effect.suspend(() => {
+    const killed = childProcess.kill(signal);
+    if (!killed) {
+      const error = new globalThis.Error("Failed to kill child process");
+      return Effect.fail(toPlatformError("kill", error, command));
+    }
+    return Effect.void;
+  });
+  const awaitProcessExit = (childProcess, exitSignal, timeoutMillis) => Effect.callback((resume) => {
+    const deadline = Date.now() + timeoutMillis;
+    let timer;
+    const stop = () => {
+      clearTimeout(timer);
+      childProcess.removeListener("exit", poll);
+    };
+    const poll = () => {
+      clearTimeout(timer);
+      if (Date.now() >= deadline || !isProcessAlive(childProcess, exitSignal)) {
+        stop();
+        resume(Effect.void);
+        return;
+      }
+      timer = setTimeout(poll, processGroupPollIntervalMillis);
+    };
+    childProcess.on("exit", poll);
+    poll();
+    return Effect.sync(stop);
+  });
+  const terminateProcessGroup = Effect.fnUntraced(function* (command, childProcess, exitSignal, options) {
+    const signalGroup = (signal) => killProcessGroup(command, childProcess, signal).pipe(Effect.catch(() => killProcess(command, childProcess, signal)));
+    yield* signalGroup(options?.killSignal ?? "SIGTERM");
+    if (Predicate.isUndefined(options?.forceKillAfter)) {
+      yield* awaitProcessExit(childProcess, exitSignal, processGroupGraceMillis);
+    } else {
+      yield* awaitProcessExit(childProcess, exitSignal, Duration.toMillis(options.forceKillAfter));
+      if (isProcessAlive(childProcess, exitSignal)) {
+        yield* signalGroup("SIGKILL");
+        yield* awaitProcessExit(childProcess, exitSignal, processGroupGraceMillis);
+      }
+    }
+    yield* Deferred.await(exitSignal);
+  });
+  const getSourceStream = (handle, from) => {
+    const fromOption = from ?? "stdout";
+    switch (fromOption) {
+      case "stdout":
+        return handle.stdout;
+      case "stderr":
+        return handle.stderr;
+      case "all":
+        return handle.all;
+      default: {
+        const fd = ChildProcess.parseFdName(fromOption);
+        if (Predicate.isNotUndefined(fd)) {
+          return handle.getOutputFd(fd);
+        }
+        return handle.stdout;
+      }
+    }
+  };
+  const spawnCommand = Effect.fnUntraced(function* (cmd) {
+    switch (cmd._tag) {
+      case "StandardCommand": {
+        const stdinConfig = resolveStdinOption(cmd.options);
+        const stdoutConfig = resolveOutputOption(cmd.options, "stdout");
+        const stderrConfig = resolveOutputOption(cmd.options, "stderr");
+        const resolvedAdditionalFds = resolveAdditionalFds(cmd.options);
+        let isReferenced = true;
+        const cwd = yield* resolveWorkingDirectory(cmd.options);
+        const env = resolveEnvironment(cmd.options);
+        const stdio = buildStdioArray(stdinConfig, stdoutConfig, stderrConfig, resolvedAdditionalFds);
+        const [childProcess, exitSignal] = yield* Effect.acquireRelease(spawn2(cmd, buildSpawnOptions(cmd.options, {
+          cwd,
+          env,
+          stdio
+        }, process.platform)), Effect.fnUntraced(function* ([childProcess2, exitSignal2]) {
+          const exited = yield* Deferred.isDone(exitSignal2);
+          if (exited) {
+            const [code] = yield* Deferred.await(exitSignal2);
+            if (code !== 0 && Predicate.isNotNull(code)) {
+              yield* Effect.ignore(killProcessGroup(cmd, childProcess2, cmd.options.killSignal ?? "SIGTERM"));
+            }
+            return;
+          }
+          if (!isReferenced) {
+            return;
+          }
+          yield* Effect.ignore(terminateProcessGroup(cmd, childProcess2, exitSignal2, cmd.options));
+        }));
+        const pid = ProcessId(childProcess.pid);
+        childProcess.on("exit", (code) => {
+          if (code !== 0 && Predicate.isNotNull(code)) {
+            killProcessGroupOnExit(childProcess, cmd.options.killSignal ?? "SIGTERM");
+          }
+        });
+        const reref = Effect.sync(() => {
+          if (!isReferenced) {
+            childProcess.ref();
+            isReferenced = true;
+          }
+        });
+        const unref = Effect.sync(() => {
+          if (isReferenced) {
+            childProcess.unref();
+            isReferenced = false;
+          }
+          return reref;
+        });
+        const stdin = yield* setupChildStdin(cmd, childProcess, stdinConfig);
+        const {
+          all,
+          stderr,
+          stdout
+        } = setupChildOutputStreams(cmd, childProcess, stdoutConfig, stderrConfig);
+        const {
+          getInputFd,
+          getOutputFd
+        } = yield* setupAdditionalFds(cmd, childProcess, resolvedAdditionalFds);
+        const isRunning = Effect.map(Deferred.isDone(exitSignal), (done) => !done);
+        const exitCode = Effect.flatMap(Deferred.await(exitSignal), ([code, signal]) => {
+          if (Predicate.isNotNull(code)) {
+            return Effect.succeed(ExitCode(code));
+          }
+          const error = new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`);
+          return Effect.fail(toPlatformError("exitCode", error, cmd));
+        });
+        const kill = (options) => terminateProcessGroup(cmd, childProcess, exitSignal, options);
+        return makeHandle({
+          pid,
+          exitCode,
+          isRunning,
+          kill,
+          stdin,
+          stdout,
+          stderr,
+          all,
+          getInputFd,
+          getOutputFd,
+          unref
+        });
+      }
+      case "PipedCommand": {
+        const {
+          commands,
+          pipeOptions
+        } = flattenCommand(cmd);
+        const [root, ...pipeline] = commands;
+        const handles = [yield* spawnCommand(root)];
+        for (let i = 0; i < pipeline.length; i++) {
+          const command = pipeline[i];
+          const options = pipeOptions[i] ?? {};
+          const stdinConfig = resolveStdinOption(command.options);
+          const sourceStream = Stream.unwrap(Effect.succeed(getSourceStream(handles[handles.length - 1], options.from)));
+          const toOption = options.to ?? "stdin";
+          if (toOption === "stdin") {
+            handles.push(yield* spawnCommand(ChildProcess.make(command.command, command.args, {
+              ...command.options,
+              stdin: {
+                ...stdinConfig,
+                stream: sourceStream
+              }
+            })));
+          } else {
+            const fd = ChildProcess.parseFdName(toOption);
+            if (Predicate.isNotUndefined(fd)) {
+              const fdName2 = ChildProcess.fdName(fd);
+              const existingFds = command.options.additionalFds ?? {};
+              handles.push(yield* spawnCommand(ChildProcess.make(command.command, command.args, {
+                ...command.options,
+                additionalFds: {
+                  ...existingFds,
+                  [fdName2]: {
+                    type: "input",
+                    stream: sourceStream
+                  }
+                }
+              })));
+            } else {
+              handles.push(yield* spawnCommand(ChildProcess.make(command.command, command.args, {
+                ...command.options,
+                stdin: {
+                  ...stdinConfig,
+                  stream: sourceStream
+                }
+              })));
+            }
+          }
+        }
+        const handle = handles[handles.length - 1];
+        const kill = (options) => Effect.forEach([...handles].reverse(), (handle2) => Effect.ignore(handle2.kill(options)), {
+          discard: true
+        });
+        const unref = Effect.gen(function* () {
+          const rerefs = [];
+          for (const handle2 of handles) {
+            rerefs.push(yield* handle2.unref);
+          }
+          return Effect.forEach([...rerefs].reverse(), (reref) => reref, {
+            discard: true
+          });
+        });
+        return makeHandle({
+          pid: handle.pid,
+          exitCode: handle.exitCode,
+          isRunning: handle.isRunning,
+          kill,
+          stdin: handles[0].stdin,
+          stdout: handle.stdout,
+          stderr: handle.stderr,
+          all: handle.all,
+          getInputFd: handle.getInputFd,
+          getOutputFd: handle.getOutputFd,
+          unref
+        });
+      }
+    }
+  });
+  return makeSpawner(spawnCommand);
+});
+var layer = /* @__PURE__ */ Layer.effect(ChildProcessSpawner, make2);
+var flattenCommand = (command) => {
+  const commands = [];
+  const pipeOptions = [];
+  const flatten = (cmd) => {
+    switch (cmd._tag) {
+      case "StandardCommand": {
+        commands.push(cmd);
+        break;
+      }
+      case "PipedCommand": {
+        flatten(cmd.left);
+        pipeOptions.push(cmd.options);
+        flatten(cmd.right);
+        break;
+      }
+    }
+  };
+  flatten(command);
+  if (commands.length === 0) {
+    throw new Error("flattenCommand produced empty commands array");
+  }
+  const [first, ...rest] = commands;
+  const nonEmptyCommands = [first, ...rest];
+  return {
+    commands: nonEmptyCommands,
+    pipeOptions
+  };
+};
+
+export {
+  layer,
+  flattenCommand,
+  NodeChildProcessSpawner_exports
+};

package/dist/vendor/chunk-QYBKAIA6.js

@@ -0,0 +1,18 @@
+import {
+  flattenCommand,
+  layer
+} from "./chunk-QPLDT6A6.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeChildProcessSpawner.js
+var NodeChildProcessSpawner_exports = {};
+__export(NodeChildProcessSpawner_exports, {
+  flattenCommand: () => flattenCommand,
+  layer: () => layer
+});
+
+export {
+  NodeChildProcessSpawner_exports
+};