@socketsecurity/cli-with-sentry 0.15.10 → 0.15.12

package/external/@socketsecurity/registry/external/which.js

@@ -230,10 +230,9 @@ function requireCjs() {
         }
         const result = {}
         if (mod != null) {
-          for (const k in mod) {
+          for (var k in mod)
             if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
               __createBinding(result, mod, k)
-          }
         }
         __setModuleDefault(result, mod)
         return result
@@ -245,9 +244,8 @@ function requireCjs() {
           if (
             p !== 'default' &&
             !Object.prototype.hasOwnProperty.call(exports, p)
-          ) {
+          )
             __createBinding(exports, m, p)
-          }
         }
       }
     Object.defineProperty(exports, '__esModule', {

package/external/@socketsecurity/registry/lib/logger.d.ts

@@ -17,6 +17,8 @@ declare namespace LoggerModule {
   export interface Task {
     run<T>(f: () => T): T
   }
+  export const incLogCallCountSymbol: unique symbol
+  export const LOG_SYMBOLS: LogSymbols
   export class Logger extends Console {
     static get LOG_SYMBOLS(): LogSymbols
     constructor(
@@ -25,6 +27,8 @@ declare namespace LoggerModule {
       ignoreErrors?: boolean | undefined
     )
     constructor(options: ConsoleConstructorOptions)
+    [incLogCallCountSymbol](): Logger
+    'Symbol(logger.logCallCount++)': Logger
     assert: LoggerMethods['assert']
     clear: LoggerMethods['clear']
     count: LoggerMethods['count']
@@ -54,7 +58,6 @@ declare namespace LoggerModule {
     trace: LoggerMethods['trace']
     warn: LoggerMethods['warn']
   }
-  export const LOG_SYMBOLS: LogSymbols
   export const logger: Logger
 }
 export = LoggerModule

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

@@ -46,7 +46,7 @@ const LOG_SYMBOLS = /*@__PURE__*/ (() => {
   for (const trapName of Reflect.ownKeys(Reflect)) {
     const fn = Reflect[trapName]
     if (typeof fn === 'function') {
-      handler[trapName] = function (...args) {
+      handler[trapName] = (...args) => {
         init()
         return fn(...args)
       }
@@ -55,25 +55,46 @@ const LOG_SYMBOLS = /*@__PURE__*/ (() => {
   return new Proxy(target, handler)
 })()
 
-const boundConsoleMethods = new Map(
-  ['debug', 'dir', 'dirxml', 'error', 'info', 'log', 'trace', 'warn'].map(n => [
-    n,
-    console[n].bind(console)
-  ])
-)
+const boundConsoleEntries = [
+  // Add bound properties from console[kBindProperties](ignoreErrors, colorMode, groupIndentation).
+  // https://github.com/nodejs/node/blob/v24.0.1/lib/internal/console/constructor.js#L230-L265
+  '_stderrErrorHandler',
+  '_stdoutErrorHandler',
+  // Add methods that need to be bound to function properly.
+  'assert',
+  'clear',
+  'count',
+  'countReset',
+  'createTask',
+  'debug',
+  'dir',
+  'dirxml',
+  'error',
+  'group',
+  'groupCollapsed',
+  'groupEnd',
+  'info',
+  'log',
+  'table',
+  'time',
+  'timeEnd',
+  'timeLog',
+  'trace',
+  'warn'
+]
+  .filter(n => typeof console[n] === 'function')
+  .map(n => [n, console[n].bind(console)])
 
-const consoleSymbols = Object.getOwnPropertySymbols(console).filter(
-  s => s !== Symbol.toStringTag
-)
+const consolePropAttributes = {
+  __proto__: null,
+  writable: true,
+  enumerable: false,
+  configurable: true
+}
 
-const privateConsole = new WeakMap()
+const incLogCallCountSymbol = Symbol.for('logger.logCallCount++')
 
-const symbolTypeToMethodName = {
-  fail: 'error',
-  info: 'info',
-  success: 'log',
-  warn: 'warn'
-}
+const privateConsole = new WeakMap()
 
 /*@__PURE__*/
 class Logger {
@@ -92,61 +113,47 @@ class Logger {
         stdout: process.stdout,
         stderr: process.stderr
       })
-      for (const { 0: key, 1: method } of boundConsoleMethods) {
+      for (const { 0: key, 1: method } of boundConsoleEntries) {
         newConsole[key] = method
       }
       privateConsole.set(this, newConsole)
     }
-    Object.defineProperties(
-      this,
-      Object.fromEntries(
-        consoleSymbols.map(key => [
-          key,
-          {
-            __proto__: null,
-            configurable: true,
-            value: console[key],
-            writable: true
-          }
-        ])
-      )
-    )
   }
 
   #apply(methodName, args) {
+    const con = privateConsole.get(this)
     const text = args.at(0)
-    const console = privateConsole.get(this)
     let extras
     if (typeof text === 'string') {
       extras = args.slice(1)
-      console[methodName](`${this.#indention}${text}`)
-      this.#logCallCount += 1
+      con[methodName](`${this.#indention}${text}`)
+      this[incLogCallCountSymbol]()
     } else {
       extras = args
     }
     if (extras.length) {
-      console[methodName](...extras)
-      this.#logCallCount += 1
+      con[methodName](...extras)
+      this[incLogCallCountSymbol]()
     }
     return this
   }
 
   #symbolApply(symbolType, args) {
-    let extras
+    const con = privateConsole.get(this)
     let text = args.at(0)
+    let extras
     if (typeof text === 'string') {
       extras = args.slice(1)
     } else {
       extras = args
       text = ''
     }
-    const methodName = symbolTypeToMethodName[symbolType]
-    const console = privateConsole.get(this)
-    console[methodName](`${this.#indention}${LOG_SYMBOLS[symbolType]} ${text}`)
-    this.#logCallCount += 1
+    // Note: Meta status messages (info/fail/etc) always go to stderr.
+    con.error(`${this.#indention}${LOG_SYMBOLS[symbolType]} ${text}`)
+    this[incLogCallCountSymbol]()
     if (extras.length) {
-      console[methodName](...extras)
-      this.#logCallCount += 1
+      con.error(...extras)
+      this[incLogCallCountSymbol]()
     }
     return this
   }
@@ -155,11 +162,49 @@ class Logger {
     return this.#logCallCount
   }
 
+  [incLogCallCountSymbol]() {
+    this.#logCallCount += 1
+    return this
+  }
+
+  assert(value, ...message) {
+    const con = privateConsole.get(this)
+    con.assert(value, ...message)
+    return value ? this : this[incLogCallCountSymbol]()
+  }
+
+  clear() {
+    const con = privateConsole.get(this)
+    con.clear()
+    if (con._stdout.isTTY) {
+      this.#logCallCount = 0
+    }
+    return this
+  }
+
+  count(label) {
+    const con = privateConsole.get(this)
+    con.count(label)
+    return this[incLogCallCountSymbol]()
+  }
+
   dedent(spaces = 2) {
     this.#indention = this.#indention.slice(0, -spaces)
     return this
   }
 
+  dir(obj, options) {
+    const con = privateConsole.get(this)
+    con.dir(obj, options)
+    return this[incLogCallCountSymbol]()
+  }
+
+  dirxml(...data) {
+    const con = privateConsole.get(this)
+    con.dirxml(data)
+    return this[incLogCallCountSymbol]()
+  }
+
   error(...args) {
     return this.#apply('error', args)
   }
@@ -168,6 +213,18 @@ class Logger {
     return this.#symbolApply('fail', args)
   }
 
+  group(...label) {
+    const con = privateConsole.get(this)
+    con.group(...label)
+    return label.length ? this[incLogCallCountSymbol]() : this
+  }
+
+  // groupCollapsed is an alias of group.
+  // https://nodejs.org/api/console.html#consolegroupcollapsed
+  groupCollapsed(...label) {
+    return this.group(...label)
+  }
+
   indent(spaces = 2) {
     this.#indention += ' '.repeat(spaces)
     return this
@@ -190,48 +247,78 @@ class Logger {
     return this.#symbolApply('success', args)
   }
 
-  warn(...args) {
-    return this.#symbolApply('warn', args)
+  table(tabularData, properties) {
+    const con = privateConsole.get(this)
+    con.table(tabularData, properties)
+    return this[incLogCallCountSymbol]()
+  }
+
+  timeEnd(label) {
+    const con = privateConsole.get(this)
+    con.timeEnd(label)
+    return this[incLogCallCountSymbol]()
   }
-}
 
-const mixinKeys = []
-for (const { 0: key, 1: value } of Object.entries(console)) {
-  if (!Logger.prototype[key] && typeof value === 'function') {
-    mixinKeys.push(key)
+  timeLog(label, ...data) {
+    const con = privateConsole.get(this)
+    con.timeLog(label, ...data)
+    return this[incLogCallCountSymbol]()
+  }
+
+  trace(message, ...args) {
+    const con = privateConsole.get(this)
+    con.trace(message, ...args)
+    return this[incLogCallCountSymbol]()
+  }
+
+  warn(...args) {
+    return this.#symbolApply('warn', args)
   }
 }
 
 Object.defineProperties(
   Logger.prototype,
-  Object.fromEntries([
-    ...mixinKeys.map(key => [
-      key,
-      {
-        __proto__: null,
-        configurable: true,
-        value: function (...args) {
-          const console = privateConsole.get(this)
-          const result = console[key](...args)
-          return result === undefined || result === console ? this : result
-        },
-        writable: true
-      }
-    ]),
-    [
-      Symbol.toStringTag,
-      {
-        __proto__: null,
-        configurable: true,
-        value: 'logger'
+  Object.fromEntries(
+    (() => {
+      const entries = [
+        [
+          Symbol.toStringTag,
+          {
+            __proto__: null,
+            configurable: true,
+            value: 'logger'
+          }
+        ]
+      ]
+      for (const { 0: key, 1: value } of Object.entries(console)) {
+        if (!Logger.prototype[key] && typeof value === 'function') {
+          // Dynamically name the log method without using Object.defineProperty.
+          const { [key]: func } = {
+            [key](...args) {
+              const con = privateConsole.get(this)
+              const result = con[key](...args)
+              return result === undefined || result === con ? this : result
+            }
+          }
+          entries.push([
+            key,
+            {
+              __proto__: null,
+              ...consolePropAttributes,
+              value: func
+            }
+          ])
+        }
       }
-    ]
-  ])
+      return entries
+    })()
+  )
 )
 
 const logger = new Logger()
 
 module.exports = {
+  incLogCallCountSymbol,
   LOG_SYMBOLS,
   Logger,
   logger

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

@@ -38,8 +38,12 @@ function Spinner(options) {
           text = ''
         }
         super[methodName](text)
+        const {
+          incLogCallCountSymbol,
+          logger
+        } = /*@__PURE__*/ require('./logger')
+        logger[incLogCallCountSymbol]()
         if (extras.length) {
-          const { logger } = /*@__PURE__*/ require('./logger')
           logger.log(...extras)
         }
         return this

package/external/@socketsecurity/registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socketsecurity/registry",
-  "version": "1.0.184",
+  "version": "1.0.187",
   "license": "MIT",
   "description": "Socket.dev registry helpers methods and metadata",
   "keywords": [
@@ -612,7 +612,7 @@
     "@babel/plugin-transform-runtime": "7.27.1",
     "@babel/runtime": "7.27.1",
     "@biomejs/biome": "1.9.4",
-    "@dotenvx/dotenvx": "1.44.0",
+    "@dotenvx/dotenvx": "1.44.1",
     "@inquirer/confirm": "5.1.10",
     "@inquirer/input": "4.1.10",
     "@inquirer/password": "4.0.13",