@socketsecurity/cli-with-sentry 1.0.76 → 1.0.78

package/external/@socketsecurity/registry/external/streaming-iterables.js

@@ -0,0 +1,326 @@
+'use strict'
+
+function getIterator(iterable) {
+  if (typeof iterable.next === 'function') {
+    return iterable
+  }
+  if (typeof iterable[Symbol.iterator] === 'function') {
+    return iterable[Symbol.iterator]()
+  }
+  if (typeof iterable[Symbol.asyncIterator] === 'function') {
+    return iterable[Symbol.asyncIterator]()
+  }
+  throw new TypeError(
+    '"values" does not to conform to any of the iterator or iterable protocols'
+  )
+}
+function defer() {
+  let reject
+  let resolve
+  const promise = new Promise((resolveFunc, rejectFunc) => {
+    resolve = resolveFunc
+    reject = rejectFunc
+  })
+  return {
+    promise,
+    reject,
+    resolve
+  }
+}
+function _buffer(size, iterable) {
+  const iterator = getIterator(iterable)
+  const resultQueue = []
+  const readQueue = []
+  let reading = false
+  let ended = false
+  function fulfillReadQueue() {
+    while (readQueue.length > 0 && resultQueue.length > 0) {
+      const readDeferred = readQueue.shift()
+      const { error, value } = resultQueue.shift()
+      if (error) {
+        readDeferred.reject(error)
+      } else {
+        readDeferred.resolve({
+          done: false,
+          value
+        })
+      }
+    }
+    while (readQueue.length > 0 && ended) {
+      const { resolve } = readQueue.shift()
+      resolve({
+        done: true,
+        value: undefined
+      })
+    }
+  }
+  async function fillQueue() {
+    if (ended) {
+      return
+    }
+    if (reading) {
+      return
+    }
+    if (resultQueue.length >= size) {
+      return
+    }
+    reading = true
+    try {
+      const { done, value } = await iterator.next()
+      if (done) {
+        ended = true
+      } else {
+        resultQueue.push({
+          value
+        })
+      }
+    } catch (error) {
+      ended = true
+      resultQueue.push({
+        error
+      })
+    }
+    fulfillReadQueue()
+    reading = false
+    fillQueue()
+  }
+  async function next() {
+    if (resultQueue.length > 0) {
+      const { error, value } = resultQueue.shift()
+      if (error) {
+        throw error
+      }
+      fillQueue()
+      return {
+        done: false,
+        value
+      }
+    }
+    if (ended) {
+      return {
+        done: true,
+        value: undefined
+      } // stupid ts
+    }
+    const deferred = defer()
+    readQueue.push(deferred)
+    fillQueue()
+    return deferred.promise
+  }
+  const asyncIterableIterator = {
+    next,
+    [Symbol.asyncIterator]: () => asyncIterableIterator
+  }
+  return asyncIterableIterator
+}
+function* syncBuffer(size, iterable) {
+  const valueQueue = []
+  let e
+  try {
+    for (const value of iterable) {
+      valueQueue.push(value)
+      if (valueQueue.length <= size) {
+        continue
+      }
+      yield valueQueue.shift()
+    }
+  } catch (error) {
+    e = error
+  }
+  for (const value of valueQueue) {
+    yield value
+  }
+  if (e) {
+    throw e
+  }
+}
+function buffer(size, iterable) {
+  if (iterable === undefined) {
+    return curriedIterable => buffer(size, curriedIterable)
+  }
+  if (size === 0) {
+    return iterable
+  }
+  if (iterable[Symbol.asyncIterator]) {
+    return _buffer(size, iterable)
+  }
+  return syncBuffer(size, iterable)
+}
+async function* _map(func, iterable) {
+  for await (const val of iterable) {
+    yield await func(val)
+  }
+}
+function map(func, iterable) {
+  if (iterable === undefined) {
+    return curriedIterable => _map(func, curriedIterable)
+  }
+  return _map(func, iterable)
+}
+function pipeline(firstFn, ...fns) {
+  let previousFn = firstFn()
+  for (const func of fns) {
+    previousFn = func(previousFn)
+  }
+  return previousFn
+}
+async function* _parallelMap(concurrency, func, iterable) {
+  let transformError = null
+  const wrapFunc = value => ({
+    value: func(value)
+  })
+  const stopOnError = async function* (source) {
+    for await (const value of source) {
+      if (transformError) {
+        return
+      }
+      yield value
+    }
+  }
+  const output = pipeline(
+    () => iterable,
+    buffer(1),
+    stopOnError,
+    map(wrapFunc),
+    buffer(concurrency - 1)
+  )
+  const itr = getIterator(output)
+  while (true) {
+    const { value, done } = await itr.next()
+    if (done) {
+      break
+    }
+    try {
+      const val = await value.value
+      if (!transformError) {
+        yield val
+      }
+    } catch (error) {
+      transformError = error
+    }
+  }
+  if (transformError) {
+    throw transformError
+  }
+}
+function parallelMap(concurrency, func, iterable) {
+  if (func === undefined) {
+    return (curriedFunc, curriedIterable) =>
+      parallelMap(concurrency, curriedFunc, curriedIterable)
+  }
+  if (iterable === undefined) {
+    return curriedIterable => parallelMap(concurrency, func, curriedIterable)
+  }
+  if (concurrency === 1) {
+    return map(func, iterable)
+  }
+  return _parallelMap(concurrency, func, iterable)
+}
+function _transform(concurrency, func, iterable) {
+  const iterator = getIterator(iterable)
+  const resultQueue = []
+  const readQueue = []
+  let ended = false
+  let reading = false
+  let inflightCount = 0
+  let lastError = null
+  function fulfillReadQueue() {
+    while (readQueue.length > 0 && resultQueue.length > 0) {
+      const { resolve } = readQueue.shift()
+      const value = resultQueue.shift()
+      resolve({
+        done: false,
+        value
+      })
+    }
+    while (readQueue.length > 0 && inflightCount === 0 && ended) {
+      const { resolve, reject } = readQueue.shift()
+      if (lastError) {
+        reject(lastError)
+        lastError = null
+      } else {
+        resolve({
+          done: true,
+          value: undefined
+        })
+      }
+    }
+  }
+  async function fillQueue() {
+    if (ended) {
+      fulfillReadQueue()
+      return
+    }
+    if (reading) {
+      return
+    }
+    if (inflightCount + resultQueue.length >= concurrency) {
+      return
+    }
+    reading = true
+    inflightCount++
+    try {
+      const { done, value } = await iterator.next()
+      if (done) {
+        ended = true
+        inflightCount--
+        fulfillReadQueue()
+      } else {
+        mapAndQueue(value)
+      }
+    } catch (error) {
+      ended = true
+      inflightCount--
+      lastError = error
+      fulfillReadQueue()
+    }
+    reading = false
+    fillQueue()
+  }
+  async function mapAndQueue(itrValue) {
+    try {
+      const value = await func(itrValue)
+      resultQueue.push(value)
+    } catch (error) {
+      ended = true
+      lastError = error
+    }
+    inflightCount--
+    fulfillReadQueue()
+    fillQueue()
+  }
+  async function next() {
+    if (resultQueue.length === 0) {
+      const deferred = defer()
+      readQueue.push(deferred)
+      fillQueue()
+      return deferred.promise
+    }
+    const value = resultQueue.shift()
+    fillQueue()
+    return {
+      done: false,
+      value
+    }
+  }
+  const asyncIterableIterator = {
+    next,
+    [Symbol.asyncIterator]: () => asyncIterableIterator
+  }
+  return asyncIterableIterator
+}
+function transform(concurrency, func, iterable) {
+  if (func === undefined) {
+    return (curriedFunc, curriedIterable) =>
+      curriedIterable
+        ? transform(concurrency, curriedFunc, curriedIterable)
+        : transform(concurrency, curriedFunc)
+  }
+  if (iterable === undefined) {
+    return curriedIterable => transform(concurrency, func, curriedIterable)
+  }
+  return _transform(concurrency, func, iterable)
+}
+
+exports.parallelMap = parallelMap
+exports.transform = transform

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

