@saeeol/core 7.3.1

package/package.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "version": "7.3.1",
+  "name": "@saeeol/core",
+  "type": "module",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "test": "bun test",
+    "test:ci": "mkdir -p .artifacts/unit && bun test --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
+    "typecheck": "tsgo --noEmit"
+  },
+  "exports": {
+    "./*": "./src/*.ts"
+  },
+  "imports": {},
+  "devDependencies": {
+    "@tsconfig/bun": "catalog:",
+    "@types/bun": "catalog:",
+    "@types/cross-spawn": "catalog:",
+    "@types/npm-package-arg": "6.1.4",
+    "@types/npmcli__arborist": "6.3.3",
+    "@types/semver": "catalog:"
+  },
+  "dependencies": {
+    "@effect/opentelemetry": "catalog:",
+    "@effect/platform-node": "catalog:",
+    "@npmcli/arborist": "9.4.0",
+    "@npmcli/config": "10.8.1",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/context-async-hooks": "2.6.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.214.0",
+    "@opentelemetry/sdk-trace-base": "2.6.1",
+    "effect": "catalog:",
+    "cross-spawn": "catalog:",
+    "glob": "13.0.5",
+    "mime-types": "3.0.2",
+    "minimatch": "10.2.5",
+    "npm-package-arg": "13.0.2",
+    "rotating-file-stream": "3.2.9",
+    "semver": "^7.6.3",
+    "xdg-basedir": "5.1.0",
+    "zod": "catalog:"
+  },
+  "overrides": {
+    "drizzle-orm": "catalog:"
+  },
+  "peerDependencies": {}
+}

package/src/cross-spawn-process.ts

