@socketsecurity/cli-with-sentry 1.0.4 → 1.0.5

package/external/node-gyp/lib/node-gyp.js

@@ -0,0 +1,188 @@
+'use strict'
+
+const path = require('path')
+const nopt = require('nopt')
+const log = require('./log')
+const childProcess = require('child_process')
+const { EventEmitter } = require('events')
+
+const commands = [
+  // Module build commands
+  'build',
+  'clean',
+  'configure',
+  'rebuild',
+  // Development Header File management commands
+  'install',
+  'list',
+  'remove'
+]
+
+class Gyp extends EventEmitter {
+  /**
+   * Export the contents of the package.json.
+   */
+  package = require('../package.json')
+
+  /**
+   * nopt configuration definitions
+   */
+  configDefs = {
+    help: Boolean, // everywhere
+    arch: String, // 'configure'
+    cafile: String, // 'install'
+    debug: Boolean, // 'build'
+    directory: String, // bin
+    make: String, // 'build'
+    'msvs-version': String, // 'configure'
+    ensure: Boolean, // 'install'
+    solution: String, // 'build' (windows only)
+    proxy: String, // 'install'
+    noproxy: String, // 'install'
+    devdir: String, // everywhere
+    nodedir: String, // 'configure'
+    loglevel: String, // everywhere
+    python: String, // 'configure'
+    'dist-url': String, // 'install'
+    tarball: String, // 'install'
+    jobs: String, // 'build'
+    thin: String, // 'configure'
+    'force-process-config': Boolean // 'configure'
+  }
+
+  /**
+   * nopt shorthands
+   */
+  shorthands = {
+    release: '--no-debug',
+    C: '--directory',
+    debug: '--debug',
+    j: '--jobs',
+    silly: '--loglevel=silly',
+    verbose: '--loglevel=verbose',
+    silent: '--loglevel=silent'
+  }
+
+  /**
+   * expose the command aliases for the bin file to use.
+   */
+  aliases = {
+    ls: 'list',
+    rm: 'remove'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.devDir = ''
+
+    this.commands = commands.reduce((acc, command) => {
+      acc[command] = (argv) => require('./' + command)(this, argv)
+      return acc
+    }, {})
+
+    Object.defineProperty(this, 'version', {
+      enumerable: true,
+      get: function () { return this.package.version }
+    })
+  }
+
+  /**
+   * Parses the given argv array and sets the 'opts',
+   * 'argv' and 'command' properties.
+   */
+  parseArgv (argv) {
+    this.opts = nopt(this.configDefs, this.shorthands, argv)
+    this.argv = this.opts.argv.remain.slice()
+
+    const commands = this.todo = []
+
+    // create a copy of the argv array with aliases mapped
+    argv = this.argv.map((arg) => {
+    // is this an alias?
+      if (arg in this.aliases) {
+        arg = this.aliases[arg]
+      }
+      return arg
+    })
+
+    // process the mapped args into "command" objects ("name" and "args" props)
+    argv.slice().forEach((arg) => {
+      if (arg in this.commands) {
+        const args = argv.splice(0, argv.indexOf(arg))
+        argv.shift()
+        if (commands.length > 0) {
+          commands[commands.length - 1].args = args
+        }
+        commands.push({ name: arg, args: [] })
+      }
+    })
+    if (commands.length > 0) {
+      commands[commands.length - 1].args = argv.splice(0)
+    }
+
+    // support for inheriting config env variables from npm
+    const npmConfigPrefix = 'npm_config_'
+    Object.keys(process.env).forEach((name) => {
+      if (name.indexOf(npmConfigPrefix) !== 0) {
+        return
+      }
+      const val = process.env[name]
+      if (name === npmConfigPrefix + 'loglevel') {
+        log.logger.level = val
+      } else {
+      // add the user-defined options to the config
+        name = name.substring(npmConfigPrefix.length)
+        // gyp@741b7f1 enters an infinite loop when it encounters
+        // zero-length options so ensure those don't get through.
+        if (name) {
+        // convert names like force_process_config to force-process-config
+          if (name.includes('_')) {
+            name = name.replace(/_/g, '-')
+          }
+          this.opts[name] = val
+        }
+      }
+    })
+
+    if (this.opts.loglevel) {
+      log.logger.level = this.opts.loglevel
+    }
+    log.resume()
+  }
+
+  /**
+   * Spawns a child process and emits a 'spawn' event.
+   */
+  spawn (command, args, opts) {
+    if (!opts) {
+      opts = {}
+    }
+    if (!opts.silent && !opts.stdio) {
+      opts.stdio = [0, 1, 2]
+    }
+    const cp = childProcess.spawn(command, args, opts)
+    log.info('spawn', command)
+    log.info('spawn args', args)
+    return cp
+  }
+
+  /**
+   * Returns the usage instructions for node-gyp.
+   */
+  usage () {
+    return [
+      '',
+      '  Usage: node-gyp <command> [options]',
+      '',
+      '  where <command> is one of:',
+      commands.map((c) => '    - ' + c + ' - ' + require('./' + c).usage).join('\n'),
+      '',
+      'node-gyp@' + this.version + '  ' + path.resolve(__dirname, '..'),
+      'node@' + process.versions.node
+    ].join('\n')
+  }
+}
+
+module.exports = () => new Gyp()
+module.exports.Gyp = Gyp

