@pnpm/exe 12.8.1 → 12.9.0

package/dist/wasm/host/guest-operations.mjs

@@ -0,0 +1,148 @@
+import { createHostServices } from './operations.mjs'
+import { RESPONSE_CAPACITY } from './protocol.mjs'
+
+export function createGuestOperations (services = createHostServices()) {
+  const pending = new Map()
+  const completed = []
+  const waiters = []
+  const inFlight = new Set()
+  const cleanupErrors = []
+  let nextId = 1
+  let closed = false
+
+  function start (request) {
+    if (closed || nextId > 0x7fffffff) return -2
+    const id = nextId++
+    const entry = { controller: new AbortController(), response: null, operation: request.operation, result: null }
+    pending.set(id, entry)
+    if (request.operation === 'process.write') request.bytes = Uint8Array.from(request.bytes)
+    if (request.operation === 'network.request' && Array.isArray(request.body)) request.body = Uint8Array.from(request.body)
+    const task = Promise.resolve().then(() => services.dispatch(request, { signal: entry.controller.signal })).then(
+      value => settle(id, entry, { ok: true, value }),
+      error => settle(id, entry, { ok: false, error: { message: error.message, code: errorCode(error) } }),
+    )
+    track(task)
+    return id
+  }
+
+  function track (task) {
+    inFlight.add(task)
+    task.then(() => inFlight.delete(task), error => {
+      inFlight.delete(task)
+      cleanupErrors.push(error)
+    })
+  }
+
+  async function releaseResult (operation, result) {
+    if (!result?.ok) return
+    const handles = ['network.request', 'upload.create', 'terminal.open'].includes(operation) ? [result.value.handle]
+      : ['process.spawn', 'shell.spawn'].includes(operation) ? [result.value.stdout, result.value.stderr, result.value.handle] : []
+    await Promise.all(handles.filter(handle => handle != null)
+      .map(handle => services.dispatch({ operation: 'resource.close', handle })))
+  }
+
+  async function settle (id, entry, result) {
+    if (!pending.has(id)) return closed ? undefined : releaseResult(entry.operation, result)
+    let bytes
+    try {
+      bytes = new TextEncoder().encode(JSON.stringify(result, (_key, value) => value instanceof Uint8Array ? [...value] : value))
+      if (bytes.length > RESPONSE_CAPACITY) throw new Error('WASM host response exceeds the transfer limit')
+    } catch (error) {
+      try {
+        await releaseResult(entry.operation, result)
+      } catch (cleanupError) {
+        cleanupErrors.push(cleanupError)
+      }
+      result = { ok: false, error: { message: error.message } }
+      bytes = new TextEncoder().encode(JSON.stringify(result))
+    }
+    if (!pending.has(id)) return
+    entry.result = result
+    entry.response = bytes
+    const waiter = waiters.shift()
+    if (waiter) waiter(id)
+    else completed.push(id)
+  }
+
+  async function dispatch (method, args) {
+    switch (method) {
+    case 'start': return start(args[0])
+    case 'length': return pending.get(args[0])?.response?.length ?? (pending.has(args[0]) ? -1 : -2)
+    case 'read': {
+      const entry = pending.get(args[0])
+      if (!entry?.response || entry.response.length > args[1]) return -2
+      pending.delete(args[0])
+      return entry.response
+    }
+    case 'cancel': {
+      const entry = pending.get(args[0])
+      pending.delete(args[0])
+      entry?.controller.abort()
+      if (entry?.result) await releaseResult(entry.operation, entry.result)
+      return 0
+    }
+    case 'close-resource': {
+      await services.dispatch({ operation: 'resource.close', handle: args[0] })
+      return 0
+    }
+    case 'wait': {
+      while (completed.length > 0) {
+        const id = completed.shift()
+        if (pending.has(id)) return id
+      }
+      return closed ? 0 : new Promise(resolve => waiters.push(resolve))
+    }
+    default: throw new Error(`Unknown guest operation: ${method}`)
+    }
+  }
+
+  return {
+    dispatch,
+    attach (worker) {
+      const listener = message => {
+        if (!message.pnpmHostRpc) return
+        const { method, args, buffer } = message.pnpmHostRpc
+        respond(buffer, dispatch(method, args)).catch(error => worker.emit('error', error))
+      }
+      worker.on('message', listener)
+      return () => worker.off('message', listener)
+    },
+    async close () {
+      closed = true
+      for (const entry of pending.values()) entry.controller.abort()
+      pending.clear()
+      for (const waiter of waiters.splice(0)) waiter(0)
+      try {
+        await services.close()
+      } finally {
+        await Promise.allSettled([...inFlight])
+      }
+      if (cleanupErrors.length) throw new AggregateError(cleanupErrors, 'Failed to clean up cancelled WASM operations')
+    },
+  }
+}
+
+async function respond (buffer, response) {
+  const header = new Int32Array(buffer, 0, 3)
+  Atomics.store(header, 1, -2)
+  Atomics.store(header, 2, 0)
+  try {
+    const value = await response
+    if (value instanceof Uint8Array) {
+      new Uint8Array(buffer, 12).set(value)
+      Atomics.store(header, 1, value.length)
+      Atomics.store(header, 2, value.length)
+    } else {
+      Atomics.store(header, 1, value)
+      Atomics.store(header, 2, 0)
+    }
+  } finally {
+    Atomics.store(header, 0, 1)
+    Atomics.notify(header, 0)
+  }
+}
+
+function errorCode (error) {
+  const code = error.code ?? error.cause?.code
+  return typeof code === 'string' ? code : undefined
+}

