@pnpm/exe 12.8.1 → 12.9.0

package/dist/wasm/host/process.mjs

@@ -0,0 +1,126 @@
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import { constants } from 'node:os'
+
+import { killProcessTree } from './process-tree.mjs'
+import { createStream } from './resources.mjs'
+import { bridgeDescriptors, prepareStdio } from './process-stdio.mjs'
+
+export async function spawnProcess (resources, options, { signal, acquireDescriptor } = {}) {
+  const stdio = prepareStdio(options, acquireDescriptor)
+  const child = startProcess(options, stdio)
+  const processResource = trackProcess(child, bridgeDescriptors(child, stdio.redirects))
+  const abort = () => {
+    processResource.cancellation = processResource.close().then(() => signal.reason, error => error)
+  }
+  signal?.addEventListener('abort', abort, { once: true })
+  void processResource.completion.then(() => signal?.removeEventListener('abort', abort))
+  const handle = resources.add(processResource)
+  const stdout = addPipe(resources, stdio.redirects.has(1) ? null : child.stdout)
+  const stderr = addPipe(resources, stdio.redirects.has(2) ? null : child.stderr)
+  try {
+    await once(child, 'spawn')
+    signal?.throwIfAborted()
+  } catch (error) {
+    resources.remove(handle)
+    if (stdout !== null) resources.remove(stdout)
+    if (stderr !== null) resources.remove(stderr)
+    await processResource.close()
+    throw error
+  }
+  return {
+    handle,
+    pid: child.pid,
+    stdout,
+    stderr,
+  }
+}
+
+export async function writeStdin (resource, bytes) {
+  if (resource.inputError) throw resource.inputError
+  if (!(bytes instanceof Uint8Array)) throw new TypeError('Process input must be a Uint8Array')
+  if (!resource.child.stdin) throw new Error('Process stdin is not piped')
+  await new Promise((resolve, reject) => {
+    resource.child.stdin.write(bytes, error => error ? reject(error) : resolve())
+  })
+}
+
+export async function endStdin (resource) {
+  if (resource.inputError) throw resource.inputError
+  if (!resource.child.stdin) throw new Error('Process stdin is not piped')
+  await new Promise((resolve, reject) => {
+    resource.child.stdin.end(error => error ? reject(error) : resolve())
+  })
+}
+
+export async function waitProcess (resource) {
+  const result = await resource.completion
+  const cancellationError = await resource.cancellation
+  if (cancellationError) throw cancellationError
+  if (result.error) throw result.error
+  return result
+}
+
+export function tryWaitProcess (resource) {
+  if (resource.status?.error) throw resource.status.error
+  return resource.status
+}
+
+function addPipe (resources, pipe) {
+  if (!pipe) return null
+  const iterator = pipe[Symbol.asyncIterator]()
+  const next = () => iterator.next().then(result => ({ result }), error => ({ error }))
+  let pending = next()
+  return resources.add(createStream(async () => {
+    const settled = await pending
+    if (settled.error) throw settled.error
+    if (!settled.result.done) pending = next()
+    return settled.result
+  }, () => pipe.destroy()))
+}
+
+function startProcess (options, stdio) {
+  try {
+    return spawn(options.program, options.args ?? [], {
+      cwd: options.cwd, env: options.env, stdio: stdio.modes,
+    })
+  } catch (error) {
+    stdio.release()
+    throw error
+  }
+}
+
+function trackProcess (child, redirected) {
+  const completion = new Promise(resolve => {
+    child.once('error', error => resolve({ error }))
+    child.once('exit', (code, signal) => resolve(exitStatus(code, signal)))
+  }).then(async result => {
+    const error = result.error ?? await redirected
+    return error ? { error } : result
+  })
+  const resource = {
+    kind: 'process',
+    child,
+    completion,
+    kill: signal => killProcessTree(child, signal),
+    inputError: null,
+    status: null,
+    async close () {
+      try {
+        await killProcessTree(child, 'SIGKILL')
+      } finally {
+        child.stdin?.destroy()
+        child.stdout?.destroy()
+        child.stderr?.destroy()
+        await completion
+      }
+    },
+  }
+  child.stdin?.on('error', error => { resource.inputError = error })
+  void completion.then(result => { resource.status = result })
+  return resource
+}
+
+function exitStatus (code, signal) {
+  return { code, signal, signalNumber: signal === null ? null : constants.signals[signal] ?? null }
+}