package/external/node-gyp/lib/process-release.js

@@ -0,0 +1,148 @@
+'use strict'
+
+/* eslint-disable n/no-deprecated-api */
+
+'use strict'
+
+const semver = require('semver')
+const url = require('url')
+const path = require('path')
+const log = require('./log')
+
+// versions where -headers.tar.gz started shipping
+const headersTarballRange = '>= 3.0.0 || ~0.12.10 || ~0.10.42'
+const bitsre = /\/win-(x86|x64|arm64)\//
+const bitsreV3 = /\/win-(x86|ia32|x64)\// // io.js v3.x.x shipped with "ia32" but should
+// have been "x86"
+
+// Captures all the logic required to determine download URLs, local directory and
+// file names. Inputs come from command-line switches (--target, --dist-url),
+// `process.version` and `process.release` where it exists.
+function processRelease (argv, gyp, defaultVersion, defaultRelease) {
+  let version = (semver.valid(argv[0]) && argv[0]) || gyp.opts.target || defaultVersion
+  const versionSemver = semver.parse(version)
+  let overrideDistUrl = gyp.opts['dist-url'] || gyp.opts.disturl
+  let isNamedForLegacyIojs
+  let name
+  let distBaseUrl
+  let baseUrl
+  let libUrl32
+  let libUrl64
+  let libUrlArm64
+  let tarballUrl
+  let canGetHeaders
+
+  if (!versionSemver) {
+    // not a valid semver string, nothing we can do
+    return { version }
+  }
+  // flatten version into String
+  version = versionSemver.version
+
+  // defaultVersion should come from process.version so ought to be valid semver
+  const isDefaultVersion = version === semver.parse(defaultVersion).version
+
+  // can't use process.release if we're using --target=x.y.z
+  if (!isDefaultVersion) {
+    defaultRelease = null
+  }
+
+  if (defaultRelease) {
+    // v3 onward, has process.release
+    name = defaultRelease.name.replace(/io\.js/, 'iojs') // remove the '.' for directory naming purposes
+  } else {
+    // old node or alternative --target=
+    // semver.satisfies() doesn't like prerelease tags so test major directly
+    isNamedForLegacyIojs = versionSemver.major >= 1 && versionSemver.major < 4
+    // isNamedForLegacyIojs is required to support Electron < 4 (in particular Electron 3)
+    // as previously this logic was used to ensure "iojs" was used to download iojs releases
+    // and "node" for node releases.  Unfortunately the logic was broad enough that electron@3
+    // published release assets as "iojs" so that the node-gyp logic worked.  Once Electron@3 has
+    // been EOL for a while (late 2019) we should remove this hack.
+    name = isNamedForLegacyIojs ? 'iojs' : 'node'
+  }
+
+  // check for the nvm.sh standard mirror env variables
+  if (!overrideDistUrl && process.env.NODEJS_ORG_MIRROR) {
+    overrideDistUrl = process.env.NODEJS_ORG_MIRROR
+  }
+
+  if (overrideDistUrl) {
+    log.verbose('download', 'using dist-url', overrideDistUrl)
+  }
+
+  if (overrideDistUrl) {
+    distBaseUrl = overrideDistUrl.replace(/\/+$/, '')
+  } else {
+    distBaseUrl = 'https://nodejs.org/dist'
+  }
+  distBaseUrl += '/v' + version + '/'
+
+  // new style, based on process.release so we have a lot of the data we need
+  if (defaultRelease && defaultRelease.headersUrl && !overrideDistUrl) {
+    baseUrl = url.resolve(defaultRelease.headersUrl, './')
+    libUrl32 = resolveLibUrl(name, defaultRelease.libUrl || baseUrl || distBaseUrl, 'x86', versionSemver.major)
+    libUrl64 = resolveLibUrl(name, defaultRelease.libUrl || baseUrl || distBaseUrl, 'x64', versionSemver.major)
+    libUrlArm64 = resolveLibUrl(name, defaultRelease.libUrl || baseUrl || distBaseUrl, 'arm64', versionSemver.major)
+    tarballUrl = defaultRelease.headersUrl
+  } else {
+    // older versions without process.release are captured here and we have to make
+    // a lot of assumptions, additionally if you --target=x.y.z then we can't use the
+    // current process.release
+    baseUrl = distBaseUrl
+    libUrl32 = resolveLibUrl(name, baseUrl, 'x86', versionSemver.major)
+    libUrl64 = resolveLibUrl(name, baseUrl, 'x64', versionSemver.major)
+    libUrlArm64 = resolveLibUrl(name, baseUrl, 'arm64', versionSemver.major)
+
+    // making the bold assumption that anything with a version number >3.0.0 will
+    // have a *-headers.tar.gz file in its dist location, even some frankenstein
+    // custom version
+    canGetHeaders = semver.satisfies(versionSemver, headersTarballRange)
+    tarballUrl = url.resolve(baseUrl, name + '-v' + version + (canGetHeaders ? '-headers' : '') + '.tar.gz')
+  }
+
+  return {
+    version,
+    semver: versionSemver,
+    name,
+    baseUrl,
+    tarballUrl,
+    shasumsUrl: url.resolve(baseUrl, 'SHASUMS256.txt'),
+    versionDir: (name !== 'node' ? name + '-' : '') + version,
+    ia32: {
+      libUrl: libUrl32,
+      libPath: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl32).path))
+    },
+    x64: {
+      libUrl: libUrl64,
+      libPath: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl64).path))
+    },
+    arm64: {
+      libUrl: libUrlArm64,
+      libPath: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrlArm64).path))
+    }
+  }
+}
+
+function normalizePath (p) {
+  return path.normalize(p).replace(/\\/g, '/')
+}
+
+function resolveLibUrl (name, defaultUrl, arch, versionMajor) {
+  const base = url.resolve(defaultUrl, './')
+  const hasLibUrl = bitsre.test(defaultUrl) || (versionMajor === 3 && bitsreV3.test(defaultUrl))
+
+  if (!hasLibUrl) {
+    // let's assume it's a baseUrl then
+    if (versionMajor >= 1) {
+      return url.resolve(base, 'win-' + arch + '/' + name + '.lib')
+    }
+    // prior to io.js@1.0.0 32-bit node.lib lives in /, 64-bit lives in /x64/
+    return url.resolve(base, (arch === 'x86' ? '' : arch + '/') + name + '.lib')
+  }
+
+  // else we have a proper url to a .lib, just make sure it's the right arch
+  return defaultUrl.replace(versionMajor === 3 ? bitsreV3 : bitsre, '/win-' + arch + '/')
+}
+
+module.exports = processRelease

