@socketsecurity/cli-with-sentry 1.1.25 → 2.0.0

package/external/@socketsecurity/registry/lib/spawn.js

@@ -1,252 +0,0 @@
-'use strict'
-
-const { isArray: ArrayIsArray } = Array
-const { hasOwn: ObjectHasOwn, keys: ObjectKeys } = Object
-
-const { getOwn } = /*@__PURE__*/ require('./objects')
-const { stripAnsi } = /*@__PURE__*/ require('./strings')
-
-const windowsScriptExtRegExp = /\.(?:cmd|bat|ps1)$/i
-
-let _child_process
-/**
- * Lazily load the child_process module.
- * @returns {import('child_process')} The Node.js child_process module.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getChildProcess() {
-  if (_child_process === undefined) {
-    // Use non-'node:' prefixed require to avoid Webpack errors.
-    // eslint-disable-next-line n/prefer-node-protocol
-    _child_process = /*@__PURE__*/ require('child_process')
-  }
-  return _child_process
-}
-
-let _npmCliPromiseSpawn
-/**
- * Lazily load the promise-spawn module for async process spawning.
- * @returns {Function} The promise-spawn module.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getNpmcliPromiseSpawn() {
-  if (_npmCliPromiseSpawn === undefined) {
-    _npmCliPromiseSpawn = /*@__PURE__*/ require('../external/@npmcli/promise-spawn')
-  }
-  return _npmCliPromiseSpawn
-}
-
-let _path
-/**
- * Lazily load the path module to avoid Webpack errors.
- * @returns {import('path')} The Node.js path module.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getPath() {
-  if (_path === undefined) {
-    // Use non-'node:' prefixed require to avoid Webpack errors.
-    // eslint-disable-next-line n/prefer-node-protocol
-    _path = /*@__PURE__*/ require('path')
-  }
-  return _path
-}
-
-/**
- * Check if a value is a spawn error.
- * @param {any} value - The value to check.
- * @returns {value is SpawnError} True if the value is a spawn error.
- * @typedef {Object} SpawnError
- * @property {string[]} args - Command arguments.
- * @property {string} cmd - Command that was run.
- * @property {number} code - Exit code.
- * @property {string} name - Error name.
- * @property {string} message - Error message.
- * @property {AbortSignal | null} signal - Abort signal.
- * @property {string} stack - Stack trace.
- * @property {string | Buffer} stderr - Standard error output.
- * @property {string | Buffer} stdout - Standard output.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function isSpawnError(value) {
-  return (
-    value !== null &&
-    typeof value === 'object' &&
-    ObjectHasOwn(value, 'code') &&
-    typeof value.code === 'number' &&
-    ObjectHasOwn(value, 'cmd') &&
-    typeof value.code === 'string' &&
-    ObjectHasOwn(value, 'args') &&
-    ArrayIsArray(value.args)
-  )
-}
-
-/**
- * Check if stdio configuration matches a specific type.
- * @param {string | string[] | readonly string[]} stdio - The stdio configuration.
- * @param {import('child_process').IOType | 'ipc' | Array<import('child_process').IOType | 'ipc'>} type - The type to check.
- * @returns {boolean} True if the stdio matches the type.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function isStdioType(stdio, type) {
-  return (
-    stdio === type ||
-    ((stdio === null || stdio === undefined) && type === 'pipe') ||
-    (ArrayIsArray(stdio) &&
-      stdio.length > 2 &&
-      stdio[0] === type &&
-      stdio[1] === type &&
-      stdio[2] === type)
-  )
-}
-
-/**
- * Strip ANSI escape codes from spawn result stdout and stderr.
- * @param {{ stdout?: string; stderr?: string }} result - The spawn result.
- * @returns {{ stdout?: string; stderr?: string }} The result with ANSI codes stripped.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function stripAnsiFromSpawnResult(result) {
-  const { stderr, stdout } = result
-  if (typeof stdout === 'string') {
-    result.stdout = stripAnsi(stdout)
-  }
-  if (typeof stderr === 'string') {
-    result.stderr = stripAnsi(stderr)
-  }
-  return result
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-/**
- * Spawn a child process with enhanced error handling and output capture.
- * @template {SpawnOptions} O
- * @param {string} cmd - The command to execute.
- * @param {string[] | readonly string[]} [args=[]] - Arguments to pass to the command.
- * @param {O} [options] - Spawn options.
- * @param {Record<any, any>} [extra] - Additional data to include in the result.
- * @returns {SpawnResult<O extends {stdioString: false} ? Buffer : string, typeof extra>} Command result with process handle.
- * @typedef {import('./objects').Remap<import('child_process').SpawnOptions & {spinner?: import('./spinner').Spinner; stdioString?: boolean; stripAnsi?: boolean}>} SpawnOptions
- * @typedef {Promise<SpawnStdioResult> & {process: import('child_process').ChildProcess; stdin: import('stream').Writable | null}} SpawnResult
- * @typedef {{cmd: string; args: string[] | readonly string[]; code: number; signal: AbortSignal | null; stdout: string | Buffer; stderr: string | Buffer}} SpawnStdioResult
- */
-function spawn(cmd, args, options, extra) {
-  // On Windows with shell: true, use just the command name, not the full path.
-  // When shell: true is used, Windows cmd.exe has issues executing full paths to
-  // .cmd/.bat files (e.g., 'C:\...\pnpm.cmd'), often resulting in ENOENT errors.
-  // Using just the command name (e.g., 'pnpm') allows cmd.exe to find it via PATH.
-  // See: https://github.com/nodejs/node/issues/3675
-  // Check for .cmd, .bat, .ps1 extensions that indicate a Windows script.
-  const shell = getOwn(options, 'shell')
-  const WIN32 = /*@__PURE__*/ require('./constants/win32')
-  if (WIN32 && shell && windowsScriptExtRegExp.test(cmd)) {
-    const path = getPath()
-    // Extract just the command name without path and extension.
-    cmd = path.basename(cmd, path.extname(cmd))
-  }
-  const {
-    spinner = /*@__PURE__*/ require('./constants/spinner'),
-    stripAnsi: shouldStripAnsi = true,
-    ...spawnOptions
-  } = { __proto__: null, ...options }
-  const { env, stdio, stdioString = true } = spawnOptions
-  // The stdio option can be a string or an array.
-  // https://nodejs.org/api/child_process.html#optionsstdio
-  const wasSpinning = !!spinner?.isSpinning
-  const shouldStopSpinner =
-    wasSpinning && !isStdioType(stdio, 'ignore') && !isStdioType(stdio, 'pipe')
-  const shouldRestartSpinner = shouldStopSpinner
-  if (shouldStopSpinner) {
-    spinner.stop()
-  }
-  const npmCliPromiseSpawn = getNpmcliPromiseSpawn()
-  let spawnPromise = npmCliPromiseSpawn(
-    cmd,
-    args,
-    {
-      signal: /*@__PURE__*/ require('./constants/abort-signal'),
-      ...spawnOptions,
-      // Node includes inherited properties of options.env when it normalizes
-      // it due to backwards compatibility. However, this is a prototype sink and
-      // undesired behavior so to prevent it we spread options.env onto a fresh
-      // object with a null [[Prototype]].
-      // https://github.com/nodejs/node/blob/v24.0.1/lib/child_process.js#L674-L678
-      env: {
-        __proto__: null,
-        ...process.env,
-        ...env
-      }
-    },
-    extra
-  )
-  const oldSpawnPromise = spawnPromise
-  if (shouldStripAnsi && stdioString) {
-    spawnPromise = spawnPromise.then(stripAnsiFromSpawnResult).catch(error => {
-      throw stripAnsiFromSpawnResult(error)
-    })
-  }
-  if (shouldRestartSpinner) {
-    spawnPromise = spawnPromise.finally(() => {
-      spinner.start()
-    })
-  }
-  for (const key of ObjectKeys(oldSpawnPromise)) {
-    spawnPromise[key] = oldSpawnPromise[key]
-  }
-  return spawnPromise
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-/**
- * Synchronously spawn a child process.
- * @param {string} cmd - The command to execute.
- * @param {string[] | readonly string[]} [args] - Arguments to pass to the command.
- * @param {SpawnSyncOptions} [options] - Spawn options without spinner support.
- * @returns {import('child_process').SpawnSyncReturns<string | Buffer>} Command result.
- * @typedef {Omit<SpawnOptions, 'spinner'>} SpawnSyncOptions
- */
-function spawnSync(cmd, args, options) {
-  // On Windows with shell: true, use just the command name, not the full path.
-  // When shell: true is used, Windows cmd.exe has issues executing full paths to
-  // .cmd/.bat files (e.g., 'C:\...\pnpm.cmd'), often resulting in ENOENT errors.
-  // Using just the command name (e.g., 'pnpm') allows cmd.exe to find it via PATH.
-  // See: https://github.com/nodejs/node/issues/3675
-  // Check for .cmd, .bat, .ps1 extensions that indicate a Windows script.
-  const shell = getOwn(options, 'shell')
-  const WIN32 = /*@__PURE__*/ require('./constants/win32')
-  if (WIN32 && shell && windowsScriptExtRegExp.test(cmd)) {
-    const path = getPath()
-    // Extract just the command name without path and extension.
-    cmd = path.basename(cmd, path.extname(cmd))
-  }
-  const { stripAnsi: shouldStripAnsi = true, ...rawSpawnOptions } = {
-    __proto__: null,
-    ...options
-  }
-  const { stdioString: rawStdioString = true } = rawSpawnOptions
-  const rawEncoding = rawStdioString ? 'utf8' : 'buffer'
-  const spawnOptions = {
-    encoding: rawEncoding,
-    ...rawSpawnOptions
-  }
-  const stdioString = spawnOptions.encoding !== 'buffer'
-  const result = getChildProcess().spawnSync(cmd, args, spawnOptions)
-  if (stdioString) {
-    const { stderr, stdout } = result
-    if (stdout) {
-      result.stdout = stdout.toString().trim()
-    }
-    if (stderr) {
-      result.stderr = stderr.toString().trim()
-    }
-  }
-  return shouldStripAnsi && stdioString
-    ? stripAnsiFromSpawnResult(result)
-    : result
-}
-
-module.exports = {
-  isSpawnError,
-  isStdioType,
-  spawn,
-  spawnSync
-}

package/external/@socketsecurity/registry/lib/spinner.js

@@ -1,205 +0,0 @@
-'use strict'
-
-const { hasOwn } = /*@__PURE__*/ require('./objects')
-
-const ciSpinner = {
-  frames: [''],
-  // The delay argument is converted to a signed 32-bit integer. This effectively
-  // limits delay to 2147483647 ms, roughly 24.8 days, since it's specified as a
-  // signed integer in the IDL.
-  // https://developer.mozilla.org/en-US/docs/Web/API/Window/setInterval?utm_source=chatgpt.com#return_value
-  interval: 2147483647
-}
-
-function desc(value) {
-  return {
-    __proto__: null,
-    configurable: true,
-    value,
-    writable: true
-  }
-}
-
-function normalizeText(value) {
-  return typeof value === 'string' ? value.trimStart() : ''
-}
-
-let _cliSpinners
-/*@__NO_SIDE_EFFECTS__*/
-function getCliSpinners(styleName) {
-  if (_cliSpinners === undefined) {
-    const yoctoFactory = /*@__PURE__*/ require('../external/@socketregistry/yocto-spinner')
-    const { constructor: YoctoCtor } = yoctoFactory()
-    _cliSpinners = YoctoCtor.spinners
-  }
-  if (typeof styleName === 'string') {
-    return hasOwn(_cliSpinners, styleName) ? _cliSpinners[styleName] : undefined
-  }
-  return _cliSpinners
-}
-
-let _Spinner
-let _defaultSpinner
-/*@__NO_SIDE_EFFECTS__*/
-function Spinner(options) {
-  if (_Spinner === undefined) {
-    const ENV = /*@__PURE__*/ require('./constants/env')
-    const abortSignal = /*@__PURE__*/ require('./constants/abort-signal')
-    const { isBlankString } = /*@__PURE__*/ require('./strings')
-    const yoctoFactory = /*@__PURE__*/ require('../external/@socketregistry/yocto-spinner')
-    const { constructor: YoctoCtor } = yoctoFactory()
-
-    /*@__PURE__*/
-    _Spinner = class Spinner extends YoctoCtor {
-      constructor(options) {
-        super({
-          signal: abortSignal,
-          ...options
-        })
-      }
-
-      #apply(methodName, args) {
-        let extras
-        let text = args.at(0)
-        if (typeof text === 'string') {
-          extras = args.slice(1)
-        } else {
-          extras = args
-          text = ''
-        }
-        const wasSpinning = this.isSpinning
-        const normalized = normalizeText(text)
-        super[methodName](normalized)
-        const {
-          incLogCallCountSymbol,
-          lastWasBlankSymbol,
-          logger
-        } = /*@__PURE__*/ require('./logger')
-        if (methodName === 'stop') {
-          if (wasSpinning && normalized) {
-            logger[lastWasBlankSymbol](isBlankString(normalized))
-            logger[incLogCallCountSymbol]()
-          }
-        } else {
-          logger[lastWasBlankSymbol](false)
-          logger[incLogCallCountSymbol]()
-        }
-        if (extras.length) {
-          logger.log(...extras)
-          logger[lastWasBlankSymbol](false)
-        }
-        return this
-      }
-
-      #applyAndKeepSpinning(methodName, args) {
-        const wasSpinning = this.isSpinning
-        this.#apply(methodName, args)
-        if (wasSpinning) {
-          this.start()
-        }
-        return this
-      }
-
-      debug(...args) {
-        const { isDebug } = /*@__PURE__*/ require('./debug')
-        if (isDebug()) {
-          return this.#applyAndKeepSpinning('info', args)
-        }
-        return this
-      }
-
-      debugAndStop(...args) {
-        const { isDebug } = /*@__PURE__*/ require('./debug')
-        if (isDebug()) {
-          return this.#apply('info', args)
-        }
-        return this
-      }
-
-      fail(...args) {
-        return this.#applyAndKeepSpinning('error', args)
-      }
-
-      failAndStop(...args) {
-        return this.#apply('error', args)
-      }
-
-      getText() {
-        return this.text
-      }
-
-      info(...args) {
-        return this.#applyAndKeepSpinning('info', args)
-      }
-
-      infoAndStop(...args) {
-        return this.#apply('info', args)
-      }
-
-      log(...args) {
-        return this.#applyAndKeepSpinning('stop', args)
-      }
-
-      logAndStop(...args) {
-        return this.#apply('stop', args)
-      }
-
-      setText(value) {
-        this.text = normalizeText(value)
-        return this
-      }
-
-      start(...args) {
-        if (args.length) {
-          const text = args.at(0)
-          const normalized = normalizeText(text)
-          // We clear this.text on start when `text` is falsy because yocto-spinner
-          // will not clear it otherwise.
-          if (!normalized) {
-            this.setText('')
-          }
-        }
-        return this.#apply('start', args)
-      }
-
-      stop(...args) {
-        // We clear this.text on stop because yocto-spinner will not clear it.
-        this.setText('')
-        return this.#apply('stop', args)
-      }
-
-      success(...args) {
-        return this.#applyAndKeepSpinning('success', args)
-      }
-
-      successAndStop(...args) {
-        return this.#apply('success', args)
-      }
-
-      warn(...args) {
-        return this.#applyAndKeepSpinning('warning', args)
-      }
-
-      warnAndStop(...args) {
-        return this.#apply('warning', args)
-      }
-    }
-    // Add aliases.
-    Object.defineProperties(_Spinner.prototype, {
-      error: desc(_Spinner.prototype.fail),
-      errorAndStop: desc(_Spinner.prototype.failAndStop),
-      warning: desc(_Spinner.prototype.warn),
-      warningAndStop: desc(_Spinner.prototype.warnAndStop)
-    })
-    _defaultSpinner = ENV.CI ? ciSpinner : undefined
-  }
-  return new _Spinner({
-    spinner: _defaultSpinner,
-    ...options
-  })
-}
-
-module.exports = {
-  getCliSpinners,
-  Spinner
-}