package/dist/wasm/host/protocol.mjs

@@ -0,0 +1 @@
+export const RESPONSE_CAPACITY = 1024 * 1024

package/dist/wasm/host/resources.mjs

@@ -0,0 +1,76 @@
+export function createResources () {
+  const resources = new Map()
+  let nextHandle = 1
+  let closed = false
+  return {
+    add (resource) {
+      if (closed) throw new Error('WASM host resources are closed')
+      if (nextHandle > 0x7fffffff) throw new Error('WASM host resource handles exhausted')
+      const handle = nextHandle++
+      resources.set(handle, resource)
+      return handle
+    },
+    get (handle, kind) {
+      const resource = resources.get(handle)
+      if (!resource || resource.kind !== kind) throw new Error(`Invalid ${kind} handle: ${handle}`)
+      return resource
+    },
+    findProcess (pid) {
+      const resource = [...resources.values()].find(resource => resource.kind === 'process' && resource.child.pid === pid)
+      if (!resource) throw Object.assign(new Error(`No owned process with PID ${pid}`), { code: 'ESRCH' })
+      return resource
+    },
+    remove (handle) {
+      resources.delete(handle)
+    },
+    async close (handle) {
+      const resource = resources.get(handle)
+      if (!resource) throw new Error(`Invalid resource handle: ${handle}`)
+      resources.delete(handle)
+      await resource.close()
+    },
+    async closeAll () {
+      closed = true
+      const pending = [...resources.values()]
+      resources.clear()
+      const results = await Promise.allSettled(pending.map(resource => resource.close()))
+      const errors = results.filter(result => result.status === 'rejected').map(result => result.reason)
+      if (errors.length) throw new AggregateError(errors, 'Failed to close WASM host resources')
+    },
+  }
+}
+
+export function createStream (reader, cancel) {
+  let remainder = new Uint8Array()
+  let reading = false
+  let closed = false
+  return {
+    kind: 'stream',
+    async read (maxBytes = 65536) {
+      if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > 65536) {
+        throw new RangeError('Stream read size must be between 1 and 65536')
+      }
+      if (reading) throw new Error('Concurrent reads of one stream are not supported')
+      if (closed) throw new Error('Stream is closed')
+      reading = true
+      try {
+        while (remainder.length === 0) {
+          // eslint-disable-next-line no-await-in-loop -- Empty chunks must be consumed before returning stream bytes.
+          const result = await reader()
+          if (result.done) return { bytes: new Uint8Array(), done: true }
+          remainder = result.value
+        }
+        const bytes = Uint8Array.from(remainder.subarray(0, maxBytes))
+        remainder = remainder.subarray(bytes.length)
+        return { bytes, done: false }
+      } finally {
+        reading = false
+      }
+    },
+    async close () {
+      closed = true
+      remainder = new Uint8Array()
+      await cancel()
+    },
+  }
+}

package/dist/wasm/host/shell-runner.mjs

@@ -0,0 +1,8 @@
+import { execute } from '@yarnpkg/shell'
+
+try {
+  process.exitCode = await execute(process.argv[2], process.argv.slice(3))
+} catch (error) {
+  console.error(error.message)
+  process.exitCode = 1
+}

package/dist/wasm/host/shell.mjs

@@ -0,0 +1,19 @@
+import { fileURLToPath } from 'node:url'
+
+import { parseShell } from '@yarnpkg/parsers'
+import { globUtils } from '@yarnpkg/shell'
+
+import { spawnProcess } from './process.mjs'
+
+export function spawnShell (resources, options, configuration) {
+  try {
+    parseShell(options.script, globUtils)
+  } catch (error) {
+    throw Object.assign(new Error(error.message, { cause: error }), { code: 'ESHELLPARSE' })
+  }
+  return spawnProcess(resources, {
+    ...options,
+    program: process.execPath,
+    args: [fileURLToPath(new URL('./shell-runner.mjs', import.meta.url)), options.script, ...(options.args ?? [])],
+  }, configuration)
+}

package/dist/wasm/host/signals.mjs