package/external/node-gyp/lib/rebuild.js

@@ -0,0 +1,12 @@
+'use strict'
+
+async function rebuild (gyp, argv) {
+  gyp.todo.push(
+    { name: 'clean', args: [] }
+    , { name: 'configure', args: argv }
+    , { name: 'build', args: [] }
+  )
+}
+
+module.exports = rebuild
+module.exports.usage = 'Runs "clean", "configure" and "build" all at once'

package/external/node-gyp/lib/remove.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const fs = require('graceful-fs').promises
+const path = require('path')
+const log = require('./log')
+const semver = require('semver')
+
+async function remove (gyp, argv) {
+  const devDir = gyp.devDir
+  log.verbose('remove', 'using node-gyp dir:', devDir)
+
+  // get the user-specified version to remove
+  let version = argv[0] || gyp.opts.target
+  log.verbose('remove', 'removing target version:', version)
+
+  if (!version) {
+    throw new Error('You must specify a version number to remove. Ex: "' + process.version + '"')
+  }
+
+  const versionSemver = semver.parse(version)
+  if (versionSemver) {
+    // flatten the version Array into a String
+    version = versionSemver.version
+  }
+
+  const versionPath = path.resolve(gyp.devDir, version)
+  log.verbose('remove', 'removing development files for version:', version)
+
+  // first check if its even installed
+  try {
+    await fs.stat(versionPath)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return 'version was already uninstalled: ' + version
+    }
+    throw err
+  }
+
+  await fs.rm(versionPath, { recursive: true, force: true, maxRetries: 3 })
+}
+
+module.exports = remove
+module.exports.usage = 'Removes the node development files for the specified version'

