@aeolus-fleet/console 0.29.2 → 0.30.1

package/.next/standalone/packages/console/.next/node_modules/import-in-the-middle-ac114f323ad7e863/lib/register.js

@@ -0,0 +1,285 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
+//
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
+
+const importHooks = [] // TODO should this be a Set?
+const binders = new WeakMap()
+let legacySetters
+let legacyGetters
+let legacyProxyHandler
+const specifiers = new Map()
+const toHook = []
+
+/**
+ * @param {object} source The module namespace.
+ * @param {string | symbol} name The export name.
+ */
+function readExport (source, name) {
+  if (name === 'module.exports' && !Object.hasOwn(source, name)) {
+    return source.default
+  }
+  return source[name]
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {unknown} value The replacement value.
+ */
+function setExport (target, name, value) {
+  return binders.get(target).write(name, value)
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {PropertyDescriptor} descriptor The replacement descriptor.
+ */
+function defineExport (target, name, descriptor) {
+  if (!('value' in descriptor)) {
+    throw new Error('Getters/setters are not supported for exports property descriptors.')
+  }
+  return setExport(target, name, descriptor.value)
+}
+
+const proxyHandler = { defineProperty: defineExport, set: setExport }
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {unknown} value The replacement value.
+ */
+function setLegacyExport (target, name, value) {
+  const setter = legacySetters.get(target)?.[name]
+  return typeof setter === 'function' ? setter(value) : true
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ */
+function getLegacyExport (target, name) {
+  if (name === Symbol.toStringTag) return 'Module'
+
+  const getter = legacyGetters.get(target)[name]
+  if (typeof getter === 'function') return getter()
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {PropertyDescriptor} descriptor The replacement descriptor.
+ */
+function defineLegacyExport (target, name, descriptor) {
+  if (!('value' in descriptor)) {
+    throw new Error('Getters/setters are not supported for exports property descriptors.')
+  }
+  return setLegacyExport(target, name, descriptor.value)
+}
+
+/**
+ * @param {string} name The wrapped module URL.
+ * @param {object} namespace The wrapper's module namespace.
+ * @param {object} set The wrapper's export setters.
+ * @param {object} get The wrapper's export getters.
+ * @param {string} specifier The original import specifier.
+ */
+function registerLegacy (name, namespace, set, get, specifier) {
+  legacySetters ??= new WeakMap()
+  legacyGetters ??= new WeakMap()
+  legacyProxyHandler ??= {
+    defineProperty: defineLegacyExport,
+    get: getLegacyExport,
+    set: setLegacyExport
+  }
+  specifiers.set(name, specifier)
+  legacySetters.set(namespace, set)
+  legacyGetters.set(namespace, get)
+  const proxy = new Proxy(namespace, legacyProxyHandler)
+  importHooks.forEach(hook => hook(name, proxy, specifier))
+  toHook.push([name, proxy, specifier])
+}
+
+/**
+ * @param {string} name The wrapped module URL.
+ * @param {ModuleBinder | object} binder The wrapper's binding state or legacy namespace.
+ * @param {string | object} specifier The original import specifier or legacy setters.
+ * @param {object} [get] The legacy export getters.
+ * @param {string} [legacySpecifier] The legacy original import specifier.
+ */
+function register (name, binder, specifier, get, legacySpecifier) {
+  if (arguments.length === 5) {
+    registerLegacy(name, binder, specifier, get, legacySpecifier)
+    return
+  }
+
+  const { namespace } = binder
+  specifiers.set(name, specifier)
+  binders.set(namespace, binder)
+  const proxy = new Proxy(namespace, proxyHandler)
+  importHooks.forEach(hook => hook(name, proxy, specifier))
+  toHook.push([name, proxy, specifier])
+}
+
+// Delays (ms) for re-reading exports that were still in their temporal dead zone
+// when the wrapper first ran (circular imports). Retried on a microtask first,
+// then at these intervals; unref'd so best-effort retries never hold the process
+// open. Frozen once at module load rather than rebuilt per wrapper.
+const RETRY_DELAYS = [0, 10, 50]
+
+/**
+ * Per-wrapped-module state a generated wrapper builds once to expose its exports
+ * through iitm's proxy. Each wrapper supplies one indexed writer for all local
+ * bindings; the constructor seeds them from the real module, and `flush`
+ * resolves any export that was undefined (circular import) once it becomes available.
+ *
+ * This is the boilerplate the wrapper used to inline in full per module. Hoisting
+ * it here compiles the retry and proxy bookkeeping once instead of once per
+ * wrapped module.
+ */
+class ModuleBinder {
+  // Mimics a Module namespace object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+  namespace = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } })
+  #set = Object.create(null)
+  #write
+  #overridden
+  #pending
+
+  /**
+   * @param {object} source The wrapped module namespace.
+   * @param {string[]} [keys] Export names in wrapper-binding order.
+   * @param {(index: number, value: unknown) => void} [write] Assigns a wrapper binding by index.
+   * @param {object[]} [sources] Alternate namespaces for star-collision bindings.
+   */
+  constructor (source, keys, write, sources) {
+    this.#write = write
+    if (keys !== undefined) {
+      for (let index = 0; index < keys.length; index++) {
+        this.#bind(keys[index], index, sources?.[index] ?? source)
+      }
+    }
+  }
+
+  /**
+   * Seeds `key` from `source` and installs its proxy accessors. A value that is
+   * undefined or throws `ReferenceError` (temporal dead zone during a circular
+   * import) is deferred to `flush`; any other throw propagates.
+   *
+   * @param {string} key The export name.
+   * @param {number} index The wrapper binding index.
+   * @param {object} source The binding's source namespace.
+   * @returns {void}
+   */
+  #bind (key, index, source) {
+    let value
+    try {
+      value = readExport(source, key)
+      this.#write(index, value)
+      this.namespace[key] = value
+    } catch (error) {
+      if (!(error instanceof ReferenceError)) throw error
+    }
+    if (value === undefined) {
+      (this.#pending ??= []).push(this.#makeUpdater(key, index, source))
+    }
+    this.#set[key] = index
+  }
+
+  /**
+   * @param {string | symbol} key The export name.
+   * @param {unknown} value The replacement value.
+   * @returns {boolean}
+   */
+  write (key, value) {
+    const index = this.#set[key]
+    if (index !== undefined) {
+      this.#write(index, value)
+      if (this.#pending !== undefined) {
+        this.#overridden ??= Object.create(null)
+        this.#overridden[key] = true
+      }
+      this.namespace[key] = value
+    }
+    return true
+  }
+
+  /**
+   * @param {string} key The export name to update.
+   * @param {number} index The wrapper binding index.
+   * @param {object} source The real module namespace.
+   * @returns {() => boolean} Updater returning whether the value is now settled.
+   */
+  #makeUpdater (key, index, source) {
+    return () => {
+      if (this.#overridden?.[key] === true) return true
+      try {
+        const value = readExport(source, key)
+        if (value !== undefined) {
+          this.#write(index, value)
+          this.namespace[key] = value
+          return true
+        }
+        return false
+      } catch (error) {
+        if (error instanceof ReferenceError) return false
+        // Only reached if a getter starts throwing a non-ReferenceError after the
+        // initial bind read already succeeded or deferred; surfaces in flush's
+        // microtask. Kept as-is from the inline wrapper.
+        /* c8 ignore next */
+        throw error
+      }
+    }
+  }
+
+  #flushOnce () {
+    const pending = this.#pending
+    if (pending === undefined) return
+
+    let next
+    for (const updater of pending) {
+      // If it still throws ReferenceError, keep it for the (single) next attempt.
+      if (updater() !== true) (next ??= []).push(updater)
+    }
+    this.#pending = next
+  }
+
+  /**
+   * Resolves exports deferred by `bind` (undefined or TDZ at wrapper-eval time).
+   * Retries on a microtask, then at `RETRY_DELAYS`, giving up afterwards to avoid
+   * unbounded retries. A no-op when nothing was deferred.
+   *
+   * @returns {void}
+   */
+  flush () {
+    if (this.#pending === undefined) return
+    queueMicrotask(() => {
+      this.#flushOnce()
+      this.#scheduleRetry(0)
+    })
+  }
+
+  /**
+   * @param {number} attempt Index into `RETRY_DELAYS` for the next retry.
+   * @returns {void}
+   */
+  #scheduleRetry (attempt) {
+    if (this.#pending === undefined) return
+    if (attempt >= RETRY_DELAYS.length) {
+      // Give up: leave exports as-is to avoid unbounded retries.
+      this.#pending = undefined
+      return
+    }
+    const timer = setTimeout(() => {
+      this.#flushOnce()
+      this.#scheduleRetry(attempt + 1)
+    }, RETRY_DELAYS[attempt])
+    // Don't keep the process alive just for best-effort retries.
+    if (timer && typeof timer.unref === 'function') timer.unref()
+  }
+}
+
+exports.register = register
+exports.ModuleBinder = ModuleBinder
+exports.importHooks = importHooks
+exports.specifiers = specifiers
+exports.toHook = toHook

package/.next/standalone/packages/console/.next/node_modules/import-in-the-middle-ac114f323ad7e863/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "import-in-the-middle",
+  "version": "3.5.2",
+  "description": "Intercept imports in Node.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "c8 --reporter lcov --check-coverage --lines 45 imhotap --files test/{hook,low-level,other,get-esm-exports,register}/*",
+    "test:e2e": "node test/check-exports/test.mjs && node test/integration-tests/turbopack-dev.mjs && node test/integration-tests/turbopack-build-start.mjs",
+    "test:ts": "c8 --reporter lcov imhotap --files test/typescript/*.test.mts",
+    "coverage": "c8 --reporter html imhotap --files test/{hook,low-level,other,get-esm-exports,register}/* && echo \"\nNow open coverage/index.html\n\"",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/nodejs/import-in-the-middle.git"
+  },
+  "keywords": [
+    "import",
+    "ritm",
+    "iitm",
+    "loader",
+    "hook",
+    "hooks"
+  ],
+  "author": "Bryan English <bryan.english@datadoghq.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/nodejs/import-in-the-middle/issues"
+  },
+  "homepage": "https://github.com/nodejs/import-in-the-middle#readme",
+  "imhotap": {
+    "runner": "node",
+    "test-env": "NODE_OPTIONS=--no-warnings --require ./test/version-check.js --experimental-loader ./test/generic-loader.mjs"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/eslint-parser": "^7.28.5",
+    "@babel/plugin-syntax-import-assertions": "^7.27.1",
+    "@node-rs/crc32": "^1.10.6",
+    "@react-email/components": "^0.0.19",
+    "@types/node": "^18.0.6",
+    "c8": "^7.14.0",
+    "date-fns": "^3.6.0",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.6.0",
+    "got": "^14.6.6",
+    "imhotap": "^2.2.0",
+    "openai": "4.47.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5",
+    "vue": "^3.5.26"
+  },
+  "dependencies": {
+    "cjs-module-lexer": "^2.2.0",
+    "es-module-lexer": "^3.0.2",
+    "module-details-from-path": "^1.0.4"
+  }
+}

package/.next/standalone/packages/console/.next/node_modules/require-in-the-middle-2ca7b9c2766f317e/index.js

@@ -0,0 +1,333 @@
+'use strict'
+
+const path = require('path')
+const Module = require('module')
+const debug = require('debug')('require-in-the-middle')
+const moduleDetailsFromPath = require('module-details-from-path')
+
+// Using the default export is discouraged, but kept for backward compatibility.
+// Use this instead:
+//    const { Hook } = require('require-in-the-middle')
+module.exports = Hook
+module.exports.Hook = Hook
+
+let builtinModules // Set<string>
+
+/**
+ * Is the given module a "core" module?
+ * https://nodejs.org/api/modules.html#core-modules
+ *
+ * @type {(moduleName: string) => boolean}
+ */
+let isCore
+if (Module.isBuiltin) { // Added in node v18.6.0, v16.17.0
+  isCore = Module.isBuiltin
+} else if (Module.builtinModules) { // Added in node v9.3.0, v8.10.0, v6.13.0
+  isCore = moduleName => {
+    if (moduleName.startsWith('node:')) {
+      return true
+    }
+
+    if (builtinModules === undefined) {
+      builtinModules = new Set(Module.builtinModules)
+    }
+
+    return builtinModules.has(moduleName)
+  }
+} else {
+  throw new Error('\'require-in-the-middle\' requires Node.js >=v9.3.0 or >=v8.10.0')
+}
+
+// 'foo/bar.js' or 'foo/bar/index.js' => 'foo/bar'
+const normalize = /([/\\]index)?(\.js)?$/
+
+// Cache `onrequire`-patched exports for modules.
+//
+// Exports for built-in (a.k.a. "core") modules are stored in an internal Map.
+//
+// Exports for non-core modules are stored on a private field on the `Module`
+// object in `require.cache`. This allows users to delete from `require.cache`
+// to trigger a re-load (and re-run of the hook's `onrequire`) of a module the
+// next time it is required.
+// https://nodejs.org/docs/latest/api/all.html#all_modules_requirecache
+//
+// In some special cases -- e.g. some other `require()` hook swapping out
+// `Module._cache` like `@babel/register` -- a non-core module won't be in
+// `require.cache`. In that case this falls back to caching on the internal Map.
+class ExportsCache {
+  constructor () {
+    this._localCache = new Map() // <module filename or id> -> <exports>
+    this._kRitmExports = Symbol('RitmExports')
+  }
+
+  has (filename, isBuiltin) {
+    if (this._localCache.has(filename)) {
+      return true
+    } else if (!isBuiltin) {
+      const mod = require.cache[filename]
+      return !!(mod && this._kRitmExports in mod)
+    } else {
+      return false
+    }
+  }
+
+  get (filename, isBuiltin) {
+    const cachedExports = this._localCache.get(filename)
+    if (cachedExports !== undefined) {
+      return cachedExports
+    } else if (!isBuiltin) {
+      const mod = require.cache[filename]
+      return (mod && mod[this._kRitmExports])
+    }
+  }
+
+  set (filename, exports, isBuiltin) {
+    if (isBuiltin) {
+      this._localCache.set(filename, exports)
+    } else if (filename in require.cache) {
+      require.cache[filename][this._kRitmExports] = exports
+    } else {
+      debug('non-core module is unexpectedly not in require.cache: "%s"', filename)
+      this._localCache.set(filename, exports)
+    }
+  }
+}
+
+function Hook (modules, options, onrequire) {
+  if ((this instanceof Hook) === false) return new Hook(modules, options, onrequire)
+  if (typeof modules === 'function') {
+    onrequire = modules
+    modules = null
+    options = null
+  } else if (typeof options === 'function') {
+    onrequire = options
+    options = null
+  }
+
+  if (typeof Module._resolveFilename !== 'function') {
+    console.error('Error: Expected Module._resolveFilename to be a function (was: %s) - aborting!', typeof Module._resolveFilename)
+    console.error('Please report this error as an issue related to Node.js %s at https://github.com/nodejs/require-in-the-middle/issues', process.version)
+    return
+  }
+
+  this._cache = new ExportsCache()
+
+  this._unhooked = false
+  this._origRequire = Module.prototype.require
+
+  const self = this
+  const patching = new Set()
+  const internals = options ? options.internals === true : false
+  const hasWhitelist = Array.isArray(modules)
+
+  debug('registering require hook')
+
+  this._require = Module.prototype.require = function (id) {
+    if (self._unhooked === true) {
+      // if the patched require function could not be removed because
+      // someone else patched it after it was patched here, we just
+      // abort and pass the request onwards to the original require
+      debug('ignoring require call - module is soft-unhooked')
+      return self._origRequire.apply(this, arguments)
+    }
+
+    return patchedRequire.call(this, arguments, false)
+  }
+
+  if (typeof process.getBuiltinModule === 'function') {
+    this._origGetBuiltinModule = process.getBuiltinModule
+    this._getBuiltinModule = process.getBuiltinModule = function (id) {
+      if (self._unhooked === true) {
+        // if the patched process.getBuiltinModule function could not be removed because
+        // someone else patched it after it was patched here, we just abort and pass the
+        // request onwards to the original process.getBuiltinModule
+        debug('ignoring process.getBuiltinModule call - module is soft-unhooked')
+        return self._origGetBuiltinModule.apply(this, arguments)
+      }
+
+      return patchedRequire.call(this, arguments, true)
+    }
+  }
+
+  // Preserve the original require/process.getBuiltinModule arguments in `args`
+  function patchedRequire (args, coreOnly) {
+    const id = args[0]
+    const core = isCore(id)
+    let filename // the string used for caching
+    if (core) {
+      filename = id
+      // If this is a builtin module that can be identified both as 'foo' and
+      // 'node:foo', then prefer 'foo' as the caching key.
+      if (id.startsWith('node:')) {
+        const idWithoutPrefix = id.slice(5)
+        if (isCore(idWithoutPrefix)) {
+          filename = idWithoutPrefix
+        }
+      }
+    } else if (coreOnly) {
+      // `coreOnly` is `true` if this was a call to `process.getBuiltinModule`, in which case
+      // we don't want to return anything if the requested `id` isn't a core module. Falling
+      // back to default behaviour, which at the time of this wrting is simply returning `undefined`
+      debug('call to process.getBuiltinModule with unknown built-in id')
+      return self._origGetBuiltinModule.apply(this, args)
+    } else {
+      try {
+        filename = Module._resolveFilename(id, this)
+      } catch (resolveErr) {
+        // If someone *else* monkey-patches before this monkey-patch, then that
+        // code might expect `require(someId)` to get through so it can be
+        // handled, even if `someId` cannot be resolved to a filename. In this
+        // case, instead of throwing we defer to the underlying `require`.
+        //
+        // For example the Azure Functions Node.js worker module does this,
+        // where `@azure/functions-core` resolves to an internal object.
+        // https://github.com/Azure/azure-functions-nodejs-worker/blob/v3.5.2/src/setupCoreModule.ts#L46-L54
+        debug('Module._resolveFilename("%s") threw %j, calling original Module.require', id, resolveErr.message)
+        return self._origRequire.apply(this, args)
+      }
+    }
+
+    let moduleName, basedir
+
+    debug('processing %s module require(\'%s\'): %s', core === true ? 'core' : 'non-core', id, filename)
+
+    // return known patched modules immediately
+    if (self._cache.has(filename, core) === true) {
+      debug('returning already patched cached module: %s', filename)
+      return self._cache.get(filename, core)
+    }
+
+    // Check if this module has a patcher in-progress already.
+    // Otherwise, mark this module as patching in-progress.
+    const isPatching = patching.has(filename)
+    if (isPatching === false) {
+      patching.add(filename)
+    }
+
+    const exports = coreOnly
+      ? self._origGetBuiltinModule.apply(this, args)
+      : self._origRequire.apply(this, args)
+
+    // If it's already patched, just return it as-is.
+    if (isPatching === true) {
+      debug('module is in the process of being patched already - ignoring: %s', filename)
+      return exports
+    }
+
+    // The module has already been loaded,
+    // so the patching mark can be cleaned up.
+    patching.delete(filename)
+
+    if (core === true) {
+      if (hasWhitelist === true && modules.includes(filename) === false) {
+        debug('ignoring core module not on whitelist: %s', filename)
+        return exports // abort if module name isn't on whitelist
+      }
+      moduleName = filename
+    } else if (hasWhitelist === true && modules.includes(filename)) {
+      // whitelist includes the absolute path to the file including extension
+      const parsedPath = path.parse(filename)
+      moduleName = parsedPath.name
+      basedir = parsedPath.dir
+    } else {
+      const stat = moduleDetailsFromPath(filename)
+      if (stat === undefined) {
+        debug('could not parse filename: %s', filename)
+        return exports // abort if filename could not be parsed
+      }
+      moduleName = stat.name
+      basedir = stat.basedir
+
+      // Ex: require('foo/lib/../bar.js')
+      // moduleName = 'foo'
+      // fullModuleName = 'foo/bar'
+      const fullModuleName = resolveModuleName(stat)
+
+      debug('resolved filename to module: %s (id: %s, resolved: %s, basedir: %s)', moduleName, id, fullModuleName, basedir)
+
+      let matchFound = false
+      if (hasWhitelist) {
+        if (!id.startsWith('.') && modules.includes(id)) {
+          // Not starting with '.' means `id` is identifying a module path,
+          // as opposed to a local file path. (Note: I'm not sure about
+          // absolute paths, but those are handled above.)
+          // If this `id` is in `modules`, then this could be a match to an
+          // package "exports" entry point that wouldn't otherwise match below.
+          moduleName = id
+          matchFound = true
+        }
+
+        // abort if module name isn't on whitelist
+        if (!modules.includes(moduleName) && !modules.includes(fullModuleName)) {
+          return exports
+        }
+
+        if (modules.includes(fullModuleName) && fullModuleName !== moduleName) {
+          // if we get to this point, it means that we're requiring a whitelisted sub-module
+          moduleName = fullModuleName
+          matchFound = true
+        }
+      }
+
+      if (!matchFound) {
+        // figure out if this is the main module file, or a file inside the module
+        let res
+        try {
+          res = require.resolve(moduleName, { paths: [basedir] })
+        } catch (e) {
+          debug('could not resolve module: %s', moduleName)
+          self._cache.set(filename, exports, core)
+          return exports // abort if module could not be resolved (e.g. no main in package.json and no index.js file)
+        }
+
+        if (res !== filename) {
+          // this is a module-internal file
+          if (internals === true) {
+            // use the module-relative path to the file, prefixed by original module name
+            moduleName = moduleName + path.sep + path.relative(basedir, filename)
+            debug('preparing to process require of internal file: %s', moduleName)
+          } else {
+            debug('ignoring require of non-main module file: %s', res)
+            self._cache.set(filename, exports, core)
+            return exports // abort if not main module file
+          }
+        }
+      }
+    }
+
+    // ensure that the cache entry is assigned a value before calling
+    // onrequire, in case calling onrequire requires the same module.
+    self._cache.set(filename, exports, core)
+    debug('calling require hook: %s', moduleName)
+    const patchedExports = onrequire(exports, moduleName, basedir)
+    self._cache.set(filename, patchedExports, core)
+
+    debug('returning module: %s', moduleName)
+    return patchedExports
+  }
+}
+
+Hook.prototype.unhook = function () {
+  this._unhooked = true
+
+  if (this._require === Module.prototype.require) {
+    Module.prototype.require = this._origRequire
+    debug('require unhook successful')
+  } else {
+    debug('require unhook unsuccessful')
+  }
+
+  if (process.getBuiltinModule !== undefined) {
+    if (this._getBuiltinModule === process.getBuiltinModule) {
+      process.getBuiltinModule = this._origGetBuiltinModule
+      debug('process.getBuiltinModule unhook successful')
+    } else {
+      debug('process.getBuiltinModule unhook unsuccessful')
+    }
+  }
+}
+
+function resolveModuleName (stat) {
+  const normalizedPath = path.sep !== '/' ? stat.path.split(path.sep).join('/') : stat.path
+  return path.posix.join(stat.name, normalizedPath).replace(normalize, '')
+}