@aeolus-fleet/console 0.30.0 → 0.31.0

package/.next/standalone/packages/console/.next/BUILD_ID

@@ -1 +1 @@
-10-qWFsL7UDAGlmmFXFB-
+M3UCCsD3-uSl8HVucbFrh

package/.next/standalone/packages/console/.next/build-manifest.json

@@ -7,9 +7,9 @@
     "static/chunks/0cz1d0mv5g_q7.js"
   ],
   "lowPriorityFiles": [
-    "static/10-qWFsL7UDAGlmmFXFB-/_buildManifest.js",
-    "static/10-qWFsL7UDAGlmmFXFB-/_ssgManifest.js",
-    "static/10-qWFsL7UDAGlmmFXFB-/_clientMiddlewareManifest.js"
+    "static/M3UCCsD3-uSl8HVucbFrh/_buildManifest.js",
+    "static/M3UCCsD3-uSl8HVucbFrh/_ssgManifest.js",
+    "static/M3UCCsD3-uSl8HVucbFrh/_clientMiddlewareManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/0wf2rmyoojkx7.js",

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

@@ -0,0 +1,221 @@
+// 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 path = require('path')
+const moduleDetailsFromPath = require('module-details-from-path')
+const { fileURLToPath } = require('url')
+const { MessageChannel } = require('worker_threads')
+
+let { isBuiltin } = require('module')
+if (!isBuiltin) {
+  isBuiltin = () => true
+}
+
+const {
+  importHooks,
+  specifiers,
+  toHook
+} = require('./lib/register')
+
+/**
+ * Checks turbopack specifiers separately (for Next.js 16+).
+ *
+ * If turbopack is used, specifiers will have an additional hash appended to the end.
+ * Something like "ai" might become "ai-5e7181a616786b24". This only happens in Next.js 16+.
+ * Just checking if the baseDir ends with this new specifier won't match, as the baseDir still has the plain package.
+ *
+ * This logic isolates a new check for checking the actual name in the case turbopack is being used.
+ *
+ * @param specifier {string}
+ * @param baseDir {string}
+ */
+function isTurbopackSpecifier (specifier, baseDir) {
+  const usingTurbopack = process.env.TURBOPACK ?? process.argv.includes('--turbo')
+  if (!usingTurbopack) return false
+
+  const specifierWithoutTurbopackHash = specifier.slice(0, specifier.lastIndexOf('-'))
+  return baseDir.endsWith(specifierWithoutTurbopackHash)
+}
+
+function addHook (hook) {
+  importHooks.push(hook)
+  toHook.forEach(([name, namespace, specifier]) => hook(name, namespace, specifier))
+}
+
+function removeHook (hook) {
+  const index = importHooks.indexOf(hook)
+  if (index > -1) {
+    importHooks.splice(index, 1)
+  }
+}
+
+function callHookFn (hookFn, namespace, name, baseDir) {
+  const newDefault = hookFn(namespace, name, baseDir)
+  if (newDefault && newDefault !== namespace) {
+    // Only ESM modules that actually export `default` can have it reassigned.
+    // Some hooks return a value unconditionally; avoid crashing when the module
+    // has no default export (see issue #188).
+    if ('default' in namespace) {
+      namespace.default = newDefault
+    }
+  }
+}
+
+let sendModulesToLoader
+
+/**
+ * EXPERIMENTAL
+ * This feature is experimental and may change in minor versions.
+ * **NOTE** This feature is incompatible with the {internals: true} Hook option.
+ *
+ * Creates a message channel with a port that can be used to add hooks to the
+ * list of exclusively included modules.
+ *
+ * This can be used to only wrap modules that are Hook'ed, however modules need
+ * to be hooked before they are imported.
+ *
+ * ```ts
+ * import { register } from 'module'
+ * import { Hook, createAddHookMessageChannel } from 'import-in-the-middle'
+ *
+ * const { registerOptions, waitForAllMessagesAcknowledged } = createAddHookMessageChannel()
+ *
+ * register('import-in-the-middle/hook.mjs', import.meta.url, registerOptions)
+ *
+ * Hook(['fs'], (exported, name, baseDir) => {
+ *   // Instrument the fs module
+ * })
+ *
+ * // Ensure that the loader has acknowledged all the modules
+ * // before we allow execution to continue
+ * await waitForAllMessagesAcknowledged()
+ * ```
+ */
+function createAddHookMessageChannel () {
+  const { port1, port2 } = new MessageChannel()
+  let pendingAckCount = 0
+  let resolveFn
+
+  sendModulesToLoader = (modules) => {
+    pendingAckCount++
+    port1.postMessage(modules)
+  }
+
+  port1.on('message', () => {
+    pendingAckCount--
+
+    if (resolveFn && pendingAckCount <= 0) {
+      resolveFn()
+    }
+  }).unref()
+
+  function waitForAllMessagesAcknowledged () {
+    // This timer is to prevent the process from exiting with code 13:
+    // 13: Unsettled Top-Level Await.
+    const timer = setInterval(() => { }, 1000)
+    const promise = new Promise((resolve) => {
+      resolveFn = resolve
+    }).then(() => { clearInterval(timer) })
+
+    if (pendingAckCount === 0) {
+      resolveFn()
+    }
+
+    return promise
+  }
+
+  const addHookMessagePort = port2
+  const registerOptions = { data: { addHookMessagePort, include: [] }, transferList: [addHookMessagePort] }
+
+  return { registerOptions, addHookMessagePort, waitForAllMessagesAcknowledged }
+}
+
+function Hook (modules, options, hookFn) {
+  if ((this instanceof Hook) === false) return new Hook(modules, options, hookFn)
+  if (typeof modules === 'function') {
+    hookFn = modules
+    modules = null
+    options = null
+  } else if (typeof options === 'function') {
+    hookFn = options
+    options = null
+  }
+  const internals = options ? options.internals === true : false
+
+  if (sendModulesToLoader && Array.isArray(modules)) {
+    sendModulesToLoader(modules)
+  }
+
+  this._iitmHook = (name, namespace, specifier) => {
+    const loadUrl = name
+    const isNodeUrl = loadUrl.startsWith('node:')
+    let filePath, baseDir
+
+    if (isNodeUrl) {
+      // Normalize builtin module name to *not* have 'node:' prefix, unless
+      // required, as it is for 'node:test' and some others.  `module.isBuiltin`
+      // is available in all Node.js versions that have node:-only modules.
+      const unprefixed = name.slice(5)
+      if (isBuiltin(unprefixed)) {
+        name = unprefixed
+      }
+    } else if (loadUrl.startsWith('file://')) {
+      const stackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      try {
+        filePath = fileURLToPath(name)
+        name = filePath
+      } catch (e) {}
+      Error.stackTraceLimit = stackTraceLimit
+
+      if (filePath) {
+        const details = moduleDetailsFromPath(filePath)
+        if (details) {
+          name = details.name
+          baseDir = details.basedir
+        }
+      }
+    }
+
+    if (modules) {
+      for (const matchArg of modules) {
+        if (filePath && matchArg === filePath) {
+          // abspath match
+          callHookFn(hookFn, namespace, filePath, undefined)
+        } else if (matchArg === name) {
+          if (!baseDir) {
+            // built-in module (or unexpected non file:// name?)
+            callHookFn(hookFn, namespace, name, baseDir)
+          } else if (baseDir.endsWith(specifiers.get(loadUrl)) || isTurbopackSpecifier(specifiers.get(loadUrl), baseDir)) {
+            // An import of the top-level module (e.g. `import 'ioredis'`).
+            // Note: Slight behaviour difference from RITM. RITM uses
+            // `require.resolve(name)` to see if filename is the module
+            // main file, which will catch `require('ioredis/built/index.js')`.
+            // The check here will not catch `import 'ioredis/built/index.js'`.
+            callHookFn(hookFn, namespace, name, baseDir)
+          } else if (internals) {
+            const internalPath = name + path.sep + path.relative(baseDir, filePath)
+            callHookFn(hookFn, namespace, internalPath, baseDir)
+          }
+        } else if (matchArg === specifier) {
+          callHookFn(hookFn, namespace, specifier, baseDir)
+        }
+      }
+    } else {
+      callHookFn(hookFn, namespace, name, baseDir)
+    }
+  }
+
+  addHook(this._iitmHook)
+}
+
+Hook.prototype.unhook = function () {
+  removeHook(this._iitmHook)
+}
+
+module.exports = Hook
+module.exports.Hook = Hook
+module.exports.addHook = addHook
+module.exports.removeHook = removeHook
+module.exports.createAddHookMessageChannel = createAddHookMessageChannel

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"
+  }
+}