package/external/node-gyp/lib/util.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const cp = require('child_process')
+const path = require('path')
+const { openSync, closeSync } = require('graceful-fs')
+const log = require('./log')
+
+const execFile = async (...args) => new Promise((resolve) => {
+  const child = cp.execFile(...args, (...a) => resolve(a))
+  child.stdin.end()
+})
+
+async function regGetValue (key, value, addOpts) {
+  const outReValue = value.replace(/\W/g, '.')
+  const outRe = new RegExp(`^\\s+${outReValue}\\s+REG_\\w+\\s+(\\S.*)$`, 'im')
+  const reg = path.join(process.env.SystemRoot, 'System32', 'reg.exe')
+  const regArgs = ['query', key, '/v', value].concat(addOpts)
+
+  log.silly('reg', 'running', reg, regArgs)
+  const [err, stdout, stderr] = await execFile(reg, regArgs, { encoding: 'utf8' })
+
+  log.silly('reg', 'reg.exe stdout = %j', stdout)
+  if (err || stderr.trim() !== '') {
+    log.silly('reg', 'reg.exe err = %j', err && (err.stack || err))
+    log.silly('reg', 'reg.exe stderr = %j', stderr)
+    if (err) {
+      throw err
+    }
+    throw new Error(stderr)
+  }
+
+  const result = outRe.exec(stdout)
+  if (!result) {
+    log.silly('reg', 'error parsing stdout')
+    throw new Error('Could not parse output of reg.exe')
+  }
+
+  log.silly('reg', 'found: %j', result[1])
+  return result[1]
+}
+
+async function regSearchKeys (keys, value, addOpts) {
+  for (const key of keys) {
+    try {
+      return await regGetValue(key, value, addOpts)
+    } catch {
+      continue
+    }
+  }
+}
+
+/**
+ * Returns the first file or directory from an array of candidates that is
+ * readable by the current user, or undefined if none of the candidates are
+ * readable.
+ */
+function findAccessibleSync (logprefix, dir, candidates) {
+  for (let next = 0; next < candidates.length; next++) {
+    const candidate = path.resolve(dir, candidates[next])
+    let fd
+    try {
+      fd = openSync(candidate, 'r')
+    } catch (e) {
+      // this candidate was not found or not readable, do nothing
+      log.silly(logprefix, 'Could not open %s: %s', candidate, e.message)
+      continue
+    }
+    closeSync(fd)
+    log.silly(logprefix, 'Found readable %s', candidate)
+    return candidate
+  }
+
+  return undefined
+}
+
+module.exports = {
+  execFile,
+  regGetValue,
+  regSearchKeys,
+  findAccessibleSync
+}

package/external/node-gyp/macOS_Catalina_acid_test.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+pkgs=(
+  "com.apple.pkg.DeveloperToolsCLILeo" # standalone
+  "com.apple.pkg.DeveloperToolsCLI"    # from XCode
+  "com.apple.pkg.CLTools_Executables"  # Mavericks
+)
+
+for pkg in "${pkgs[@]}"; do
+  output=$(/usr/sbin/pkgutil --pkg-info "$pkg" 2>/dev/null)
+  if [ "$output" ]; then
+    version=$(echo "$output" | grep 'version' | cut -d' ' -f2)
+    break
+  fi
+done
+
+if [ "$version" ]; then
+  echo "Command Line Tools version: $version"
+else
+  echo >&2 'Command Line Tools not found'
+fi

package/external/node-gyp/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "node-gyp",
+  "description": "Node.js native addon build tool",
+  "license": "MIT",
+  "keywords": [
+    "native",
+    "addon",
+    "module",
+    "c",
+    "c++",
+    "bindings",
+    "gyp"
+  ],
+  "version": "11.2.0",
+  "installVersion": 11,
+  "author": "Nathan Rajlich <nathan@tootallnate.net> (http://tootallnate.net)",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/node-gyp.git"
+  },
+  "preferGlobal": true,
+  "bin": "./bin/node-gyp.js",
+  "main": "./lib/node-gyp.js",
+  "dependencies": {
+    "env-paths": "^2.2.0",
+    "exponential-backoff": "^3.1.1",
+    "graceful-fs": "^4.2.6",
+    "make-fetch-happen": "^14.0.3",
+    "nopt": "^8.0.0",
+    "proc-log": "^5.0.0",
+    "semver": "^7.3.5",
+    "tar": "^7.4.3",
+    "tinyglobby": "^0.2.12",
+    "which": "^5.0.0"
+  },
+  "engines": {
+    "node": "^18.17.0 || >=20.5.0"
+  },
+  "devDependencies": {
+    "bindings": "^1.5.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.16.0",
+    "mocha": "^11.0.1",
+    "nan": "^2.14.2",
+    "neostandard": "^0.11.9",
+    "require-inject": "^1.4.4"
+  },
+  "scripts": {
+    "lint": "eslint \"*/*.js\" \"test/**/*.js\" \".github/**/*.js\"",
+    "test": "cross-env NODE_GYP_NULL_LOGGER=true mocha --timeout 15000 test/test-download.js test/test-*"
+  }
+}

