@nirvana-labs/nirvana 1.31.1 → 1.32.0

package/oidc/node_modules/npm/lib/utils/format-search-stream.js

@@ -0,0 +1,173 @@
+const { stripVTControlCharacters: strip } = require('node:util')
+const { Minipass } = require('minipass')
+
+// This module consumes package data in the following format:
+//
+// {
+//   name: String,
+//   description: String,
+//   maintainers: [{ username: String, email: String }],
+//   keywords: String | [String],
+//   version: String,
+//   date: Date // can be null,
+// }
+//
+// The returned stream will format this package data
+// into a byte stream of formatted, displayable output.
+
+function filter (data, exclude) {
+  const words = [data.name]
+    .concat(data.maintainers.map(m => m.username))
+    .concat(data.keywords || [])
+    .map(f => f?.trim?.())
+    .filter(Boolean)
+    .join(' ')
+    .toLowerCase()
+
+  if (exclude.find(pattern => {
+    // Treats both /foo and /foo/ as regex searches
+    if (pattern.startsWith('/')) {
+      if (pattern.endsWith('/')) {
+        pattern = pattern.slice(0, -1)
+      }
+      return words.match(new RegExp(pattern.slice(1)))
+    }
+    return words.includes(pattern)
+  })) {
+    return false
+  }
+
+  return true
+}
+
+module.exports = (opts) => {
+  return opts.json ? new JSONOutputStream(opts) : new TextOutputStream(opts)
+}
+
+class JSONOutputStream extends Minipass {
+  #didFirst = false
+  #exclude
+
+  constructor (opts) {
+    super()
+    this.#exclude = opts.exclude
+  }
+
+  write (obj) {
+    if (!filter(obj, this.#exclude)) {
+      return
+    }
+    if (!this.#didFirst) {
+      super.write('[\n')
+      this.#didFirst = true
+    } else {
+      super.write('\n,\n')
+    }
+
+    return super.write(JSON.stringify(obj))
+  }
+
+  end () {
+    super.write(this.#didFirst ? ']\n' : '\n[]\n')
+    super.end()
+  }
+}
+
+class TextOutputStream extends Minipass {
+  #args
+  #chalk
+  #exclude
+  #parseable
+
+  constructor (opts) {
+    super()
+    // Consider a search for "cowboys" and "boy".  If we highlight "boys" first the "cowboys" string will no longer string match because of the ansi highlighting added to "boys".  If we highlight "boy" second then the ansi reset at the end will make the highlighting only on "cowboy" with a normal "s".  Neither is perfect but at least the first option doesn't do partial highlighting. So, we sort strings smaller to larger
+    this.#args = opts.args
+      .map(s => s.toLowerCase())
+      .filter(Boolean)
+      .sort((a, b) => a.length - b.length)
+    this.#chalk = opts.npm.chalk
+    this.#exclude = opts.exclude
+    this.#parseable = opts.parseable
+  }
+
+  write (data) {
+    if (!filter(data, this.#exclude)) {
+      return
+    }
+    // Normalize
+    const pkg = {
+      authors: data.maintainers.map((m) => `${strip(m.username)}`).join(' '),
+      publisher: strip(data.publisher?.username || ''),
+      date: data.date ? data.date.toISOString().slice(0, 10) : 'prehistoric',
+      description: strip(data.description ?? ''),
+      keywords: [],
+      name: strip(data.name),
+      version: data.version,
+    }
+    if (Array.isArray(data.keywords)) {
+      pkg.keywords = data.keywords.map(strip)
+    } else if (typeof data.keywords === 'string') {
+      pkg.keywords = strip(data.keywords.replace(/[,\s]+/, ' ')).split(' ')
+    }
+
+    let output
+    if (this.#parseable) {
+      output = [pkg.name, pkg.description, pkg.author, pkg.date, pkg.version, pkg.keywords]
+        .filter(Boolean)
+        .map(col => ('' + col).replace(/\t/g, ' ')).join('\t')
+      return super.write(output)
+    }
+
+    const keywords = pkg.keywords.map(k => {
+      if (this.#args.includes(k)) {
+        return this.#chalk.cyan(k)
+      } else {
+        return k
+      }
+    }).join(' ')
+
+    const description = this.#highlight(pkg.description)
+    let name
+    if (this.#args.includes(pkg.name)) {
+      name = this.#chalk.cyan(pkg.name)
+    } else {
+      name = this.#highlight(pkg.name)
+      name = this.#chalk.blue(name)
+    }
+
+    if (description.length) {
+      output = `${name}\n${description}\n`
+    } else {
+      output = `${name}\n`
+    }
+    if (pkg.publisher) {
+      output += `Version ${this.#chalk.blue(pkg.version)} published ${this.#chalk.blue(pkg.date)} by ${this.#chalk.blue(pkg.publisher)}\n`
+    } else {
+      output += `Version ${this.#chalk.blue(pkg.version)} published ${this.#chalk.blue(pkg.date)} by ${this.#chalk.yellow('???')}\n`
+    }
+    output += `Maintainers: ${pkg.authors}\n`
+    if (keywords) {
+      output += `Keywords: ${keywords}\n`
+    }
+    output += `${this.#chalk.blue(`https://npm.im/${pkg.name}`)}\n`
+    return super.write(output)
+  }
+
+  #highlight (input) {
+    let output = input
+    for (const arg of this.#args) {
+      let i = output.toLowerCase().indexOf(arg)
+      while (i > -1) {
+        const highlit = this.#chalk.cyan(output.slice(i, i + arg.length))
+        output = [
+          output.slice(0, i),
+          highlit,
+          output.slice(i + arg.length),
+        ].join('')
+        i = output.toLowerCase().indexOf(arg, i + highlit.length)
+      }
+    }
+    return output
+  }
+}

package/oidc/node_modules/npm/lib/utils/format.js

@@ -0,0 +1,56 @@
+// All logging goes through here, both to console and log files
+
+const { formatWithOptions: baseFormatWithOptions } = require('node:util')
+const { redactLog } = require('@npmcli/redact')
+
+// These are most assuredly not a mistake
+// https://eslint.org/docs/latest/rules/no-control-regex
+// \x00 through \x1f, \x7f through \x9f, not including \x09 \x0a \x0b \x0d
+/* eslint-disable-next-line no-control-regex */
+const HAS_C01 = /[\x00-\x08\x0c\x0e-\x1f\x7f-\x9f]/
+
+// Allows everything up to '[38;5;255m' in 8 bit notation
+const ALLOWED_SGR = /^\[[0-9;]{0,8}m/
+
+// '[38;5;255m'.length
+const SGR_MAX_LEN = 10
+
+// Strips all ANSI C0 and C1 control characters (except for SGR up to 8 bit)
+function STRIP_C01 (str) {
+  if (!HAS_C01.test(str)) {
+    return str
+  }
+  let result = ''
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i]
+    const code = char.charCodeAt(0)
+    if (!HAS_C01.test(char)) {
+      // Most characters are in this set so continue early if we can
+      result = `${result}${char}`
+    } else if (code === 27 && ALLOWED_SGR.test(str.slice(i + 1, i + SGR_MAX_LEN + 1))) {
+      // \x1b with allowed SGR
+      result = `${result}\x1b`
+    } else if (code <= 31) {
+      // escape all other C0 control characters besides \x7f
+      result = `${result}^${String.fromCharCode(code + 64)}`
+    } else {
+      // hasC01 ensures this is now a C1 control character or \x7f
+      result = `${result}^${String.fromCharCode(code - 64)}`
+    }
+  }
+  return result
+}
+
+const formatWithOptions = ({ prefix: prefixes = [], eol = '\n', redact = true, ...options }, ...args) => {
+  const prefix = prefixes.filter(p => p != null).join(' ')
+  let formatted = STRIP_C01(baseFormatWithOptions(options, ...args))
+  if (redact) {
+    formatted = redactLog(formatted)
+  }
+  // Splitting could be changed to only `\n` once we are sure we only emit unix newlines.
+  // The eol param to this function will put the correct newlines in place for the returned string.
+  const lines = formatted.split(/\r?\n/)
+  return lines.reduce((acc, l) => `${acc}${prefix}${prefix && l ? ' ' : ''}${l}${eol}`, '')
+}
+
+module.exports = { formatWithOptions }

package/oidc/node_modules/npm/lib/utils/get-identity.js

@@ -0,0 +1,26 @@
+const npmFetch = require('npm-registry-fetch')
+
+module.exports = async (npm, opts) => {
+  const { registry } = opts
+
+  // First, check if we have a user/pass-based auth
+  const creds = npm.config.getCredentialsByURI(registry)
+  if (creds.username) {
+    return creds.username
+  }
+
+  // No username, but we have other credentials; fetch the username from registry
+  if (creds.token || creds.certfile && creds.keyfile) {
+    const registryData = await npmFetch.json('/-/whoami', { ...opts })
+    if (typeof registryData?.username === 'string') {
+      return registryData.username
+    }
+  }
+
+  // At this point, even if they have a credentials object, it doesn't have a
+  // valid token.
+  throw Object.assign(
+    new Error('This command requires you to be logged in.'),
+    { code: 'ENEEDAUTH' }
+  )
+}

package/oidc/node_modules/npm/lib/utils/get-workspaces.js

@@ -0,0 +1,54 @@
+const { resolve, relative } = require('node:path')
+const mapWorkspaces = require('@npmcli/map-workspaces')
+const { minimatch } = require('minimatch')
+const pkgJson = require('@npmcli/package-json')
+
+// minimatch wants forward slashes only for glob patterns
+const globify = pattern => pattern.split('\\').join('/')
+
+// Returns an Map of paths to workspaces indexed by workspace name
+// { foo => '/path/to/foo' }
+const getWorkspaces = async (filters, { path, includeWorkspaceRoot, relativeFrom }) => {
+  // TODO we need a better error to be bubbled up here if this call fails
+  const { content: pkg } = await pkgJson.normalize(path)
+  const workspaces = await mapWorkspaces({ cwd: path, pkg })
+  let res = new Map()
+  if (includeWorkspaceRoot) {
+    res.set(pkg.name, path)
+  }
+
+  if (!filters.length) {
+    res = new Map([...res, ...workspaces])
+  }
+
+  for (const filterArg of filters) {
+    for (const [workspaceName, workspacePath] of workspaces.entries()) {
+      let relativePath = relative(relativeFrom, workspacePath)
+      if (filterArg.startsWith('./')) {
+        relativePath = `./${relativePath}`
+      }
+      const relativeFilter = relative(path, filterArg)
+      if (filterArg === workspaceName
+        || resolve(relativeFrom, filterArg) === workspacePath
+        || minimatch(relativePath, `${globify(relativeFilter)}/*`)
+        || minimatch(relativePath, `${globify(filterArg)}/*`)
+      ) {
+        res.set(workspaceName, workspacePath)
+      }
+    }
+  }
+
+  if (!res.size) {
+    let msg = '!'
+    if (filters.length) {
+      msg = `:\n ${filters.reduce(
+        (acc, filterArg) => `${acc} --workspace=${filterArg}`, '')}`
+    }
+
+    throw new Error(`No workspaces found${msg}`)
+  }
+
+  return res
+}
+
+module.exports = getWorkspaces

package/oidc/node_modules/npm/lib/utils/installed-deep.js

@@ -0,0 +1,45 @@
+const { resolve } = require('node:path')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+
+const installedDeep = async (npm) => {
+  const Arborist = require('@npmcli/arborist')
+  const {
+    depth,
+    global,
+    prefix,
+    workspacesEnabled,
+  } = npm.flatOptions
+
+  const getValues = (tree) =>
+    [...tree.inventory.values()]
+      .filter(i => i.location !== '' && !i.isRoot)
+      .map(i => {
+        return i
+      })
+      .filter(i => (i.depth - 1) <= depth)
+      .sort((a, b) => (a.depth - b.depth) || localeCompare(a.name, b.name))
+
+  const res = new Set()
+  const gArb = new Arborist({
+    global: true,
+    path: resolve(npm.globalDir, '..'),
+    workspacesEnabled,
+  })
+  const gTree = await gArb.loadActual({ global: true })
+
+  for (const node of getValues(gTree)) {
+    res.add(global ? node.name : [node.name, '-g'])
+  }
+
+  if (!global) {
+    const arb = new Arborist({ global: false, path: prefix, workspacesEnabled })
+    const tree = await arb.loadActual()
+    for (const node of getValues(tree)) {
+      res.add(node.name)
+    }
+  }
+
+  return [...res]
+}
+
+module.exports = installedDeep

package/oidc/node_modules/npm/lib/utils/installed-shallow.js

@@ -0,0 +1,19 @@
+const { readdirScoped } = require('@npmcli/fs')
+
+const installedShallow = async (npm, opts) => {
+  const names = async global => {
+    const paths = await readdirScoped(global ? npm.globalDir : npm.localDir)
+    return paths.map(p => p.replace(/\\/g, '/'))
+  }
+  const { conf: { argv: { remain } } } = opts
+  if (remain.length > 3) {
+    return null
+  }
+
+  const { global } = npm.flatOptions
+  const locals = global ? [] : await names(false)
+  const globals = (await names(true)).map(n => global ? n : `${n} -g`)
+  return [...locals, ...globals]
+}
+
+module.exports = installedShallow

package/oidc/node_modules/npm/lib/utils/is-windows.js

@@ -0,0 +1,4 @@
+const isWindowsShell = (process.platform === 'win32') &&
+  !/^MINGW(32|64)$/.test(process.env.MSYSTEM) && process.env.TERM !== 'cygwin'
+
+exports.isWindowsShell = isWindowsShell

package/oidc/node_modules/npm/lib/utils/log-file.js

@@ -0,0 +1,261 @@
+const os = require('node:os')
+const { join, dirname, basename } = require('node:path')
+const fsMiniPass = require('fs-minipass')
+const fs = require('node:fs/promises')
+const { log } = require('proc-log')
+const { formatWithOptions } = require('./format')
+
+const padZero = (n, length) => n.toString().padStart(length.toString().length, '0')
+
+class LogFiles {
+  // Default to an array so we can buffer
+  // initial writes before we know the cache location
+  #logStream = []
+
+  // We cap log files at a certain number of log events per file.
+  // Note that each log event can write more than one line to the
+  // file. Then we rotate log files once this number of events is reached
+  #MAX_LOGS_PER_FILE = null
+
+  // Now that we write logs continuously we need to have a backstop
+  // here for infinite loops that still log. This is also partially handled
+  // by the config.get('max-files') option, but this is a failsafe to
+  // prevent runaway log file creation
+  #MAX_FILES_PER_PROCESS = null
+
+  #fileLogCount = 0
+  #totalLogCount = 0
+  #path = null
+  #logsMax = null
+  #files = []
+  #timing = false
+
+  constructor ({
+    maxLogsPerFile = 50_000,
+    maxFilesPerProcess = 5,
+  } = {}) {
+    this.#MAX_LOGS_PER_FILE = maxLogsPerFile
+    this.#MAX_FILES_PER_PROCESS = maxFilesPerProcess
+    this.on()
+  }
+
+  on () {
+    process.on('log', this.#logHandler)
+  }
+
+  off () {
+    process.off('log', this.#logHandler)
+    this.#endStream()
+  }
+
+  load ({ command, path, logsMax = Infinity, timing } = {}) {
+    if (['completion'].includes(command)) {
+      return
+    }
+
+    // dir is user configurable and is required to exist so
+    // this can error if the dir is missing or not configured correctly
+    this.#path = path
+    this.#logsMax = logsMax
+    this.#timing = timing
+
+    // Log stream has already ended
+    if (!this.#logStream) {
+      return
+    }
+
+    log.verbose('logfile', `logs-max:${logsMax} dir:${this.#path}`)
+
+    // Write the contents of our array buffer to our new file stream and
+    // set that as the new log logstream for future writes
+    // if logs max is 0 then the user does not want a log file
+    if (this.#logsMax > 0) {
+      const initialFile = this.#openLogFile()
+      if (initialFile) {
+        for (const item of this.#logStream) {
+          const formatted = this.#formatLogItem(...item)
+          if (formatted !== null) {
+            initialFile.write(formatted)
+          }
+        }
+        this.#logStream = initialFile
+      }
+    }
+
+    log.verbose('logfile', this.files[0] || 'no logfile created')
+
+    // Kickoff cleaning process, even if we aren't writing a logfile.
+    // This is async but it will always ignore the current logfile
+    // Return the result so it can be awaited in tests
+    return this.#cleanLogs()
+  }
+
+  get files () {
+    return this.#files
+  }
+
+  get #isBuffered () {
+    return Array.isArray(this.#logStream)
+  }
+
+  #endStream (output) {
+    if (this.#logStream && !this.#isBuffered) {
+      this.#logStream.end(output)
+      this.#logStream = null
+    }
+  }
+
+  #logHandler = (level, ...args) => {
+    // Ignore pause and resume events since we
+    // write everything to the log file
+    if (level === 'pause' || level === 'resume') {
+      return
+    }
+
+    // If the stream is ended then do nothing
+    if (!this.#logStream) {
+      return
+    }
+
+    if (this.#isBuffered) {
+      // Cant do anything but buffer the output if we don't
+      // have a file stream yet
+      this.#logStream.push([level, ...args])
+      return
+    }
+
+    const logOutput = this.#formatLogItem(level, ...args)
+    if (logOutput === null) {
+      return
+    }
+
+    // Open a new log file if we've written too many logs to this one
+    if (this.#fileLogCount >= this.#MAX_LOGS_PER_FILE) {
+      // Write last chunk to the file and close it
+      this.#endStream(logOutput)
+      if (this.#files.length >= this.#MAX_FILES_PER_PROCESS) {
+        // but if its way too many then we just stop listening
+        this.off()
+      } else {
+        // otherwise we are ready for a new file for the next event
+        this.#logStream = this.#openLogFile()
+      }
+    } else {
+      this.#logStream.write(logOutput)
+    }
+  }
+
+  #formatLogItem (level, title, ...args) {
+    // Only right timing logs to logfile if explicitly requests
+    if (level === log.KEYS.timing && !this.#timing) {
+      return null
+    }
+
+    this.#fileLogCount += 1
+    const prefix = [this.#totalLogCount++, level, title || null]
+    return formatWithOptions({ prefix, eol: os.EOL, colors: false }, ...args)
+  }
+
+  #getLogFilePath (count = '') {
+    return `${this.#path}debug-${count}.log`
+  }
+
+  #openLogFile () {
+    // Count in filename will be 0 indexed
+    const count = this.#files.length
+
+    try {
+      // Pad with zeros so that our log files are always sorted properly
+      // We never want to write files ending in `-9.log` and `-10.log` because
+      // log file cleaning is done by deleting the oldest so in this example
+      // `-10.log` would be deleted next
+      const f = this.#getLogFilePath(padZero(count, this.#MAX_FILES_PER_PROCESS))
+      // Some effort was made to make the async, but we need to write logs
+      // during process.on('exit') which has to be synchronous. So in order
+      // to never drop log messages, it is easiest to make it sync all the time
+      // and this was measured to be about 1.5% slower for 40k lines of output
+      const logStream = new fsMiniPass.WriteStreamSync(f, { flags: 'a' })
+      if (count > 0) {
+        // Reset file log count if we are opening
+        // after our first file
+        this.#fileLogCount = 0
+      }
+      this.#files.push(logStream.path)
+      return logStream
+    } catch (e) {
+      // If the user has a readonly logdir then we don't want to
+      // warn this on every command so it should be verbose
+      log.verbose('logfile', `could not be created: ${e}`)
+    }
+  }
+
+  async #cleanLogs () {
+    // module to clean out the old log files
+    // this is a best-effort attempt.  if a rm fails, we just
+    // log a message about it and move on.  We do return a
+    // Promise that succeeds when we've tried to delete everything,
+    // just for the benefit of testing this function properly.
+
+    try {
+      const logPath = this.#getLogFilePath()
+      const patternFileName = basename(logPath)
+        // tell glob to only match digits
+        .replace(/\d/g, 'd')
+        // Handle the old (prior to 8.2.0) log file names which did not have a
+        // counter suffix
+        .replace('-.log', '')
+
+      let files = await fs.readdir(
+        dirname(logPath), {
+          withFileTypes: true,
+          encoding: 'utf-8',
+        })
+      files = files.sort((a, b) => basename(a.name).localeCompare(basename(b.name), 'en'))
+
+      const logFiles = []
+
+      for (const file of files) {
+        if (!file.isFile()) {
+          continue
+        }
+
+        const genericFileName = file.name.replace(/\d/g, 'd')
+        const filePath = join(dirname(logPath), basename(file.name))
+
+        // Always ignore the currently written files
+        if (
+          genericFileName.includes(patternFileName)
+          && genericFileName.endsWith('.log')
+          && !this.#files.includes(filePath)
+        ) {
+          logFiles.push(filePath)
+        }
+      }
+
+      const toDelete = logFiles.length - this.#logsMax
+
+      if (toDelete <= 0) {
+        return
+      }
+
+      log.silly('logfile', `start cleaning logs, removing ${toDelete} files`)
+
+      for (const file of logFiles.slice(0, toDelete)) {
+        try {
+          await fs.rm(file, { force: true })
+        } catch (e) {
+          log.silly('logfile', 'error removing log file', file, e)
+        }
+      }
+    } catch (e) {
+      // Disable cleanup failure warnings when log writing is disabled
+      if (this.#logsMax > 0) {
+        log.verbose('logfile', 'error cleaning log files', e)
+      }
+    } finally {
+      log.silly('logfile', 'done cleaning log files')
+    }
+  }
+}
+
+module.exports = LogFiles