@@ -0,0 +1,49 @@
+export function createSignals (source = process) {
+  const queued = []
+  const waiters = []
+  let handlers
+  let closed = false
+
+  function subscribe () {
+    if (handlers) return
+    handlers = ['SIGINT', 'SIGTERM'].map(signal => {
+      const listener = () => {
+        const value = { signal, number: signal === 'SIGINT' ? 2 : 15 }
+        const waiter = waiters.shift()
+        if (waiter) waiter.resolve(value)
+        else queued.push(value)
+      }
+      source.on(signal, listener)
+      return [signal, listener]
+    })
+  }
+
+  return {
+    next ({ signal } = {}) {
+      if (closed) return Promise.reject(new Error('Signal subscription is closed'))
+      signal?.throwIfAborted()
+      subscribe()
+      if (queued.length) return Promise.resolve(queued.shift())
+      return new Promise((resolve, reject) => {
+        const abort = () => {
+          const index = waiters.indexOf(waiter)
+          if (index !== -1) waiters.splice(index, 1)
+          waiter.reject(signal.reason)
+        }
+        const finish = callback => value => {
+          signal?.removeEventListener('abort', abort)
+          callback(value)
+        }
+        const waiter = { resolve: finish(resolve), reject: finish(reject) }
+        waiters.push(waiter)
+        signal?.addEventListener('abort', abort, { once: true })
+      })
+    },
+    close () {
+      closed = true
+      for (const [signal, listener] of handlers ?? []) source.off(signal, listener)
+      for (const waiter of waiters.splice(0)) waiter.reject(new Error('Signal subscription is closed'))
+      queued.length = 0
+    },
+  }
+}

package/dist/wasm/host/terminal-input.mjs

@@ -0,0 +1,7 @@
+const activeInputs = new WeakSet()
+
+export function claimTerminalInput (input) {
+  if (activeInputs.has(input)) throw new Error('A terminal prompt is already active')
+  activeInputs.add(input)
+  return () => activeInputs.delete(input)
+}

package/dist/wasm/host/terminal-password.mjs

@@ -0,0 +1,32 @@
+import { createResources } from './resources.mjs'
+import { openTerminal, writeTerminal } from './terminal-session.mjs'
+
+export async function password (options, context = {}) {
+  if (typeof options.message !== 'string') throw new TypeError('Password prompt message must be a string')
+  context.signal?.throwIfAborted()
+  const resources = createResources()
+  try {
+    const { handle } = await openTerminal(resources, { ...context, output: context.output ?? process.stderr, maxQueuedKeys: 65536 })
+    const session = resources.get(handle, 'terminal')
+    await writeTerminal(session, `${options.message}: `)
+    return await readPassword(session, options.allowEmpty, context.signal)
+  } finally {
+    await resources.closeAll()
+  }
+}
+
+async function readPassword (session, allowEmpty, signal) {
+  const characters = []
+  while (true) {
+    // eslint-disable-next-line no-await-in-loop -- input must be consumed in key order
+    const key = await session.read(signal)
+    if (['ctrl-c', 'escape', 'eof'].includes(key.name)) throw Object.assign(new Error('Password input cancelled'), { code: 'EINTR' })
+    if (key.name === 'enter' && (allowEmpty || characters.length)) {
+      await writeTerminal(session, '\n') // eslint-disable-line no-await-in-loop -- newline is emitted only after accepting the complete password
+      return characters.join('')
+    }
+    if (key.name === 'backspace' || key.name === 'delete') characters.pop()
+    else if (key.character && Array.from(key.character).every(character => character >= ' ' && character !== '\x7f')) characters.push(key.character)
+    if (characters.length > 65536) throw new Error('Password input exceeds the terminal limit')
+  }
+}

package/dist/wasm/host/terminal-session.mjs