package/external/node-gyp/release-please-config.json

@@ -0,0 +1,40 @@
+{
+    "packages": {
+        ".": {
+            "include-component-in-tag": false,
+            "release-type": "node",
+            "changelog-sections": [
+                { "type": "feat", "section": "Features", "hidden": false },
+                { "type": "fix", "section": "Bug Fixes", "hidden": false },
+                { "type": "bin", "section": "Core", "hidden": false },
+                { "type": "gyp", "section": "Core", "hidden": false },
+                { "type": "lib", "section": "Core", "hidden": false },
+                { "type": "src", "section": "Core", "hidden": false },
+                { "type": "test", "section": "Tests", "hidden": false },
+                { "type": "build", "section": "Core", "hidden": false },
+                { "type": "clean", "section": "Core", "hidden": false },
+                { "type": "configure", "section": "Core", "hidden": false },
+                { "type": "install", "section": "Core", "hidden": false },
+                { "type": "list", "section": "Core", "hidden": false },
+                { "type": "rebuild", "section": "Core", "hidden": false },
+                { "type": "remove", "section": "Core", "hidden": false },
+                { "type": "deps", "section": "Core", "hidden": false },
+                { "type": "python", "section": "Core", "hidden": false },
+                { "type": "lin", "section": "Core", "hidden": false },
+                { "type": "linux", "section": "Core", "hidden": false },
+                { "type": "mac", "section": "Core", "hidden": false },
+                { "type": "macos", "section": "Core", "hidden": false },
+                { "type": "win", "section": "Core", "hidden": false },
+                { "type": "windows", "section": "Core", "hidden": false },
+                { "type": "zos", "section": "Core", "hidden": false },
+                { "type": "doc", "section": "Doc", "hidden": false },
+                { "type": "docs", "section": "Doc", "hidden": false },
+                { "type": "readme", "section": "Doc", "hidden": false },
+                { "type": "chore", "section": "Miscellaneous", "hidden": false },
+                { "type": "refactor", "section": "Miscellaneous", "hidden": false },
+                { "type": "ci", "section": "Miscellaneous", "hidden": false },
+                { "type": "meta", "section": "Miscellaneous", "hidden": false }
+            ]
+        }
+    }
+}

package/external/node-gyp/src/win_delay_load_hook.cc

@@ -0,0 +1,41 @@
+/*
+ * When this file is linked to a DLL, it sets up a delay-load hook that
+ * intervenes when the DLL is trying to load the host executable
+ * dynamically. Instead of trying to locate the .exe file it'll just
+ * return a handle to the process image.
+ *
+ * This allows compiled addons to work when the host executable is renamed.
+ */
+
+#ifdef _MSC_VER
+
+#pragma managed(push, off)
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#include <delayimp.h>
+#include <string.h>
+
+static FARPROC WINAPI load_exe_hook(unsigned int event, DelayLoadInfo* info) {
+  HMODULE m;
+  if (event != dliNotePreLoadLibrary)
+    return NULL;
+
+  if (_stricmp(info->szDll, HOST_BINARY) != 0)
+    return NULL;
+
+  // try for libnode.dll to compat node.js that using 'vcbuild.bat dll'
+  m = GetModuleHandle(TEXT("libnode.dll"));
+  if (m == NULL) m = GetModuleHandle(NULL);
+  return (FARPROC) m;
+}
+
+decltype(__pfnDliNotifyHook2) __pfnDliNotifyHook2 = load_exe_hook;
+
+#pragma managed(pop)
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socketsecurity/cli-with-sentry",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "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",
@@ -155,6 +155,7 @@
     "micromatch": "4.0.8",
     "mock-fs": "5.5.0",
     "nock": "14.0.5",
+    "node-gyp": "11.2.0",
     "npm-package-arg": "12.0.2",
     "npm-run-all2": "8.0.4",
     "open": "10.1.2",