package/dist/wasm/host/lock-registry.mjs

@@ -0,0 +1,167 @@
+import { randomUUID } from 'node:crypto'
+import fs from 'node:fs'
+import { createConnection, createServer } from 'node:net'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+
+const mutexPort = 29753
+const tokens = new Set()
+let listener
+let acquiring = 0
+
+// The rendezvous port protects only registry updates. Held file locks use
+// ephemeral ports, so unrelated nested locks cannot collide or reverse order.
+export async function acquireFileLease (identity, exclusive, previous) {
+  acquiring++
+  try {
+    return await acquireRegisteredLease(identity, exclusive, previous)
+  } finally {
+    acquiring--
+    closeIdleListener()
+  }
+}
+
+async function acquireRegisteredLease (identity, exclusive, previous) {
+  const mutex = await listen(createServer(socket => socket.destroy()), mutexPort)
+  if (!mutex) return undefined
+  let token
+  try {
+    const file = registryPath(identity)
+    const owners = await liveOwners(file)
+    if (owners.some(owner => owner.token !== previous?.token && (exclusive || owner.exclusive))) return undefined
+    const server = await leaseListener()
+    token = previous?.token ?? randomUUID()
+    tokens.add(token)
+    const owner = { port: server.address().port, token, exclusive, pid: process.pid }
+    writeOwners(file, [...owners.filter(entry => entry.token !== token), owner])
+    return { token, exclusive, release () { tokens.delete(token); closeIdleListener() } }
+  } catch (error) {
+    if (token && token !== previous?.token) tokens.delete(token)
+    throw error
+  } finally {
+    await new Promise(resolve => mutex.close(resolve))
+  }
+}
+
+function registryPath (identity) {
+  const directory = path.join(os.tmpdir(), `pnpm-wasm-file-locks-${process.getuid()}`)
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 })
+  const descriptor = fs.openSync(directory, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW)
+  try {
+    if (fs.fstatSync(descriptor).uid !== process.getuid()) throw new Error('WASM lock registry belongs to another user')
+    fs.fchmodSync(descriptor, 0o700)
+  } finally {
+    fs.closeSync(descriptor)
+  }
+  return path.join(directory, identity.replace(':', '-'))
+}
+
+async function liveOwners (file) {
+  let descriptor
+  try {
+    descriptor = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK)
+  } catch (error) {
+    if (error.code === 'ENOENT') return []
+    throw error
+  }
+  let owners
+  try {
+    const metadata = fs.fstatSync(descriptor)
+    if (!metadata.isFile() || metadata.size > 1024 * 1024) throw new Error('Invalid WASM lock ownership record')
+    owners = JSON.parse(fs.readFileSync(descriptor, 'utf8'))
+  } finally {
+    fs.closeSync(descriptor)
+  }
+  if (!Array.isArray(owners) || owners.length > 4096 || !owners.every(validOwner)) throw new Error('Invalid WASM lock ownership record')
+  const live = await Promise.all(owners.map(async owner => await isAlive(owner) ? owner : undefined))
+  return live.filter(Boolean)
+}
+
+function validOwner (owner) {
+  return Number.isInteger(owner?.port) && owner.port > 0 && owner.port < 65536 &&
+    typeof owner.token === 'string' && /^[\da-f-]{36}$/.test(owner.token) && typeof owner.exclusive === 'boolean' &&
+    (owner.pid == null || (Number.isSafeInteger(owner.pid) && owner.pid > 0))
+}
+
+function writeOwners (file, owners) {
+  const temporary = `${file}.${randomUUID()}`
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(owners), { flag: 'wx', mode: 0o600 })
+    fs.renameSync(temporary, file)
+  } catch (error) {
+    try { fs.unlinkSync(temporary) } catch (cleanup) { if (cleanup.code !== 'ENOENT') throw cleanup }
+    throw error
+  }
+}
+
+async function leaseListener () {
+  listener ??= listen(createServer(socket => {
+    let request = ''
+    socket.setTimeout(1000, () => socket.destroy())
+    socket.on('error', () => { /* A probing process may exit before receiving the response. */ })
+    socket.on('data', chunk => {
+      request += chunk.toString()
+      if (request.length > 37) return socket.destroy()
+      if (request.endsWith('\n')) socket.end(tokens.has(request.trim()) ? 'alive\n' : 'released\n')
+    })
+  }), 0)
+  return listener
+}
+
+function listen (server, port) {
+  return new Promise((resolve, reject) => {
+    server.once('error', error => {
+      if (error.code === 'EADDRINUSE') resolve(undefined)
+      else reject(error)
+    })
+    server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
+      server.unref()
+      resolve(server)
+    })
+  })
+}
+
+function isAlive (owner) {
+  if (owner.pid != null && processIsAbsent(owner.pid)) return Promise.resolve(false)
+  return new Promise((resolve, reject) => {
+    const socket = createConnection({ host: '127.0.0.1', port: owner.port })
+    let response = ''
+    function finish (value) {
+      socket.destroy()
+      resolve(value)
+    }
+    // A slow live owner must never be reaped. Only refusal or an explicit
+    // different token proves that this ownership record is abandoned.
+    socket.setTimeout(1000, () => finish(true))
+    socket.on('connect', () => socket.write(`${owner.token}\n`))
+    socket.on('data', chunk => {
+      response += chunk.toString()
+      if (response.endsWith('\n') || response.length > 32) finish(response !== 'released\n')
+    })
+    socket.on('end', () => finish(response !== 'released\n'))
+    socket.on('error', error => {
+      socket.destroy()
+      if (error.code === 'ECONNREFUSED') resolve(false)
+      else if (error.code === 'ECONNRESET') resolve(true)
+      else reject(error)
+    })
+  })
+}
+
+function processIsAbsent (pid) {
+  try {
+    process.kill(pid, 0)
+  } catch (error) {
+    if (error.code === 'ESRCH') return true
+    if (!['EPERM', 'EINVAL', 'ENOSYS'].includes(error.code)) throw error
+  }
+  return false
+}
+
+function closeIdleListener () {
+  if (tokens.size || acquiring || !listener) return
+  const closing = listener
+  listener = undefined
+  void closing.then(server => server.close(), () => { /* The acquisition already reports a failed listener. */ })
+}