@@ -6,6 +6,46 @@ const { getGlobMatcher } = /*@__PURE__*/ require('./globs')
 const { naturalCompare } = /*@__PURE__*/ require('./sorts')
 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,
@@ -38,25 +78,26 @@ function getPath() {
 
 /*@__NO_SIDE_EFFECTS__*/
 function innerReadDirNames(dirents, options) {
-  const { includeEmpty, sort } = {
-    __proto__: null,
-    sort: true,
-    includeEmpty: false,
-    ...options
-  }
+  const {
+    ignore,
+    includeEmpty = false,
+    sort = true
+  } = { __proto__: null, ...options }
   const path = getPath()
   const names = dirents
     .filter(
       d =>
         d.isDirectory() &&
-        (includeEmpty || !isDirEmptySync(path.join(d.parentPath, d.name)))
+        (includeEmpty ||
+          !isDirEmptySync(path.join(d.parentPath, d.name), { ignore }))
     )
     .map(d => d.name)
   return sort ? names.sort(naturalCompare) : names
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-function isDirEmptySync(dirname) {
+function isDirEmptySync(dirname, options) {
+  const { ignore = defaultIgnore } = { __proto__: null, ...options }
   const fs = getFs()
   try {
     const files = fs.readdirSync(dirname)
@@ -64,10 +105,7 @@ function isDirEmptySync(dirname) {
     if (length === 0) {
       return true
     }
-    const matcher = getGlobMatcher(
-      /*@__PURE__*/ require('./constants/ignore-globs'),
-      { cwd: dirname }
-    )
+    const matcher = getGlobMatcher(ignore, { cwd: dirname })
     let ignoredCount = 0
     for (let i = 0; i < length; i += 1) {
       if (matcher(files[i])) {

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

@@ -10,17 +10,17 @@ function getPicomatch() {
   return _picomatch
 }
 
-let _tinyGlobby
+let _fastGlob
 /*@__NO_SIDE_EFFECTS__*/
-function getTinyGlobby() {
-  if (_tinyGlobby === undefined) {
-    _tinyGlobby = /*@__PURE__*/ require('../external/tinyglobby')
+function getFastGlob() {
+  if (_fastGlob === undefined) {
+    _fastGlob = /*@__PURE__*/ require('../external/fast-glob')
   }
-  return _tinyGlobby
+  return _fastGlob
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-async function globLicenses(dirname, options) {
+function globStreamLicenses(dirname, options) {
   const {
     ignore: ignoreOpt,
     ignoreOriginals,
@@ -36,8 +36,8 @@ async function globLicenses(dirname, options) {
       /*@__PURE__*/ require('./constants/license-original-glob-recursive')
     )
   }
-  const tinyGlobby = getTinyGlobby()
-  return await tinyGlobby.glob(
+  const fastGlob = getFastGlob()
+  return fastGlob.globStream(
     [
       recursive
         ? /*@__PURE__*/ require('./constants/license-glob-recursive')
@@ -48,7 +48,6 @@ async function globLicenses(dirname, options) {
       absolute: true,
       caseSensitiveMatch: false,
       cwd: dirname,
-      expandDirectories: recursive,
       ...globOptions,
       ...(ignore ? { ignore } : {})
     }
@@ -76,5 +75,5 @@ function getGlobMatcher(glob, options) {
 
 module.exports = {
   getGlobMatcher,
-  globLicenses
+  globStreamLicenses
 }

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

@@ -216,8 +216,8 @@ function resolveBinPathSync(binPath) {
     }
 
     let relPath = ''
-    const source = fs.readFileSync(binPath, 'utf8')
     if (hasKnownExt) {
+      const source = fs.readFileSync(binPath, 'utf8')
       if (isNpmOrNpx) {
         if (extLowered === '.cmd') {
           // "npm.cmd" and "npx.cmd" defined by

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

@@ -0,0 +1,37 @@
+'use strict'
+
+const { apply: ReflectApply } = Reflect
+
+let _streamingIterables
+/*@__NO_SIDE_EFFECTS__*/
+function getStreamingIterables() {
+  if (_streamingIterables === undefined) {
+    _streamingIterables = /*@__PURE__*/ require('../external/streaming-iterables')
+  }
+  return _streamingIterables
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+async function parallelForEach(concurrency, func, iterable) {
+  for await (const _ of parallelMap(concurrency, func, iterable)) {
+    /* empty block */
+  }
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function parallelMap(...args) {
+  const streamingIterables = getStreamingIterables()
+  return ReflectApply(streamingIterables.parallelMap, undefined, args)
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+function transform(...args) {
+  const streamingIterables = getStreamingIterables()
+  return ReflectApply(streamingIterables.transform, undefined, args)
+}
+
+module.exports = {
+  parallelForEach,
+  parallelMap,
+  transform
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socketsecurity/cli-with-sentry",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "CLI for Socket.dev, includes Sentry error handling, otherwise identical to the regular `socket` package",
   "homepage": "https://github.com/SocketDev/socket-cli",
   "license": "MIT",
@@ -112,7 +112,7 @@
     "@socketregistry/is-interactive": "1.0.6",
     "@socketregistry/packageurl-js": "1.0.8",
     "@socketsecurity/config": "3.0.1",
-    "@socketsecurity/registry": "1.0.250",
+    "@socketsecurity/registry": "1.0.256",
     "@socketsecurity/sdk": "1.4.67",
     "@types/blessed": "0.1.25",
     "@types/cmd-shim": "5.0.2",
@@ -127,7 +127,7 @@
     "@types/which": "3.0.4",
     "@types/yargs-parser": "21.0.3",
     "@typescript-eslint/parser": "8.38.0",
-    "@typescript/native-preview": "7.0.0-dev.20250731.1",
+    "@typescript/native-preview": "7.0.0-dev.20250801.1",
     "@vitest/coverage-v8": "3.2.4",
     "blessed": "0.1.81",
     "blessed-contrib": "4.11.0",
@@ -143,6 +143,7 @@
     "eslint-plugin-n": "17.21.3",
     "eslint-plugin-sort-destructure-keys": "2.0.0",
     "eslint-plugin-unicorn": "56.0.1",
+    "fast-glob": "3.3.3",
     "globals": "16.3.0",
     "hpagent": "1.2.0",
     "husky": "9.1.7",
@@ -154,7 +155,7 @@
     "meow": "13.2.0",
     "micromatch": "4.0.8",
     "mock-fs": "5.5.0",
-    "nock": "14.0.7",
+    "nock": "14.0.8",
     "npm-package-arg": "13.0.0",
     "npm-run-all2": "8.0.4",
     "open": "10.2.0",
@@ -167,7 +168,6 @@
     "synp": "1.9.14",
     "terminal-link": "2.1.1",
     "tiny-updater": "3.5.3",
-    "tinyglobby": "0.2.14",
     "trash": "9.0.0",
     "type-coverage": "2.29.7",
     "typescript-eslint": "8.38.0",
@@ -239,6 +239,6 @@
     "strict": true
   },
   "dependencies": {
-    "@sentry/node": "9.43.0"
+    "@sentry/node": "10.0.0"
   }
 }