@@ -0,0 +1,114 @@
+import { emitKeypressEvents } from 'node:readline'
+import { PassThrough } from 'node:stream'
+
+import { claimTerminalInput } from './terminal-input.mjs'
+
+export async function openTerminal (resources, { input = process.stdin, output = selectOutput(), maxQueuedKeys = 128 } = {}) {
+  if (!input.isTTY || !output?.isTTY || typeof input.setRawMode !== 'function') {
+    throw Object.assign(new Error('Interactive terminal input is unavailable'), { code: 'ENOTTY' })
+  }
+  const release = claimTerminalInput(input)
+  let session
+  try {
+    session = createSession(input, output, { release, maxQueuedKeys })
+    return { handle: resources.add(session), rows: output.rows ?? null, columns: output.columns ?? null }
+  } catch (error) {
+    await session?.close()
+    release()
+    throw error
+  }
+}
+
+export function writeTerminal (session, text) {
+  if (typeof text !== 'string' || text.length > 65536) throw new TypeError('Invalid terminal output')
+  return new Promise((resolve, reject) => {
+    session.output.write(text, error => error ? reject(error) : resolve(null))
+  })
+}
+
+function createSession (input, output, { release, maxQueuedKeys }) {
+  const keys = new PassThrough()
+  const state = { queue: [], pending: null, error: null, closed: false, maxQueuedKeys }
+  const wasRaw = Boolean(input.isRaw)
+  const wasFlowing = input.readableFlowing === true
+  const onData = chunk => keys.write(chunk)
+  const onError = error => fail(state, error)
+  const onEnd = () => fail(state, Object.assign(new Error('Terminal input closed'), { code: 'EINTR' }))
+  emitKeypressEvents(keys)
+  keys.on('keypress', (character, key) => receiveKey(state, decodeKey(character, key)))
+  input.setRawMode(true)
+  input.on('data', onData).on('error', onError).on('end', onEnd)
+  output.on('error', onError)
+  input.resume()
+  return {
+    kind: 'terminal', output,
+    read: signal => readKey(state, signal),
+    async close () {
+      if (state.closed) return
+      state.closed = true
+      fail(state, new Error('Terminal session closed'))
+      input.off('data', onData).off('error', onError).off('end', onEnd)
+      keys.destroy()
+      try {
+        try {
+          input.setRawMode(wasRaw)
+        } finally {
+          if (!wasFlowing) input.pause()
+          release()
+        }
+        await writeTerminal({ output }, '\x1b[?25h')
+      } finally {
+        output.off('error', onError)
+      }
+    },
+  }
+}
+
+function readKey (state, signal) {
+  signal?.throwIfAborted()
+  if (state.error) return Promise.reject(state.error)
+  if (state.pending) throw new Error('A terminal key read is already pending')
+  if (state.queue.length) return Promise.resolve(state.queue.shift())
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      state.pending = null
+      reject(signal.reason)
+    }
+    state.pending = {
+      resolve: key => { signal?.removeEventListener('abort', abort); resolve(key) },
+      reject: error => { signal?.removeEventListener('abort', abort); reject(error) },
+    }
+    signal?.addEventListener('abort', abort, { once: true })
+  })
+}
+
+function receiveKey (state, key) {
+  if (state.closed || state.error) return
+  if (state.pending) {
+    const pending = state.pending
+    state.pending = null
+    pending.resolve(key)
+  } else if (state.queue.length < state.maxQueuedKeys) state.queue.push(key)
+  else fail(state, new Error(`Terminal input queue exceeded ${state.maxQueuedKeys} keys`))
+}
+
+function fail (state, error) {
+  state.error ??= error
+  state.queue.length = 0
+  state.pending?.reject(state.error)
+  state.pending = null
+}
+
+function decodeKey (character, key) {
+  if (key.ctrl && key.name === 'c') return { name: 'ctrl-c' }
+  if (key.ctrl && key.name === 'd') return { name: 'eof' }
+  if (['escape', 'backspace', 'delete', 'left', 'right', 'home', 'end'].includes(key.name)) return { name: key.name }
+  if (key.name === 'tab') return { name: key.shift ? 'backtab' : 'tab' }
+  if (['return', 'enter'].includes(key.name)) return { name: 'enter' }
+  if (['up', 'down'].includes(key.name)) return { name: key.name }
+  return { name: 'other', ...(!key.ctrl && !key.meta && character ? { character } : {}) }
+}
+
+function selectOutput () {
+  return process.stdout.isTTY ? process.stdout : process.stderr
+}

package/dist/wasm/host/terminal.mjs