package/dist/wasm/host/network.mjs

@@ -0,0 +1,76 @@
+import { createStream } from './resources.mjs'
+
+export async function request (resources, options, signal) {
+  let url
+  try {
+    url = new URL(options.url)
+  } catch {
+    throw new TypeError('Invalid HTTP request URL')
+  }
+  if (url.username || url.password) throw new TypeError('HTTP URL credentials must be supplied as an Authorization header')
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error(`Unsupported HTTP protocol: ${url.protocol}`)
+  }
+  const controller = new AbortController()
+  const timeoutMs = options.timeoutMs ?? 60000
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1) throw new RangeError('Invalid HTTP timeout')
+  if (options.totalTimeoutMs != null && (!Number.isInteger(options.totalTimeoutMs) || options.totalTimeoutMs < 1)) {
+    throw new RangeError('Invalid HTTP total timeout')
+  }
+  const totalTimer = options.totalTimeoutMs == null ? null
+    : setTimeout(() => controller.abort(new Error('HTTP request deadline timed out')), options.totalTimeoutMs)
+  const timer = setTimeout(() => controller.abort(new Error('HTTP request timed out')), timeoutMs)
+  const pending = resources.add({ kind: 'request', close: () => controller.abort() })
+  try {
+    const body = options.bodyHandle == null ? options.body : resources.get(options.bodyHandle, 'upload').readable
+    const response = await fetch(url, {
+      method: options.method ?? 'GET',
+      headers: options.headers,
+      body,
+      ...(options.bodyHandle == null ? {} : { duplex: 'half' }),
+      redirect: 'manual',
+      signal: signal ? AbortSignal.any([controller.signal, signal]) : controller.signal,
+    })
+    const reader = response.body?.getReader()
+    const stream = createStream(
+      async () => {
+        const chunk = await readWithTimeout(reader, controller, timeoutMs)
+        if (chunk.done) clearTimeout(totalTimer)
+        return chunk
+      },
+      () => {
+        clearTimeout(totalTimer)
+        controller.abort()
+      },
+    )
+    signal?.throwIfAborted()
+    return {
+      handle: resources.add(stream),
+      status: response.status,
+      headers: decodedHeaders(response.headers),
+      url: response.url,
+    }
+  } catch (error) {
+    clearTimeout(totalTimer)
+    controller.abort()
+    throw error
+  } finally {
+    clearTimeout(timer)
+    resources.remove(pending)
+  }
+}
+
+function decodedHeaders (headers) {
+  const decoded = headers.get('content-encoding')?.split(',')
+    .every(encoding => ['gzip', 'deflate', 'br'].includes(encoding.trim().toLowerCase()))
+  return [...headers].filter(([name]) => !decoded || (name !== 'content-encoding' && name !== 'content-length'))
+}
+
+async function readWithTimeout (reader, controller, timeoutMs) {
+  const timer = setTimeout(() => controller.abort(new Error('HTTP response timed out')), timeoutMs)
+  try {
+    return await reader?.read() ?? { done: true }
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/dist/wasm/host/operations.mjs

@@ -0,0 +1,67 @@
+import { request } from './network.mjs'
+import { endStdin, spawnProcess, tryWaitProcess, waitProcess, writeStdin } from './process.mjs'
+import { createResources } from './resources.mjs'
+import { createSignals } from './signals.mjs'
+import { spawnShell } from './shell.mjs'
+import { createUpload, writeUpload } from './upload.mjs'
+import { confirm, input, prompt } from './terminal.mjs'
+import { openTerminal, writeTerminal } from './terminal-session.mjs'
+import { password } from './terminal-password.mjs'
+
+export function createHostServices (configuration = {}) {
+  const resources = createResources()
+  const signals = createSignals(configuration.signalSource)
+  let closed = false
+  return {
+    async dispatch (message, options = {}) {
+      if (closed) throw new Error('WASM host services are closed')
+      options.signal?.throwIfAborted()
+      switch (message.operation) {
+      case 'network.request': return request(resources, message, options.signal)
+      case 'upload.create': return createUpload(resources)
+      case 'upload.write': return writeUpload(resources.get(message.handle, 'upload'), message.bytes)
+      case 'upload.end': return resources.get(message.handle, 'upload').writer.close()
+      case 'stream.read': return resources.get(message.handle, 'stream').read(message.maxBytes)
+      case 'resource.close': return resources.close(message.handle)
+      case 'process.spawn': return spawnProcess(resources, message, {
+        signal: options.signal, acquireDescriptor: configuration.acquireDescriptor,
+      })
+      case 'shell.spawn': return spawnShell(resources, message, {
+        signal: options.signal, acquireDescriptor: configuration.acquireDescriptor,
+      })
+      case 'process.write': return writeStdin(resources.get(message.handle, 'process'), message.bytes)
+      case 'process.endDetached':
+        resources.get(message.handle, 'process').child.stdin?.end()
+        return null
+      case 'process.closeStdin':
+        resources.get(message.handle, 'process').child.stdin?.destroy()
+        return null
+      case 'process.end': return endStdin(resources.get(message.handle, 'process'))
+      case 'process.wait': return waitProcess(resources.get(message.handle, 'process'))
+      case 'process.tryWait': return tryWaitProcess(resources.get(message.handle, 'process'))
+      case 'process.release':
+        resources.get(message.handle, 'process')
+        resources.remove(message.handle)
+        return null
+      case 'process.killPid':
+        return resources.findProcess(message.pid).kill(message.signal ?? 'SIGTERM')
+      case 'process.kill': return resources.get(message.handle, 'process').kill(message.signal ?? 'SIGTERM')
+      case 'signal.next': return signals.next(options)
+      case 'terminal.status': return { stdin: Boolean(process.stdin.isTTY), stdout: Boolean(process.stdout.isTTY), stderr: Boolean(process.stderr.isTTY) }
+      case 'terminal.open': return openTerminal(resources)
+      case 'terminal.readKey': return resources.get(message.handle, 'terminal').read(options.signal)
+      case 'terminal.write': return writeTerminal(resources.get(message.handle, 'terminal'), message.text)
+      case 'terminal.prompt': return prompt(message, options)
+      case 'terminal.confirm': return confirm(message, options)
+      case 'terminal.input': return input(message, options)
+      case 'terminal.password': return password(message, options)
+      default: throw new Error(`Unknown WASM host operation: ${message.operation}`)
+      }
+    },
+    async close () {
+      closed = true
+      signals.close()
+      await resources.closeAll()
+    },
+  }
+}

package/dist/wasm/host/poll.mjs

@@ -0,0 +1,74 @@
+import { performance } from 'node:perf_hooks'
+import { setTimeout } from 'node:timers/promises'
+
+import { errno } from './wasi-errno.mjs'
+
+const { AbortController } = globalThis
+
+// Clock polling must yield the supervisor so other guest threads, leases and
+// process termination remain responsive while a Rust thread sleeps.
+export function createPoll (memory) {
+  const controller = new AbortController()
+  return { close () { controller.abort() }, async poll (input, output, count, written) {
+    try {
+      if (!input || !output || !count || !written) return errno.EINVAL
+      const subscriptions = readSubscriptions(memory, input >>> 0, count >>> 0)
+      new Uint8Array(memory.buffer, output >>> 0, (count >>> 0) * 32)
+      new DataView(memory.buffer).setUint32(written >>> 0, 0, true)
+      const descriptors = subscriptions.filter(subscription => subscription.type !== 0)
+      if (descriptors.length) return writeEvents(memory, { output, written }, descriptors, errno.ENOSYS)
+      const first = subscriptions.reduce((earliest, entry) => entry.delay < earliest.delay ? entry : earliest)
+      await waitForClock(first.delay, controller.signal)
+      return writeEvents(memory, { output, written }, [first], 0)
+    } catch (error) {
+      if (error.name === 'AbortError') return errno.EINTR
+      if (error instanceof RangeError) return errno.EFAULT
+      if (error.code === 'EINVAL') return errno.EINVAL
+      throw error
+    }
+  } }
+}
+
+function readSubscriptions (memory, input, count) {
+  const view = new DataView(memory.buffer, input, count * 48)
+  return Array.from({ length: count }, (_, index) => {
+    const offset = index * 48
+    const type = view.getUint8(offset + 8)
+    if (type > 2) throw Object.assign(new Error('Invalid WASI subscription type'), { code: 'EINVAL' })
+    return { userdata: view.getBigUint64(offset, true), type, delay: type === 0 ? clockDelay(view, offset) : 0n }
+  })
+}
+
+function clockDelay (view, offset) {
+  const clock = view.getUint32(offset + 16, true)
+  const timeout = view.getBigUint64(offset + 24, true)
+  const flags = view.getUint16(offset + 40, true)
+  if (clock > 3 || flags > 1) throw Object.assign(new Error('Invalid WASI clock subscription'), { code: 'EINVAL' })
+  if (flags === 0) return timeout
+  // Match the clock epoch used by the injected WASI clock_time_get import.
+  const now = BigInt(Math.floor(clock === 0 ? Date.now() : performance.now())) * 1000000n
+  return timeout > now ? timeout - now : 0n
+}
+
+async function waitForClock (delay, signal) {
+  const deadline = performance.now() + Number(delay) / 1000000
+  let remaining = deadline - performance.now()
+  do {
+    // eslint-disable-next-line no-await-in-loop -- Recheck the deadline after early or maximum-length timers.
+    await setTimeout(Math.min(Math.ceil(Math.max(remaining, 0)), 2147483647), undefined, { signal })
+    remaining = deadline - performance.now()
+  } while (remaining > 0)
+}
+
+function writeEvents (memory, { output, written }, subscriptions, error) {
+  const view = new DataView(memory.buffer)
+  subscriptions.forEach((subscription, index) => {
+    const offset = (output >>> 0) + index * 32
+    new Uint8Array(memory.buffer, offset, 32).fill(0)
+    view.setBigUint64(offset, subscription.userdata, true)
+    view.setUint16(offset + 8, error, true)
+    view.setUint8(offset + 10, subscription.type)
+  })
+  view.setUint32(written >>> 0, subscriptions.length, true)
+  return 0
+}

package/dist/wasm/host/process-stdio.mjs

@@ -0,0 +1,41 @@
+import { createReadStream, createWriteStream } from 'node:fs'
+import { pipeline } from 'node:stream/promises'
+
+export function prepareStdio (options, acquireDescriptor) {
+  const redirects = new Map()
+  try {
+    const modes = ['stdin', 'stdout', 'stderr'].map((name, index) => {
+      const mode = options[name] ?? 'pipe'
+      if (mode && typeof mode === 'object' && Number.isInteger(mode.fd) && mode.fd >= 0) {
+        if (!acquireDescriptor) throw new Error('WASI descriptor leasing is unavailable')
+        const lease = acquireDescriptor(mode.fd)
+        if (!Number.isInteger(lease.fd) || lease.fd < 0) throw new Error(`Invalid WASI descriptor: ${mode.fd}`)
+        redirects.set(index, lease)
+        return 'pipe'
+      }
+      if (!['pipe', 'inherit', 'ignore'].includes(mode)) throw new Error(`Invalid stdio mode: ${mode}`)
+      return mode
+    })
+    return { modes, redirects, release: () => release(redirects) }
+  } catch (error) {
+    release(redirects)
+    throw error
+  }
+}
+
+export function bridgeDescriptors (child, redirects) {
+  return Promise.allSettled([...redirects].map(async ([index, lease]) => {
+    try {
+      if (index === 0) await pipeline(createReadStream(null, { fd: lease.fd, autoClose: false }), child.stdin)
+      else await pipeline(child.stdio[index], createWriteStream(null, { fd: lease.fd, autoClose: false }))
+    } catch (error) {
+      if (index !== 0 || !['EPIPE', 'ERR_STREAM_PREMATURE_CLOSE'].includes(error.code)) throw error
+    } finally {
+      lease.release()
+    }
+  })).then(results => results.find(result => result.status === 'rejected')?.reason)
+}
+
+function release (redirects) {
+  for (const lease of redirects.values()) lease.release()
+}

package/dist/wasm/host/process-tree.mjs

@@ -0,0 +1,54 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const executeFile = promisify(execFile)
+
+export async function killProcessTree (child, signal) {
+  if (!isRunning(child)) return false
+  let stdout
+  try {
+    ({ stdout } = await executeFile('/bin/ps', ['-eo', 'pid,ppid'], {
+      timeout: 2000, maxBuffer: 4 * 1024 * 1024, encoding: 'utf8',
+    }))
+  } catch (error) {
+    if (isRunning(child)) child.kill(signal)
+    throw error
+  }
+  if (!isRunning(child)) return false
+  const descendants = findDescendants(stdout, child.pid)
+  for (const pid of descendants.reverse()) signalProcess(pid, signal)
+  return child.kill(signal)
+}
+
+export function findDescendants (listing, parentPid) {
+  const children = new Map()
+  for (const line of listing.trim().split('\n').slice(1)) {
+    const [pid, parent] = line.trim().split(/\s+/).map(Number)
+    if (!Number.isInteger(pid) || pid < 1 || !Number.isInteger(parent) || parent < 0) continue
+    const siblings = children.get(parent) ?? []
+    siblings.push(pid)
+    children.set(parent, siblings)
+  }
+  const descendants = []
+  const visited = new Set([parentPid])
+  const pending = [...(children.get(parentPid) ?? [])]
+  for (const pid of pending) {
+    if (visited.has(pid)) continue
+    visited.add(pid)
+    descendants.push(pid)
+    pending.push(...(children.get(pid) ?? []))
+  }
+  return descendants
+}
+
+function isRunning (child) {
+  return child.pid !== undefined && child.exitCode === null && child.signalCode === null
+}
+
+function signalProcess (pid, signal) {
+  try {
+    process.kill(pid, signal)
+  } catch (error) {
+    if (error.code !== 'ESRCH') throw error
+  }
+}