package/external/@socketsecurity/registry/lib/streams.js

@@ -1,84 +0,0 @@
-'use strict'
-
-const {
-  normalizeIterationOptions,
-  pRetry
-} = /*@__PURE__*/ require('./promises')
-
-let _streamingIterables
-/**
- * Get the streaming-iterables module.
- * @returns {Object} The streaming-iterables module.
- * @private
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getStreamingIterables() {
-  if (_streamingIterables === undefined) {
-    _streamingIterables = /*@__PURE__*/ require('../external/streaming-iterables')
-  }
-  return _streamingIterables
-}
-
-/**
- * Execute a function for each item in an iterable in parallel.
- * @param {AsyncIterable} iterable - The async iterable to process.
- * @param {Function} func - Function to execute for each item.
- * @param {Object} [options] - Iteration options including concurrency.
- * @returns {Promise<void>} Resolves when all items are processed.
- */
-/*@__NO_SIDE_EFFECTS__*/
-async function parallelEach(iterable, func, options) {
-  for await (const _ of parallelMap(iterable, func, options)) {
-    /* empty block */
-  }
-}
-
-/**
- * Map over an iterable in parallel with concurrency control.
- * @param {AsyncIterable} iterable - The async iterable to map.
- * @param {Function} func - Mapping function.
- * @param {Object} [options] - Iteration options including concurrency.
- * @returns {AsyncIterable} Async iterable of mapped values.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function parallelMap(iterable, func, options) {
-  const streamingIterables = getStreamingIterables()
-  const opts = normalizeIterationOptions(options)
-  return streamingIterables.parallelMap(
-    opts.concurrency,
-    item =>
-      pRetry(func, {
-        ...opts.retries,
-        args: [item]
-      }),
-    iterable
-  )
-}
-
-/**
- * Transform an iterable with a function.
- * @param {AsyncIterable} iterable - The async iterable to transform.
- * @param {Function} func - Transform function.
- * @param {Object} [options] - Iteration options including concurrency.
- * @returns {AsyncIterable} Transformed async iterable.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function transform(iterable, func, options) {
-  const streamingIterables = getStreamingIterables()
-  const opts = normalizeIterationOptions(options)
-  return streamingIterables.transform(
-    opts.concurrency,
-    item =>
-      pRetry(func, {
-        ...opts.retries,
-        args: [item]
-      }),
-    iterable
-  )
-}
-
-module.exports = {
-  parallelEach,
-  parallelMap,
-  transform
-}