@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/lib/dispatcher/proxy-agent.js

@@ -1,15 +1,13 @@
 'use strict'
 
-const { kProxy, kClose, kDestroy, kDispatch } = require('../core/symbols')
+const { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = require('../core/symbols')
+const { URL } = require('node:url')
 const Agent = require('./agent')
 const Pool = require('./pool')
 const DispatcherBase = require('./dispatcher-base')
-const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError, ProxyConnectionError } = require('../core/errors')
+const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require('../core/errors')
 const buildConnector = require('../core/connect')
 const Client = require('./client')
-const { channels } = require('../core/diagnostics')
-const Socks5ProxyAgent = require('./socks5-proxy-agent')
-const { hasSafeIterator } = require('../core/util')
 
 const kAgent = Symbol('proxy agent')
 const kClient = Symbol('proxy client')
@@ -17,9 +15,7 @@ const kProxyHeaders = Symbol('proxy headers')
 const kRequestTls = Symbol('request tls settings')
 const kProxyTls = Symbol('proxy tls settings')
 const kConnectEndpoint = Symbol('connect endpoint function')
-const kConnectEndpointHTTP1 = Symbol('connect endpoint function (http/1.1 only)')
 const kTunnelProxy = Symbol('tunnel proxy')
-const proxyAuthorization = 'proxy-authorization'
 
 function defaultProtocolPort (protocol) {
   return protocol === 'https:' ? 443 : 80
@@ -38,23 +34,16 @@ function defaultAgentFactory (origin, opts) {
   return new Pool(origin, opts)
 }
 
-function shouldProxyTunnel (requestProtocol, proxyTunnel) {
-  return proxyTunnel === true || requestProtocol !== 'http:'
-}
-
 class Http1ProxyWrapper extends DispatcherBase {
   #client
-  #proxyServername
 
-  constructor (proxyUrl, { headers = {}, connect, factory, proxyServername }) {
+  constructor (proxyUrl, { headers = {}, connect, factory }) {
+    super()
     if (!proxyUrl) {
       throw new InvalidArgumentError('Proxy URL is mandatory')
     }
 
-    super()
-
     this[kProxyHeaders] = headers
-    this.#proxyServername = proxyServername
     if (factory) {
       this.#client = factory(proxyUrl, { connect })
     } else {
@@ -63,15 +52,15 @@ class Http1ProxyWrapper extends DispatcherBase {
   }
 
   [kDispatch] (opts, handler) {
-    const onResponseStart = handler.onResponseStart
-    handler.onResponseStart = function (controller, statusCode, data, statusMessage) {
+    const onHeaders = handler.onHeaders
+    handler.onHeaders = function (statusCode, data, resume) {
       if (statusCode === 407) {
-        if (typeof handler.onResponseError === 'function') {
-          handler.onResponseError(controller, new InvalidArgumentError('Proxy Authentication Required (407)'))
+        if (typeof handler.onError === 'function') {
+          handler.onError(new InvalidArgumentError('Proxy Authentication Required (407)'))
         }
         return
       }
-      if (onResponseStart) onResponseStart.call(this, controller, statusCode, data, statusMessage)
+      if (onHeaders) onHeaders.call(this, statusCode, data, resume)
     }
 
     // Rewrite request as an HTTP1 Proxy request, without tunneling.
@@ -89,27 +78,22 @@ class Http1ProxyWrapper extends DispatcherBase {
     }
     opts.headers = { ...this[kProxyHeaders], ...headers }
 
-    // Pin the SNI/cert hostname to the proxy. Without this the underlying
-    // Client would derive it from the (rewritten) Host header, which points
-    // at the target — wrong for the TLS handshake to the proxy itself.
-    if (this.#proxyServername != null) {
-      opts.servername = this.#proxyServername
-    }
-
     return this.#client[kDispatch](opts, handler)
   }
 
-  [kClose] () {
+  async [kClose] () {
     return this.#client.close()
   }
 
-  [kDestroy] (err) {
+  async [kDestroy] (err) {
     return this.#client.destroy(err)
   }
 }
 
 class ProxyAgent extends DispatcherBase {
   constructor (opts) {
+    super()
+
     if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
       throw new InvalidArgumentError('Proxy uri is mandatory')
     }
@@ -119,14 +103,15 @@ class ProxyAgent extends DispatcherBase {
       throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
     }
 
-    const { proxyTunnel, connectTimeout } = opts
-
-    super(opts)
+    const { proxyTunnel = true } = opts
 
     const url = this.#getUrl(opts)
     const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
 
     this[kProxy] = { uri: href, protocol }
+    this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent)
+      ? opts.interceptors.ProxyAgent
+      : []
     this[kRequestTls] = opts.requestTls
     this[kProxyTls] = opts.proxyTls
     this[kProxyHeaders] = opts.headers || {}
@@ -141,105 +126,48 @@ class ProxyAgent extends DispatcherBase {
       this[kProxyHeaders]['proxy-authorization'] = opts.token
     } else if (username && password) {
       this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
-    } else if (username) {
-      this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:`).toString('base64')}`
     }
 
-    const connect = buildConnector({ timeout: connectTimeout, ...opts.proxyTls })
-    const connectHTTP1 = buildConnector({ timeout: connectTimeout, ...opts.proxyTls, allowH2: false })
-    this[kConnectEndpoint] = buildConnector({ timeout: connectTimeout, ...opts.requestTls })
-    this[kConnectEndpointHTTP1] = buildConnector({ timeout: connectTimeout, ...opts.requestTls, allowH2: false })
+    const connect = buildConnector({ ...opts.proxyTls })
+    this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
 
     const agentFactory = opts.factory || defaultAgentFactory
     const factory = (origin, options) => {
       const { protocol } = new URL(origin)
-
-      // Handle SOCKS5 proxy
-      if (this[kProxy].protocol === 'socks5:' || this[kProxy].protocol === 'socks:') {
-        return new Socks5ProxyAgent(this[kProxy].uri, {
-          headers: this[kProxyHeaders],
-          connect,
-          factory: agentFactory,
-          username: opts.username || username,
-          password: opts.password || password,
-          connectTimeout,
-          proxyTls: opts.proxyTls,
-          requestTls: opts.requestTls
-        })
-      }
-
-      if (!shouldProxyTunnel(protocol, this[kTunnelProxy])) {
-        const forwardConnect = this[kProxy].protocol === 'https:'
-          ? (opts, cb) => connectHTTP1(opts, (err, socket) => {
-              if (err && err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
-                cb(new SecureProxyConnectionError(err))
-              } else {
-                cb(err, socket)
-              }
-            })
-          : connectHTTP1
+      if (!this[kTunnelProxy] && protocol === 'http:' && this[kProxy].protocol === 'http:') {
         return new Http1ProxyWrapper(this[kProxy].uri, {
           headers: this[kProxyHeaders],
-          connect: forwardConnect,
-          factory: agentFactory,
-          proxyServername: this[kProxy].protocol === 'https:'
-            ? (this[kProxyTls]?.servername || proxyHostname)
-            : undefined
+          connect,
+          factory: agentFactory
         })
       }
       return agentFactory(origin, options)
     }
-
-    // For SOCKS5 proxies, we don't need a client to the proxy itself
-    // The SOCKS5 connection is handled within Socks5ProxyAgent
-    if (protocol === 'socks5:' || protocol === 'socks:') {
-      this[kClient] = null
-    } else {
-      this[kClient] = clientFactory(url, { connect })
-    }
-
+    this[kClient] = clientFactory(url, { connect })
     this[kAgent] = new Agent({
       ...opts,
       factory,
       connect: async (opts, callback) => {
-        // SOCKS5 proxies handle their own connections via Socks5ProxyAgent,
-        // so this connect function should never be called for them.
-        if (!this[kClient]) {
-          callback(new InvalidArgumentError('Cannot establish tunnel connection without a proxy client'))
-          return
-        }
-
         let requestedPath = opts.host
         if (!opts.port) {
           requestedPath += `:${defaultProtocolPort(opts.protocol)}`
         }
         try {
-          const connectParams = {
+          const { socket, statusCode } = await this[kClient].connect({
             origin,
             port,
             path: requestedPath,
             signal: opts.signal,
             headers: {
               ...this[kProxyHeaders],
-              host: opts.host,
-              ...(opts.connections == null || opts.connections > 0 ? { 'proxy-connection': 'keep-alive' } : {})
+              host: opts.host
             },
             servername: this[kProxyTls]?.servername || proxyHostname
-          }
-          const { socket, statusCode } = await this[kClient].connect(connectParams)
+          })
           if (statusCode !== 200) {
             socket.on('error', noop).destroy()
             callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`))
-            return
           }
-
-          if (channels.proxyConnected.hasSubscribers) {
-            channels.proxyConnected.publish({
-              socket,
-              connectParams
-            })
-          }
-
           if (opts.protocol !== 'https:') {
             callback(null, socket)
             return
@@ -250,23 +178,11 @@ class ProxyAgent extends DispatcherBase {
           } else {
             servername = opts.servername
           }
-          const connectEndpoint = opts.allowH2 === false
-            ? this[kConnectEndpointHTTP1]
-            : this[kConnectEndpoint]
-
-          connectEndpoint({ ...opts, servername, httpSocket: socket }, callback)
+          this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
         } catch (err) {
           if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
             // Throw a custom error to avoid loop in client.js#connect
             callback(new SecureProxyConnectionError(err))
-          } else if (err.code === 'UND_ERR_SOCKET') {
-            // A socket failure while establishing the tunnel means the CONNECT
-            // never completed, so there is nothing to recover - the proxy just
-            // tore down the connection. client.js#onError treats UND_ERR_SOCKET
-            // as a recoverable error on an established connection and leaves the
-            // request queued, which makes connect() retry forever. Surface it as
-            // a non-recoverable proxy error so the request fails instead. (#3897)
-            callback(new ProxyConnectionError(err))
           } else {
             callback(err)
           }
@@ -294,7 +210,7 @@ class ProxyAgent extends DispatcherBase {
   }
 
   /**
-   * @param {import('../../types/proxy-agent').ProxyAgent.Options | string | URL} opts
+   * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
    * @returns {URL}
    */
   #getUrl (opts) {
@@ -307,26 +223,20 @@ class ProxyAgent extends DispatcherBase {
     }
   }
 
-  [kClose] () {
-    const promises = [this[kAgent].close()]
-    if (this[kClient]) {
-      promises.push(this[kClient].close())
-    }
-    return Promise.all(promises)
+  async [kClose] () {
+    await this[kAgent].close()
+    await this[kClient].close()
   }
 
-  [kDestroy] () {
-    const promises = [this[kAgent].destroy()]
-    if (this[kClient]) {
-      promises.push(this[kClient].destroy())
-    }
-    return Promise.all(promises)
+  async [kDestroy] () {
+    await this[kAgent].destroy()
+    await this[kClient].destroy()
   }
 }
 
 /**
- * @param {string[] | Record<string, string> | Iterable<[string, string | string[] | undefined]>} headers
- * @returns {Record<string, string | string[] | undefined>}
+ * @param {string[] | Record<string, string>} headers
+ * @returns {Record<string, string>}
  */
 function buildHeaders (headers) {
   // When using undici.fetch, the headers list is stored
@@ -336,44 +246,12 @@ function buildHeaders (headers) {
     const headersPair = {}
 
     for (let i = 0; i < headers.length; i += 2) {
-      if (isProxyAuthorizationHeader(headers[i])) {
-        throwProxyAuthError()
-      }
-
       headersPair[headers[i]] = headers[i + 1]
     }
 
     return headersPair
   }
 
-  // Materialize iterable header containers (e.g. Map, Headers) into a record so
-  // that throwIfProxyAuthIsSent() can inspect their entries. Object.keys and
-  // for...in see nothing on a Map/Headers instance, so without this the
-  // Proxy-Authorization guard is bypassed and proxy credentials can reach the
-  // origin server (GHSA-6cv7-626c-qhqw).
-  if (headers && typeof headers === 'object' && hasSafeIterator(headers)) {
-    const headersPair = {}
-
-    for (const [key, value] of headers) {
-      if (!Object.hasOwn(headersPair, key)) {
-        headersPair[key] = value
-        continue
-      }
-
-      const previous = headersPair[key]
-      const values = []
-      if (previous !== undefined) {
-        values.push(...(Array.isArray(previous) ? previous : [previous]))
-      }
-      if (value !== undefined) {
-        values.push(...(Array.isArray(value) ? value : [value]))
-      }
-      headersPair[key] = values.length > 1 ? values : values[0]
-    }
-
-    return headersPair
-  }
-
   return headers
 }
 
@@ -386,23 +264,11 @@ function buildHeaders (headers) {
  * It should be removed in the next major version for performance reasons
  */
 function throwIfProxyAuthIsSent (headers) {
-  for (const key in headers) {
-    if (isProxyAuthorizationHeader(key)) {
-      throwProxyAuthError()
-    }
+  const existProxyAuth = headers && Object.keys(headers)
+    .find((key) => key.toLowerCase() === 'proxy-authorization')
+  if (existProxyAuth) {
+    throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
   }
 }
 
-/**
- * @param {string} key
- * @returns {boolean}
- */
-function isProxyAuthorizationHeader (key) {
-  return key.length === proxyAuthorization.length && key.toLowerCase() === proxyAuthorization
-}
-
-function throwProxyAuthError () {
-  throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
-}
-
 module.exports = ProxyAgent

package/node_modules/undici/lib/dispatcher/retry-agent.js

@@ -2,7 +2,6 @@
 
 const Dispatcher = require('./dispatcher')
 const RetryHandler = require('../handler/retry-handler')
-const { kOriginless, kUrl } = require('../core/symbols')
 
 class RetryAgent extends Dispatcher {
   #agent = null
@@ -11,8 +10,6 @@ class RetryAgent extends Dispatcher {
     super(options)
     this.#agent = agent
     this.#options = options
-    this[kUrl] = agent[kUrl]
-    this[kOriginless] = agent[kOriginless]
   }
 
   dispatch (opts, handler) {

package/node_modules/undici/lib/global.js

@@ -2,14 +2,9 @@
 
 // We include a version number for the Dispatcher API. In case of breaking changes,
 // this version number must be increased to avoid conflicts.
-const globalDispatcher = Symbol.for('undici.globalDispatcher.2')
-const legacyGlobalDispatcher = Symbol.for('undici.globalDispatcher.1')
+const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
 const { InvalidArgumentError } = require('./core/errors')
 const Agent = require('./dispatcher/agent')
-const Dispatcher1Wrapper = require('./dispatcher/dispatcher1-wrapper')
-
-// Fallback storage for when globalThis is not extensible (e.g. frozen)
-let fallbackDispatcher
 
 if (getGlobalDispatcher() === undefined) {
   setGlobalDispatcher(new Agent())
@@ -19,64 +14,19 @@ function setGlobalDispatcher (agent) {
   if (!agent || typeof agent.dispatch !== 'function') {
     throw new InvalidArgumentError('Argument agent must implement Agent')
   }
-
-  try {
-    Object.defineProperty(globalThis, globalDispatcher, {
-      value: agent,
-      writable: true,
-      enumerable: false,
-      configurable: false
-    })
-  } catch (err) {
-    // globalThis is not extensible (e.g. Object.freeze(globalThis))
-    // Use fallback storage instead
-    if (err instanceof TypeError) {
-      fallbackDispatcher = agent
-      return
-    }
-    throw err
-  }
-
-  try {
-    const legacyAgent = agent instanceof Dispatcher1Wrapper ? agent : new Dispatcher1Wrapper(agent)
-
-    Object.defineProperty(globalThis, legacyGlobalDispatcher, {
-      value: legacyAgent,
-      writable: true,
-      enumerable: false,
-      configurable: false
-    })
-  } catch (err) {
-    // globalThis is not extensible; fallback storage is already set
-    if (!(err instanceof TypeError)) {
-      throw err
-    }
-  }
+  Object.defineProperty(globalThis, globalDispatcher, {
+    value: agent,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
 }
 
 function getGlobalDispatcher () {
-  return globalThis[globalDispatcher] ?? fallbackDispatcher
+  return globalThis[globalDispatcher]
 }
 
-// These are the globals that can be installed by undici.install().
-// Not exported by index.js to avoid use outside of this module.
-const installedExports = /** @type {const} */ (
-  [
-    'fetch',
-    'Headers',
-    'Response',
-    'Request',
-    'FormData',
-    'WebSocket',
-    'CloseEvent',
-    'ErrorEvent',
-    'MessageEvent',
-    'EventSource'
-  ]
-)
-
 module.exports = {
   setGlobalDispatcher,
-  getGlobalDispatcher,
-  installedExports
+  getGlobalDispatcher
 }

package/node_modules/undici/lib/handler/decorator-handler.js

@@ -1,15 +1,7 @@
 'use strict'
 
-const assert = require('node:assert')
-
-/**
- * @deprecated
- */
 module.exports = class DecoratorHandler {
   #handler
-  #onCompleteCalled = false
-  #onErrorCalled = false
-  #onResponseStartCalled = false
 
   constructor (handler) {
     if (typeof handler !== 'object' || handler === null) {
@@ -18,55 +10,35 @@ module.exports = class DecoratorHandler {
     this.#handler = handler
   }
 
-  onRequestStart (...args) {
-    this.#handler.onRequestStart?.(...args)
+  onConnect (...args) {
+    return this.#handler.onConnect?.(...args)
   }
 
-  onRequestUpgrade (...args) {
-    assert(!this.#onCompleteCalled)
-    assert(!this.#onErrorCalled)
-
-    return this.#handler.onRequestUpgrade?.(...args)
+  onError (...args) {
+    return this.#handler.onError?.(...args)
   }
 
-  onResponseStart (...args) {
-    assert(!this.#onCompleteCalled)
-    assert(!this.#onErrorCalled)
-    assert(!this.#onResponseStartCalled)
-
-    this.#onResponseStartCalled = true
-
-    return this.#handler.onResponseStart?.(...args)
+  onUpgrade (...args) {
+    return this.#handler.onUpgrade?.(...args)
   }
 
-  onResponseData (...args) {
-    assert(!this.#onCompleteCalled)
-    assert(!this.#onErrorCalled)
-
-    return this.#handler.onResponseData?.(...args)
+  onResponseStarted (...args) {
+    return this.#handler.onResponseStarted?.(...args)
   }
 
-  onResponseEnd (...args) {
-    assert(!this.#onCompleteCalled)
-    assert(!this.#onErrorCalled)
+  onHeaders (...args) {
+    return this.#handler.onHeaders?.(...args)
+  }
 
-    this.#onCompleteCalled = true
-    return this.#handler.onResponseEnd?.(...args)
+  onData (...args) {
+    return this.#handler.onData?.(...args)
   }
 
-  onResponseError (...args) {
-    this.#onErrorCalled = true
-    return this.#handler.onResponseError?.(...args)
+  onComplete (...args) {
+    return this.#handler.onComplete?.(...args)
   }
 
-  /**
-   * @deprecated
-   */
   onBodySent (...args) {
     return this.#handler.onBodySent?.(...args)
   }
-
-  onRequestSent (...args) {
-    return this.#handler.onRequestSent?.(...args)
-  }
 }