@@ -0,0 +1,61 @@
+import { createInterface } from 'node:readline'
+
+import { claimTerminalInput } from './terminal-input.mjs'
+
+export async function prompt (options, { signal, input = process.stdin, output = process.stderr } = {}) {
+  if (typeof options.message !== 'string') throw new TypeError('Terminal prompt message must be a string')
+  signal?.throwIfAborted()
+  const release = claimTerminalInput(input)
+  let terminal
+  let abort
+  let keypress
+  try {
+    terminal = createInterface({ input, output, terminal: Boolean(input.isTTY && output.isTTY) })
+    return await new Promise((resolve, reject) => {
+      abort = () => reject(signal.reason)
+      signal?.addEventListener('abort', abort, { once: true })
+      terminal.once('SIGINT', () => resolve({ cancelled: true }))
+      keypress = (_text, key) => {
+        if (options.cancelOnEscape && key?.name === 'escape') resolve({ cancelled: true })
+      }
+      input.on('keypress', keypress)
+      terminal.once('close', () => resolve({ value: null }))
+      terminal.once('error', reject)
+      terminal.question(`${options.message}: `, value => resolve({ value }))
+    })
+  } finally {
+    signal?.removeEventListener('abort', abort)
+    if (keypress) input.off('keypress', keypress)
+    terminal?.close()
+    release()
+  }
+}
+
+export async function confirm (options, context = {}) {
+  const input = context.input ?? process.stdin
+  const output = context.output ?? process.stderr
+  if (!input.isTTY || !output.isTTY) throw Object.assign(new Error('Confirmation requires an interactive terminal'), { code: 'ENOTTY' })
+  if (options.default != null && typeof options.default !== 'boolean') throw new TypeError('Confirmation default must be a boolean')
+  const suffix = options.default == null ? '(y/n)' : options.default ? '(Y/n)' : '(y/N)'
+  while (true) {
+    // eslint-disable-next-line no-await-in-loop -- each answer determines whether another prompt is needed
+    const answer = await prompt({ message: `${options.message} ${suffix}`, cancelOnEscape: true }, { ...context, input, output })
+    if (answer.cancelled || answer.value == null) throw Object.assign(new Error('Confirmation cancelled'), { code: 'EINTR' })
+    const value = answer.value.trim().toLowerCase()
+    if (value === 'y' || value === 'yes') return true
+    if (value === 'n' || value === 'no') return false
+    if (value === '' && options.default != null) return options.default
+  }
+}
+
+export async function input (options, context = {}) {
+  if (!(context.input ?? process.stdin).isTTY || !(context.output ?? process.stderr).isTTY) {
+    throw Object.assign(new Error('Input requires an interactive terminal'), { code: 'ENOTTY' })
+  }
+  while (true) {
+    // eslint-disable-next-line no-await-in-loop -- empty input must be retried when the caller requires a value
+    const answer = await prompt({ message: options.message, cancelOnEscape: true }, context)
+    if (answer.cancelled || answer.value == null) throw Object.assign(new Error('Input cancelled'), { code: 'EINTR' })
+    if (options.allowEmpty || answer.value !== '') return answer.value
+  }
+}

package/dist/wasm/host/thread-spawn.mjs

@@ -0,0 +1,21 @@
+import { waitForReply } from './wait-for-reply.mjs'
+
+// Keep the upstream supervisor's spawn protocol while making the child wait interruptible.
+export function createThreadSpawn (memory, postMessage, options) {
+  return (startArg, errorOrTid) => {
+    const ownsResult = errorOrTid === undefined
+    const exports = options.instance().exports
+    if (ownsResult) errorOrTid = exports.malloc(8) >>> 0
+    if (ownsResult && !errorOrTid) return -48
+    const result = new Int32Array(memory.buffer, errorOrTid, 2)
+    Atomics.store(result, 0, 0)
+    Atomics.store(result, 1, 0)
+    postMessage({ __emnapi__: { type: 'spawn-thread', payload: { startArg, errorOrTid } } })
+    waitForReply(result, 1, options.checkCancelled)
+    const failed = Atomics.load(result, 0)
+    const thread = Atomics.load(result, 1)
+    if (!ownsResult) return failed
+    exports.free(errorOrTid)
+    return failed ? -thread : thread
+  }
+}