@@ -0,0 +1,273 @@
+import { NodeSink, NodeStream } from "@effect/platform-node"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as PlatformError from "effect/PlatformError"
+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 type { ChildProcessHandle } from "effect/unstable/process/ChildProcessSpawner"
+import {
+  makeHandle,
+  ProcessId,
+  ExitCode,
+} from "effect/unstable/process/ChildProcessSpawner"
+import * as NodeChildProcess from "node:child_process"
+import { PassThrough } from "node:stream"
+import launch from "cross-spawn"
+import { toError, toPlatformError, type ExitSignal } from "./cross-spawn-utils"
+
+export const env = (opts: ChildProcess.CommandOptions) =>
+  opts.extendEnv ? { ...globalThis.process.env, ...opts.env } : opts.env
+
+const input = (x: ChildProcess.CommandInput | undefined): NodeChildProcess.IOType | undefined =>
+  Stream.isStream(x) ? "pipe" : x
+
+const output = (x: ChildProcess.CommandOutput | undefined): NodeChildProcess.IOType | undefined =>
+  Sink.isSink(x) ? "pipe" : x
+
+export const stdin = (opts: ChildProcess.CommandOptions): ChildProcess.StdinConfig => {
+  const cfg: ChildProcess.StdinConfig = { stream: "pipe", encoding: "utf-8", endOnDone: true }
+  if (Predicate.isUndefined(opts.stdin)) return cfg
+  if (typeof opts.stdin === "string") return { ...cfg, stream: opts.stdin }
+  if (Stream.isStream(opts.stdin)) return { ...cfg, stream: opts.stdin }
+  return {
+    stream: opts.stdin.stream,
+    encoding: opts.stdin.encoding ?? cfg.encoding,
+    endOnDone: opts.stdin.endOnDone ?? cfg.endOnDone,
+  }
+}
+
+export const stdio = (opts: ChildProcess.CommandOptions, key: "stdout" | "stderr"): ChildProcess.StdoutConfig => {
+  const cfg = opts[key]
+  if (Predicate.isUndefined(cfg)) return { stream: "pipe" }
+  if (typeof cfg === "string") return { stream: cfg }
+  if (Sink.isSink(cfg)) return { stream: cfg }
+  return { stream: cfg.stream }
+}
+
+export const fds = (opts: ChildProcess.CommandOptions) => {
+  if (Predicate.isUndefined(opts.additionalFds)) return []
+  return Object.entries(opts.additionalFds)
+    .flatMap(([name, config]) => {
+      const fd = ChildProcess.parseFdName(name)
+      return Predicate.isUndefined(fd) ? [] : [{ fd, config }]
+    })
+    .toSorted((a, b) => a.fd - b.fd)
+}
+
+export const stdios = (
+  sin: ChildProcess.StdinConfig,
+  sout: ChildProcess.StdoutConfig,
+  serr: ChildProcess.StderrConfig,
+  extra: ReadonlyArray<{ fd: number; config: ChildProcess.AdditionalFdConfig }>,
+): NodeChildProcess.StdioOptions => {
+  const pipe = (x: NodeChildProcess.IOType | undefined) =>
+    process.platform === "win32" && x === "pipe" ? "overlapped" : x
+  const arr: Array<NodeChildProcess.IOType | undefined> = [
+    pipe(input(sin.stream)),
+    pipe(output(sout.stream)),
+    pipe(output(serr.stream)),
+  ]
+  if (extra.length === 0) return arr as NodeChildProcess.StdioOptions
+  const max = extra.reduce((acc, x) => Math.max(acc, x.fd), 2)
+  for (let i = 3; i <= max; i++) arr[i] = "ignore"
+  for (const x of extra) arr[x.fd] = pipe("pipe")
+  return arr as NodeChildProcess.StdioOptions
+}
+
+export const setupFds = Effect.fnUntraced(function* (
+  command: ChildProcess.StandardCommand,
+  proc: NodeChildProcess.ChildProcess,
+  extra: ReadonlyArray<{ fd: number; config: ChildProcess.AdditionalFdConfig }>,
+) {
+  if (extra.length === 0) {
+    return {
+      getInputFd: () => Sink.drain,
+      getOutputFd: () => Stream.empty,
+    }
+  }
+
+  const ins = new Map<number, Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>>()
+  const outs = new Map<number, Stream.Stream<Uint8Array, PlatformError.PlatformError>>()
+
+  for (const x of extra) {
+    const node = proc.stdio[x.fd]
+    switch (x.config.type) {
+      case "input": {
+        let sink: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError> = Sink.drain
+        if (node && "write" in node) {
+          sink = NodeSink.fromWritable({
+            evaluate: () => node,
+            onError: (err) => toPlatformError(`fromWritable(fd${x.fd})`, toError(err), command),
+            endOnDone: true,
+          })
+        }
+        if (x.config.stream) yield* Effect.forkScoped(Stream.run(x.config.stream, sink))
+        ins.set(x.fd, sink)
+        break
+      }
+      case "output": {
+        let stream: Stream.Stream<Uint8Array, PlatformError.PlatformError> = Stream.empty
+        if (node && "read" in node) {
+          const tap = new PassThrough()
+          node.on("error", (err) => tap.destroy(toError(err)))
+          node.pipe(tap)
+          stream = NodeStream.fromReadable({
+            evaluate: () => tap,
+            onError: (err) => toPlatformError(`fromReadable(fd${x.fd})`, toError(err), command),
+          })
+        }
+        if (x.config.sink) stream = Stream.transduce(stream, x.config.sink)
+        outs.set(x.fd, stream)
+        break
+      }
+    }
+  }
+
+  return {
+    getInputFd: (fd: number) => ins.get(fd) ?? Sink.drain,
+    getOutputFd: (fd: number) => outs.get(fd) ?? Stream.empty,
+  }
+})
+
+export const setupStdin = (
+  command: ChildProcess.StandardCommand,
+  proc: NodeChildProcess.ChildProcess,
+  cfg: ChildProcess.StdinConfig,
+) =>
+  Effect.suspend(() => {
+    let sink: Sink.Sink<void, unknown, never, PlatformError.PlatformError> = Sink.drain
+    if (Predicate.isNotNull(proc.stdin)) {
+      sink = NodeSink.fromWritable({
+        evaluate: () => proc.stdin!,
+        onError: (err) => toPlatformError("fromWritable(stdin)", toError(err), command),
+        endOnDone: cfg.endOnDone,
+        encoding: cfg.encoding,
+      })
+    }
+    if (Stream.isStream(cfg.stream)) return Effect.as(Effect.forkScoped(Stream.run(cfg.stream, sink)), sink)
+    return Effect.succeed(sink)
+  })
+
+export const setupOutput = (
+  command: ChildProcess.StandardCommand,
+  proc: NodeChildProcess.ChildProcess,
+  out: ChildProcess.StdoutConfig,
+  err: ChildProcess.StderrConfig,
+) => {
+  let stdout = proc.stdout
+    ? NodeStream.fromReadable({
+        evaluate: () => proc.stdout!,
+        onError: (cause) => toPlatformError("fromReadable(stdout)", toError(cause), command),
+      })
+    : Stream.empty
+  let stderr = proc.stderr
+    ? NodeStream.fromReadable({
+        evaluate: () => proc.stderr!,
+        onError: (cause) => toPlatformError("fromReadable(stderr)", toError(cause), command),
+      })
+    : Stream.empty
+
+  if (Sink.isSink(out.stream)) stdout = Stream.transduce(stdout, out.stream)
+  if (Sink.isSink(err.stream)) stderr = Stream.transduce(stderr, err.stream)
+
+  return { stdout, stderr, all: Stream.merge(stdout, stderr) }
+}
+
+export const spawn = (command: ChildProcess.StandardCommand, opts: NodeChildProcess.SpawnOptions) =>
+  Effect.callback<readonly [NodeChildProcess.ChildProcess, ExitSignal], PlatformError.PlatformError>((resume) => {
+    const signal = Deferred.makeUnsafe<readonly [code: number | null, signal: NodeJS.Signals | null]>()
+    const proc = launch(command.command, command.args, opts)
+    let end = false
+    let exit: readonly [code: number | null, signal: NodeJS.Signals | null] | undefined
+    proc.on("error", (err) => {
+      resume(Effect.fail(toPlatformError("spawn", err, command)))
+    })
+    proc.on("exit", (...args) => {
+      exit = args
+    })
+    proc.on("close", (...args) => {
+      if (end) return
+      end = true
+      Deferred.doneUnsafe(signal, Exit.succeed(exit ?? args))
+    })
+    proc.on("spawn", () => {
+      resume(Effect.succeed([proc, signal]))
+    })
+    return Effect.sync(() => {
+      proc.kill("SIGTERM")
+    })
+  })
+
+export const killGroup = (
+  command: ChildProcess.StandardCommand,
+  proc: NodeChildProcess.ChildProcess,
+  signal: NodeJS.Signals,
+) => {
+  if (globalThis.process.platform === "win32") {
+    return Effect.callback<void, PlatformError.PlatformError>((resume) => {
+      NodeChildProcess.exec(`taskkill /pid ${proc.pid} /T /F`, { windowsHide: true }, (err) => {
+        if (err) return resume(Effect.fail(toPlatformError("kill", toError(err), command)))
+        resume(Effect.void)
+      })
+    })
+  }
+
+  return Effect.try({
+    try: () => {
+      globalThis.process.kill(-proc.pid!, signal)
+    },
+    catch: (err) => toPlatformError("kill", toError(err), command),
+  })
+}
+
+export const killOne = (
+  command: ChildProcess.StandardCommand,
+  proc: NodeChildProcess.ChildProcess,
+  signal: NodeJS.Signals,
+) =>
+  Effect.suspend(() => {
+    if (proc.kill(signal)) return Effect.void
+    return Effect.fail(toPlatformError("kill", new Error("Failed to kill child process"), command))
+  })
+
+export const timeout =
+  (
+    proc: NodeChildProcess.ChildProcess,
+    command: ChildProcess.StandardCommand,
+    opts: ChildProcess.KillOptions | undefined,
+  ) =>
+  <A, E, R>(
+    f: (
+      command: ChildProcess.StandardCommand,
+      proc: NodeChildProcess.ChildProcess,
+      signal: NodeJS.Signals,
+    ) => Effect.Effect<A, E, R>,
+  ) => {
+    const signal = opts?.killSignal ?? "SIGTERM"
+    if (Predicate.isUndefined(opts?.forceKillAfter)) return f(command, proc, signal)
+    return Effect.timeoutOrElse(f(command, proc, signal), {
+      duration: opts.forceKillAfter,
+      orElse: () => f(command, proc, "SIGKILL"),
+    })
+  }
+
+export const source = (handle: ChildProcessHandle, from: ChildProcess.PipeFromOption | undefined) => {
+  const opt = from ?? "stdout"
+  switch (opt) {
+    case "stdout":
+      return handle.stdout
+    case "stderr":
+      return handle.stderr
+    case "all":
+      return handle.all
+    default: {
+      const fd = ChildProcess.parseFdName(opt)
+      return Predicate.isNotUndefined(fd) ? handle.getOutputFd(fd) : handle.stdout
+    }
+  }
+}
+
+export { makeHandle, ProcessId, ExitCode }