@socketsecurity/cli-with-sentry 1.0.75 → 1.0.77

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/constants/env.js

@@ -28,6 +28,12 @@ module.exports = ObjectFreeze({
     envAsString(env.NODE_ENV).toLowerCase() === 'development'
       ? 'development'
       : 'production',
+  // A space-separated list of command-line options. `options...` are interpreted
+  // before command-line options, so command-line options will override or compound
+  // after anything in `options...`. Node.js will exit with an error if an option
+  // that is not allowed in the environment is used, such as `-p` or a script file.
+  // https://nodejs.org/api/cli.html#node_optionsoptions
+  NODE_OPTIONS: envAsString(env.NODE_OPTIONS),
   // PRE_COMMIT is set to '1' by our 'test-pre-commit' script run by the
   // .husky/pre-commit hook.
   PRE_COMMIT: envAsBoolean(env.PRE_COMMIT),

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/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.75",
+  "version": "1.0.77",
   "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",
@@ -87,7 +87,7 @@
     "@biomejs/biome": "2.1.3",
     "@coana-tech/cli": "14.10.6",
     "@cyclonedx/cdxgen": "11.4.4",
-    "@dotenvx/dotenvx": "1.48.3",
+    "@dotenvx/dotenvx": "1.48.4",
     "@eslint/compat": "1.3.1",
     "@eslint/js": "9.32.0",
     "@npmcli/arborist": "9.1.3",
@@ -97,9 +97,9 @@
     "@octokit/request-error": "7.0.0",
     "@octokit/rest": "22.0.0",
     "@octokit/types": "14.1.0",
-    "@pnpm/dependency-path": "1001.0.2",
-    "@pnpm/lockfile.detect-dep-types": "1001.0.12",
-    "@pnpm/lockfile.fs": "1001.1.16",
+    "@pnpm/dependency-path": "1001.1.0",
+    "@pnpm/lockfile.detect-dep-types": "1001.0.13",
+    "@pnpm/lockfile.fs": "1001.1.17",
     "@pnpm/logger": "1001.0.0",
     "@rollup/plugin-babel": "6.0.4",
     "@rollup/plugin-commonjs": "28.0.6",
@@ -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.249",
+    "@socketsecurity/registry": "1.0.254",
     "@socketsecurity/sdk": "1.4.67",
     "@types/blessed": "0.1.25",
     "@types/cmd-shim": "5.0.2",
@@ -127,14 +127,14 @@
     "@types/which": "3.0.4",
     "@types/yargs-parser": "21.0.3",
     "@typescript-eslint/parser": "8.38.0",
-    "@typescript/native-preview": "7.0.0-dev.20250729.2",
+    "@typescript/native-preview": "7.0.0-dev.20250801.1",
     "@vitest/coverage-v8": "3.2.4",
     "blessed": "0.1.81",
     "blessed-contrib": "4.11.0",
     "browserslist": "4.25.1",
     "chalk-table": "1.0.2",
     "cmd-shim": "7.0.0",
-    "custompatch": "1.1.7",
+    "custompatch": "1.1.8",
     "del-cli": "6.0.0",
     "dev-null-cli": "2.0.0",
     "eslint": "9.32.0",
@@ -143,18 +143,19 @@
     "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",
     "ignore": "7.0.5",
-    "js-yaml": "npm:@zkochan/js-yaml@0.0.7",
+    "js-yaml": "npm:@zkochan/js-yaml@0.0.9",
     "knip": "5.62.0",
     "lint-staged": "16.1.2",
     "magic-string": "0.30.17",
     "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",
@@ -162,12 +163,11 @@
     "pony-cause": "2.1.11",
     "registry-auth-token": "5.1.0",
     "registry-url": "7.2.0",
-    "rollup": "4.46.1",
+    "rollup": "4.46.2",
     "semver": "7.7.2",
     "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"
   }
 }