package/dist/wasm/host/upload.mjs

@@ -0,0 +1,21 @@
+export function createUpload (resources) {
+  let controller
+  const stream = new TransformStream({ start (value) { controller = value } }, { highWaterMark: 1 }, { highWaterMark: 1 })
+  const writer = stream.writable.getWriter()
+  return { handle: resources.add({
+    kind: 'upload',
+    readable: stream.readable,
+    writer,
+    close: () => controller.error(new Error('HTTP upload cancelled')),
+  }) }
+}
+
+export async function writeUpload (upload, bytes) {
+  if (Array.isArray(bytes) && bytes.every(byte => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+    bytes = Uint8Array.from(bytes)
+  }
+  if (!(bytes instanceof Uint8Array) || bytes.length > 65536) {
+    throw new TypeError('HTTP upload chunks must contain at most 65536 bytes')
+  }
+  await upload.writer.write(bytes)
+}

package/dist/wasm/host/wait-for-reply.mjs

@@ -0,0 +1,7 @@
+// WebContainers cannot interrupt a worker parked in an indefinite Atomics.wait.
+export function waitForReply (state, index, checkCancelled) {
+  while (Atomics.load(state, index) === 0) {
+    checkCancelled?.()
+    Atomics.wait(state, index, 0, 100)
+  }
+}

package/dist/wasm/host/wasi-errno.mjs

@@ -0,0 +1,81 @@
+// WASI preview1 errno numbers, shared by filesystem extensions and syscall RPC.
+export const errno = {
+  E2BIG: 1,
+  EACCES: 2,
+  EADDRINUSE: 3,
+  EADDRNOTAVAIL: 4,
+  EAFNOSUPPORT: 5,
+  EAGAIN: 6,
+  EALREADY: 7,
+  EBADF: 8,
+  EBADMSG: 9,
+  EBUSY: 10,
+  ECANCELED: 11,
+  ECHILD: 12,
+  ECONNABORTED: 13,
+  ECONNREFUSED: 14,
+  ECONNRESET: 15,
+  EDEADLK: 16,
+  EDESTADDRREQ: 17,
+  EDOM: 18,
+  EDQUOT: 19,
+  EEXIST: 20,
+  EFAULT: 21,
+  EFBIG: 22,
+  EHOSTUNREACH: 23,
+  EIDRM: 24,
+  EILSEQ: 25,
+  EINPROGRESS: 26,
+  EINTR: 27,
+  EINVAL: 28,
+  EIO: 29,
+  EISCONN: 30,
+  EISDIR: 31,
+  ELOOP: 32,
+  EMFILE: 33,
+  EMLINK: 34,
+  EMSGSIZE: 35,
+  EMULTIHOP: 36,
+  ENAMETOOLONG: 37,
+  ENETDOWN: 38,
+  ENETRESET: 39,
+  ENETUNREACH: 40,
+  ENFILE: 41,
+  ENOBUFS: 42,
+  ENODEV: 43,
+  ENOENT: 44,
+  ENOEXEC: 45,
+  ENOLCK: 46,
+  ENOLINK: 47,
+  ENOMEM: 48,
+  ENOMSG: 49,
+  ENOPROTOOPT: 50,
+  ENOSPC: 51,
+  ENOSYS: 52,
+  ENOTCONN: 53,
+  ENOTDIR: 54,
+  ENOTEMPTY: 55,
+  ENOTRECOVERABLE: 56,
+  ENOTSOCK: 57,
+  ENOTSUP: 58,
+  ENOTTY: 59,
+  ENXIO: 60,
+  EOVERFLOW: 61,
+  EOWNERDEAD: 62,
+  EPERM: 63,
+  EPIPE: 64,
+  EPROTO: 65,
+  EPROTONOSUPPORT: 66,
+  EPROTOTYPE: 67,
+  ERANGE: 68,
+  EROFS: 69,
+  ESPIPE: 70,
+  ESRCH: 71,
+  ESTALE: 72,
+  ETIMEDOUT: 73,
+  ETXTBSY: 74,
+  EXDEV: 75,
+  ENOTCAPABLE: 76,
+  EOPNOTSUPP: 58,
+  EWOULDBLOCK: 6,
+}