@socketsecurity/cli-with-sentry 1.0.79 → 1.0.80

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

@@ -2,50 +2,11 @@
 
 const { freeze: ObjectFreeze } = Object
 
-const { getGlobMatcher } = /*@__PURE__*/ require('./globs')
+const { defaultIgnore, getGlobMatcher } = /*@__PURE__*/ require('./globs')
 const { naturalCompare } = /*@__PURE__*/ require('./sorts')
+const { pathLikeToString } = /*@__PURE__*/ require('./path')
 const { stripBom } = /*@__PURE__*/ require('./strings')
 
-const defaultIgnore = ObjectFreeze([
-  // Most of these ignored files can be included specifically if included in the
-  // files globs. Exceptions to this are:
-  // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
-  // These can NOT be included.
-  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L280
-  '**/.git',
-  '**/.npmrc',
-  // '**/bun.lockb?',
-  // '**/node_modules',
-  // '**/package-lock.json',
-  // '**/pnpm-lock.ya?ml',
-  // '**/yarn.lock',
-  // Include npm-packlist defaults:
-  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L15-L38
-  '**/.DS_Store',
-  '**/.gitignore',
-  '**/.hg',
-  '**/.lock-wscript',
-  '**/.npmignore',
-  '**/.svn',
-  '**/.wafpickle-*',
-  '**/.*.swp',
-  '**/._*/**',
-  '**/archived-packages/**',
-  '**/build/config.gypi',
-  '**/CVS',
-  '**/npm-debug.log',
-  '**/*.orig',
-  // Inline generic .gitignore entries from the socket-registry repository root.
-  '**/.env',
-  '**/.eslintcache',
-  '**/.nvm',
-  '**/.tap',
-  '**/.tapci.yaml',
-  '**/.vscode',
-  '**/*.tsbuildinfo',
-  '**/Thumbs.db'
-])
-
 const defaultRemoveOptions = ObjectFreeze({
   __proto__: null,
   force: true,
@@ -95,6 +56,12 @@ function innerReadDirNames(dirents, options) {
   return sort ? names.sort(naturalCompare) : names
 }
 
+/*@__NO_SIDE_EFFECTS__*/
+function isDirSync(filepath) {
+  const fs = getFs()
+  return fs.existsSync(filepath) && !!safeStatsSync(filepath)?.isDirectory()
+}
+
 /*@__NO_SIDE_EFFECTS__*/
 function isDirEmptySync(dirname, options) {
   const { ignore = defaultIgnore } = { __proto__: null, ...options }
@@ -105,7 +72,7 @@ function isDirEmptySync(dirname, options) {
     if (length === 0) {
       return true
     }
-    const matcher = getGlobMatcher(ignore, { cwd: dirname })
+    const matcher = getGlobMatcher(ignore, { cwd: pathLikeToString(dirname) })
     let ignoredCount = 0
     for (let i = 0; i < length; i += 1) {
       if (matcher(files[i])) {
@@ -119,7 +86,7 @@ function isDirEmptySync(dirname, options) {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function isSymbolicLinkSync(filepath) {
+function isSymLinkSync(filepath) {
   const fs = getFs()
   try {
     return fs.lstatSync(filepath).isSymbolicLink()
@@ -129,9 +96,9 @@ function isSymbolicLinkSync(filepath) {
 
 /*@__NO_SIDE_EFFECTS__*/
 function parse(filepath, content, reviver, shouldThrow) {
-  const str = Buffer.isBuffer(content) ? content.toString('utf8') : content
+  const jsonStr = Buffer.isBuffer(content) ? content.toString('utf8') : content
   try {
-    return JSON.parse(stripBom(str), reviver)
+    return JSON.parse(stripBom(jsonStr), reviver)
   } catch (e) {
     if (shouldThrow) {
       if (e) {
@@ -148,7 +115,10 @@ async function readDirNames(dirname, options) {
   const fs = getFs()
   try {
     return innerReadDirNames(
-      await fs.promises.readdir(dirname, { withFileTypes: true }),
+      await fs.promises.readdir(dirname, {
+        __proto__: null,
+        withFileTypes: true
+      }),
       options
     )
   } catch {}
@@ -160,29 +130,48 @@ function readDirNamesSync(dirname, options) {
   const fs = getFs()
   try {
     return innerReadDirNames(
-      fs.readdirSync(dirname, { withFileTypes: true }),
+      fs.readdirSync(dirname, { __proto__: null, withFileTypes: true }),
       options
     )
   } catch {}
   return []
 }
 
+/*@__NO_SIDE_EFFECTS__*/
+async function readFileBinary(filepath, options) {
+  const fs = getFs()
+  return await fs.promises.readFile(filepath, {
+    signal: /*@__PURE__*/ require('./constants/abort-signal'),
+    ...options,
+    encoding: 'binary'
+  })
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+async function readFileUtf8(filepath, options) {
+  const fs = getFs()
+  return await fs.promises.readFile(filepath, {
+    signal: /*@__PURE__*/ require('./constants/abort-signal'),
+    ...options,
+    encoding: 'utf8'
+  })
+}
+
 /*@__NO_SIDE_EFFECTS__*/
 async function readJson(filepath, options) {
   if (typeof options === 'string') {
     options = { encoding: options }
   }
-  const { reviver, throws, ...fsOptionsRaw } = { __proto__: null, ...options }
-  const fsOptions = {
-    __proto__: null,
-    encoding: 'utf8',
-    ...fsOptionsRaw
-  }
+  const { reviver, throws, ...fsOptions } = { __proto__: null, ...options }
   const fs = getFs()
   const shouldThrow = throws === undefined || !!throws
   return parse(
     filepath,
-    await fs.promises.readFile(filepath, fsOptions),
+    await fs.promises.readFile(filepath, {
+      __proto__: null,
+      encoding: 'utf8',
+      ...fsOptions
+    }),
     reviver,
     shouldThrow
   )
@@ -193,17 +182,16 @@ function readJsonSync(filepath, options) {
   if (typeof options === 'string') {
     options = { encoding: options }
   }
-  const { reviver, throws, ...fsOptionsRaw } = { __proto__: null, ...options }
-  const fsOptions = {
-    __proto__: null,
-    encoding: 'utf8',
-    ...fsOptionsRaw
-  }
+  const { reviver, throws, ...fsOptions } = { __proto__: null, ...options }
   const fs = getFs()
   const shouldThrow = throws === undefined || !!throws
   return parse(
     filepath,
-    fs.readFileSync(filepath, fsOptions),
+    fs.readFileSync(filepath, {
+      __proto__: null,
+      encoding: 'utf8',
+      ...fsOptions
+    }),
     reviver,
     shouldThrow
   )
@@ -231,6 +219,45 @@ function removeSync(filepath, options) {
   })
 }
 
+/*@__NO_SIDE_EFFECTS__*/
+async function safeReadFile(filepath, options) {
+  const fs = getFs()
+  try {
+    return await fs.promises.readFile(filepath, {
+      encoding: 'utf8',
+      signal: /*@__PURE__*/ require('./constants/abort-signal'),
+      ...(typeof options === 'string' ? { encoding: options } : options)
+    })
+  } catch {}
+  return undefined
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function safeStatsSync(filepath, options) {
+  const fs = getFs()
+  try {
+    return fs.statSync(filepath, {
+      __proto__: null,
+      throwIfNoEntry: false,
+      ...options
+    })
+  } catch {}
+  return undefined
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function safeReadFileSync(filepath, options) {
+  const fs = getFs()
+  try {
+    return fs.readFileSync(filepath, {
+      __proto__: null,
+      encoding: 'utf8',
+      ...(typeof options === 'string' ? { encoding: options } : options)
+    })
+  } catch {}
+  return undefined
+}
+
 /*@__NO_SIDE_EFFECTS__*/
 function stringify(
   json,
@@ -257,52 +284,56 @@ function uniqueSync(filepath) {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-async function writeJson(filepath, json, options) {
+async function writeJson(filepath, jsonContent, options) {
   if (typeof options === 'string') {
     options = { encoding: options }
   }
-  const { EOL, finalEOL, replacer, spaces, ...fsOptionsRaw } = {
+  const { EOL, finalEOL, replacer, spaces, ...fsOptions } = {
     __proto__: null,
     ...options
   }
-  const fsOptions = {
+  const fs = getFs()
+  const jsonString = stringify(jsonContent, EOL, finalEOL, replacer, spaces)
+  await fs.promises.writeFile(filepath, jsonString, {
     __proto__: null,
     encoding: 'utf8',
-    ...fsOptionsRaw
-  }
-  const fs = getFs()
-  const str = stringify(json, EOL, finalEOL, replacer, spaces)
-  await fs.promises.writeFile(filepath, str, fsOptions)
+    ...fsOptions
+  })
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function writeJsonSync(filepath, json, options) {
+function writeJsonSync(filepath, jsonContent, options) {
   if (typeof options === 'string') {
     options = { encoding: options }
   }
-  const { EOL, finalEOL, replacer, spaces, ...fsOptionsRaw } = {
+  const { EOL, finalEOL, replacer, spaces, ...fsOptions } = {
     __proto__: null,
     ...options
   }
-  const fsOptions = {
+  const fs = getFs()
+  const jsonString = stringify(jsonContent, EOL, finalEOL, replacer, spaces)
+  fs.writeFileSync(filepath, jsonString, {
     __proto__: null,
     encoding: 'utf8',
-    ...fsOptionsRaw
-  }
-  const fs = getFs()
-  const str = stringify(json, EOL, finalEOL, replacer, spaces)
-  fs.writeFileSync(filepath, str, fsOptions)
+    ...fsOptions
+  })
 }
 
 module.exports = {
+  isDirSync,
   isDirEmptySync,
-  isSymbolicLinkSync,
+  isSymLinkSync,
+  readFileBinary,
+  readFileUtf8,
   readJson,
   readJsonSync,
   readDirNames,
   readDirNamesSync,
   remove,
   removeSync,
+  safeReadFile,
+  safeReadFileSync,
+  safeStatsSync,
   uniqueSync,
   writeJson,
   writeJsonSync

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

@@ -1,5 +1,49 @@
 'use strict'
 
+const { freeze: ObjectFreeze } = Object
+
+const defaultIgnore = ObjectFreeze([
+  // Most of these ignored files can be included specifically if included in the
+  // files globs. Exceptions to this are:
+  // https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files
+  // These can NOT be included.
+  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L280
+  '**/.git',
+  '**/.npmrc',
+  // '**/bun.lockb?',
+  '**/node_modules',
+  // '**/package-lock.json',
+  // '**/pnpm-lock.ya?ml',
+  // '**/yarn.lock',
+  // Include npm-packlist defaults:
+  // https://github.com/npm/npm-packlist/blob/v10.0.0/lib/index.js#L15-L38
+  '**/.DS_Store',
+  '**/.gitignore',
+  '**/.hg',
+  '**/.lock-wscript',
+  '**/.npmignore',
+  '**/.svn',
+  '**/.wafpickle-*',
+  '**/.*.swp',
+  '**/._*/**',
+  '**/archived-packages/**',
+  '**/build/config.gypi',
+  '**/CVS',
+  '**/npm-debug.log',
+  '**/*.orig',
+  // Inline generic socket-registry .gitignore entries.
+  '**/.env',
+  '**/.eslintcache',
+  '**/.nvm',
+  '**/.tap',
+  '**/.tapci.yaml',
+  '**/.vscode',
+  '**/*.tsbuildinfo',
+  '**/Thumbs.db',
+  // Inline additional ignores.
+  '**/bower_components'
+])
+
 let _picomatch
 /*@__NO_SIDE_EFFECTS__*/
 function getPicomatch() {
@@ -28,7 +72,7 @@ function globStreamLicenses(dirname, options) {
     ...globOptions
   } = { __proto__: null, ...options }
   const ignore = [
-    ...(Array.isArray(ignoreOpt) ? ignoreOpt : []),
+    ...(Array.isArray(ignoreOpt) ? ignoreOpt : defaultIgnore),
     '**/*.{cjs,cts,js,json,mjs,mts,ts}'
   ]
   if (ignoreOriginals) {
@@ -74,6 +118,7 @@ function getGlobMatcher(glob, options) {
 }
 
 module.exports = {
+  defaultIgnore,
   getGlobMatcher,
   globStreamLicenses
 }

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

@@ -6,13 +6,37 @@ const leadingDotSlashRegExp = /^\.\.?[/\\]/
 const slashRegExp = /[/\\]/
 const nodeModulesPathRegExp = /(?:^|[/\\])node_modules(?:[/\\]|$)/
 
+let _buffer
 /*@__NO_SIDE_EFFECTS__*/
-function isNodeModules(filepath) {
+function getBuffer() {
+  if (_buffer === undefined) {
+    // Use non-'node:' prefixed require to avoid Webpack errors.
+    // eslint-disable-next-line n/prefer-node-protocol
+    _buffer = /*@__PURE__*/ require('buffer')
+  }
+  return _buffer
+}
+
+let _url
+/*@__NO_SIDE_EFFECTS__*/
+function getUrl() {
+  if (_url === undefined) {
+    // Use non-'node:' prefixed require to avoid Webpack errors.
+    // eslint-disable-next-line n/prefer-node-protocol
+    _url = /*@__PURE__*/ require('url')
+  }
+  return _url
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function isNodeModules(pathLike) {
+  const filepath = pathLikeToString(pathLike)
   return nodeModulesPathRegExp.test(filepath)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function isRelative(filepath) {
+function isRelative(pathLike) {
+  const filepath = pathLikeToString(pathLike)
   if (typeof filepath !== 'string') {
     return false
   }
@@ -34,12 +58,13 @@ function isRelative(filepath) {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function normalizePath(filePath) {
-  const { length } = filePath
+function normalizePath(pathLike) {
+  const filepath = pathLikeToString(pathLike)
+  const { length } = filepath
   if (length < 2) {
-    return length === 1 && filePath.charCodeAt(0) === 92 /*'\\'*/
+    return length === 1 && filepath.charCodeAt(0) === 92 /*'\\'*/
       ? '/'
-      : filePath
+      : filepath
   }
 
   let code = 0
@@ -53,13 +78,13 @@ function normalizePath(filePath) {
   // are okay to convert to forward slashes.
   // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
   let prefix = ''
-  if (length > 4 && filePath.charCodeAt(3) === 92 /*'\\'*/) {
-    const code2 = filePath.charCodeAt(2)
+  if (length > 4 && filepath.charCodeAt(3) === 92 /*'\\'*/) {
+    const code2 = filepath.charCodeAt(2)
     // Look for \\?\ or \\.\
     if (
       (code2 === 63 /*'?'*/ || code2 === 46) /*'.'*/ &&
-      filePath.charCodeAt(0) === 92 /*'\\'*/ &&
-      filePath.charCodeAt(1) === 92 /*'\\'*/
+      filepath.charCodeAt(0) === 92 /*'\\'*/ &&
+      filepath.charCodeAt(1) === 92 /*'\\'*/
     ) {
       start = 2
       prefix = '//'
@@ -68,7 +93,7 @@ function normalizePath(filePath) {
   if (start === 0) {
     // Trim leading slashes
     while (
-      ((code = filePath.charCodeAt(start)),
+      ((code = filepath.charCodeAt(start)),
       code === 47 /*'/'*/ || code === 92) /*'\\'*/
     ) {
       start += 1
@@ -77,24 +102,24 @@ function normalizePath(filePath) {
       prefix = '/'
     }
   }
-  let nextIndex = search(filePath, slashRegExp, start)
+  let nextIndex = search(filepath, slashRegExp, start)
   if (nextIndex === -1) {
-    return prefix + filePath.slice(start)
+    return prefix + filepath.slice(start)
   }
   // Discard any empty string segments by collapsing repeated segment separator slashes.
   while (nextIndex !== -1) {
-    const segment = filePath.slice(start, nextIndex)
+    const segment = filepath.slice(start, nextIndex)
     collapsed = collapsed + (collapsed.length === 0 ? '' : '/') + segment
     start = nextIndex + 1
     while (
-      ((code = filePath.charCodeAt(start)),
+      ((code = filepath.charCodeAt(start)),
       code === 47 /*'/'*/ || code === 92) /*'\\'*/
     ) {
       start += 1
     }
-    nextIndex = search(filePath, slashRegExp, start)
+    nextIndex = search(filepath, slashRegExp, start)
   }
-  const lastSegment = filePath.slice(start)
+  const lastSegment = filepath.slice(start)
   if (lastSegment.length !== 0) {
     collapsed = collapsed + '/' + lastSegment
   }
@@ -102,12 +127,30 @@ function normalizePath(filePath) {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function splitPath(filepath) {
+function pathLikeToString(pathLike) {
+  if (typeof pathLike === 'string') {
+    return pathLike
+  }
+  const Buffer = getBuffer()
+  if (Buffer.isBuffer(pathLike)) {
+    return pathLike.toString('utf8')
+  }
+  const url = getUrl()
+  if (pathLike instanceof URL) {
+    return url.fileURLToPath(pathLike)
+  }
+  return String(pathLike)
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function splitPath(pathLike) {
+  const filepath = pathLikeToString(pathLike)
   return filepath.split(slashRegExp)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function trimLeadingDotSlash(filepath) {
+function trimLeadingDotSlash(pathLike) {
+  const filepath = pathLikeToString(pathLike)
   return filepath.replace(leadingDotSlashRegExp, '')
 }
 
@@ -115,6 +158,7 @@ module.exports = {
   isNodeModules,
   isRelative,
   normalizePath,
+  pathLikeToString,
   splitPath,
   trimLeadingDotSlash
 }

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

@@ -13,6 +13,25 @@ function getTimers() {
   return _timers
 }
 
+/*@__NO_SIDE_EFFECTS__*/
+function normalizeIterationOptions(options) {
+  const {
+    // The number of concurrent executions performed at one time.
+    concurrency = 1,
+    // Retries as a number or options object.
+    retries,
+    // AbortSignal used to support cancellation.
+    signal = /*@__PURE__*/ require('./constants/abort-signal')
+  } = { __proto__: null, ...options }
+  const retryOpts = resolveRetryOptions(retries)
+  return {
+    __proto__: null,
+    concurrency,
+    retries: normalizeRetryOptions({ signal, ...retryOpts }),
+    signal
+  }
+}
+
 /*@__NO_SIDE_EFFECTS__*/
 function normalizeRetryOptions(options) {
   const {
@@ -62,23 +81,31 @@ function resolveRetryOptions(options) {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-async function pEach(array, concurrency, callbackFn, options) {
-  await pEachChunk(arrayChunk(array, concurrency), callbackFn, options)
+async function pEach(array, callbackFn, options) {
+  const iterOpts = normalizeIterationOptions(options)
+  await pEachChunk(
+    arrayChunk(array, iterOpts.concurrency),
+    callbackFn,
+    iterOpts.retries
+  )
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-async function pFilter(array, concurrency, callbackFn, options) {
+async function pFilter(array, callbackFn, options) {
+  const iterOpts = normalizeIterationOptions(options)
   return (
-    await pFilterChunk(arrayChunk(array, concurrency), callbackFn, options)
+    await pFilterChunk(
+      arrayChunk(array, iterOpts.concurrency),
+      callbackFn,
+      iterOpts.retries
+    )
   ).flat()
 }
 
 /*@__NO_SIDE_EFFECTS__*/
 async function pEachChunk(chunks, callbackFn, options) {
-  const {
-    retries,
-    signal = /*@__PURE__*/ require('./constants/abort-signal')
-  } = { __proto__: null, ...options }
+  const retryOpts = normalizeRetryOptions(options)
+  const { signal } = retryOpts
   for (const chunk of chunks) {
     if (signal?.aborted) {
       return
@@ -87,8 +114,7 @@ async function pEachChunk(chunks, callbackFn, options) {
     await Promise.all(
       chunk.map(value =>
         pRetry(callbackFn, {
-          signal,
-          ...resolveRetryOptions(retries),
+          ...retryOpts,
           args: [value]
         })
       )
@@ -98,10 +124,8 @@ async function pEachChunk(chunks, callbackFn, options) {
 
 /*@__NO_SIDE_EFFECTS__*/
 async function pFilterChunk(chunks, callbackFn, options) {
-  const {
-    retries,
-    signal = /*@__PURE__*/ require('./constants/abort-signal')
-  } = { __proto__: null, ...options }
+  const retryOpts = normalizeRetryOptions(options)
+  const { signal } = retryOpts
   const { length } = chunks
   const filteredChunks = Array(length)
   for (let i = 0; i < length; i += 1) {
@@ -114,8 +138,7 @@ async function pFilterChunk(chunks, callbackFn, options) {
       const predicateResults = await Promise.all(
         chunk.map(value =>
           pRetry(callbackFn, {
-            signal,
-            ...resolveRetryOptions(retries),
+            ...retryOpts,
             args: [value]
           })
         )
@@ -197,9 +220,12 @@ async function pRetry(callbackFn, options) {
 }
 
 module.exports = {
+  normalizeIterationOptions,
+  normalizeRetryOptions,
   pEach,
   pEachChunk,
   pFilter,
   pFilterChunk,
-  pRetry
+  pRetry,
+  resolveRetryOptions
 }

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

@@ -1,6 +1,9 @@
 'use strict'
 
-const { apply: ReflectApply } = Reflect
+const {
+  normalizeIterationOptions,
+  pRetry
+} = /*@__PURE__*/ require('./promises')
 
 let _streamingIterables
 /*@__NO_SIDE_EFFECTS__*/
@@ -12,26 +15,44 @@ function getStreamingIterables() {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-async function parallelForEach(concurrency, func, iterable) {
-  for await (const _ of parallelMap(concurrency, func, iterable)) {
+async function parallelEach(iterable, func, options) {
+  for await (const _ of parallelMap(iterable, func, options)) {
     /* empty block */
   }
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function parallelMap(...args) {
+function parallelMap(iterable, func, options) {
   const streamingIterables = getStreamingIterables()
-  return ReflectApply(streamingIterables.parallelMap, undefined, args)
+  const opts = normalizeIterationOptions(options)
+  return streamingIterables.parallelMap(
+    opts.concurrency,
+    item =>
+      pRetry(func, {
+        ...opts.retries,
+        args: [item]
+      }),
+    iterable
+  )
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function transform(...args) {
+function transform(iterable, func, options) {
   const streamingIterables = getStreamingIterables()
-  return ReflectApply(streamingIterables.transform, undefined, args)
+  const opts = normalizeIterationOptions(options)
+  return streamingIterables.transform(
+    opts.concurrency,
+    item =>
+      pRetry(func, {
+        ...opts.retries,
+        args: [item]
+      }),
+    iterable
+  )
 }
 
 module.exports = {
-  parallelForEach,
+  parallelEach,
   parallelMap,
   transform
 }