@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/{undici → @mytools/fst-platform/node_modules/undici}/lib/dispatcher/round-robin-pool.js

@@ -6,7 +6,6 @@ const {
   kNeedDrain,
   kAddClient,
   kGetDispatcher,
-  kHasDispatcher,
   kRemoveClient
 } = require('./pool-base')
 const Client = require('./client')
@@ -65,11 +64,14 @@ class RoundRobinPool extends PoolBase {
       })
     }
 
-    super(options)
+    super()
 
     this[kConnections] = connections || null
     this[kUrl] = util.parseOrigin(origin)
     this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
     this[kFactory] = factory
     this[kIndex] = -1
 
@@ -93,9 +95,10 @@ class RoundRobinPool extends PoolBase {
 
   [kGetDispatcher] () {
     const clientTtlOption = this[kOptions].clientTtl
+    const clientsLength = this[kClients].length
 
     // If we have no clients yet, create one
-    if (this[kClients].length === 0) {
+    if (clientsLength === 0) {
       const dispatcher = this[kFactory](this[kUrl], this[kOptions])
       this[kAddClient](dispatcher)
       return dispatcher
@@ -103,14 +106,14 @@ class RoundRobinPool extends PoolBase {
 
     // Round-robin through existing clients
     let checked = 0
-    while (checked < this[kClients].length) {
-      this[kIndex] = (this[kIndex] + 1) % this[kClients].length
+    while (checked < clientsLength) {
+      this[kIndex] = (this[kIndex] + 1) % clientsLength
       const client = this[kClients][this[kIndex]]
 
       // Check if client is stale (TTL expired)
       if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
         this[kRemoveClient](client)
-        this[kIndex]--
+        checked++
         continue
       }
 
@@ -123,37 +126,12 @@ class RoundRobinPool extends PoolBase {
     }
 
     // All clients are busy, create a new one if we haven't reached the limit
-    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+    if (!this[kConnections] || clientsLength < this[kConnections]) {
       const dispatcher = this[kFactory](this[kUrl], this[kOptions])
       this[kAddClient](dispatcher)
       return dispatcher
     }
   }
-
-  [kHasDispatcher] () {
-    const clientTtlOption = this[kOptions].clientTtl
-    for (let i = 0; i < this[kClients].length; i++) {
-      const client = this[kClients][i]
-
-      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
-        this[kRemoveClient](client)
-        if (i <= this[kIndex]) {
-          this[kIndex]--
-        }
-        i--
-      } else if (!client[kNeedDrain]) {
-        return true
-      }
-    }
-
-    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
-      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
-      this[kAddClient](dispatcher)
-      return true
-    }
-
-    return false
-  }
 }
 
 module.exports = RoundRobinPool

package/node_modules/{undici → @mytools/fst-platform/node_modules/undici}/lib/dispatcher/socks5-proxy-agent.js

@@ -4,33 +4,22 @@ const { URL } = require('node:url')
 
 let tls // include tls conditionally since it is not always available
 const DispatcherBase = require('./dispatcher-base')
-const { ConnectTimeoutError, InvalidArgumentError } = require('../core/errors')
+const { InvalidArgumentError } = require('../core/errors')
 const { Socks5Client, STATES } = require('../core/socks5-client')
-const { kBusy, kConnected, kDispatch, kClose, kDestroy } = require('../core/symbols')
+const { kDispatch, kClose, kDestroy } = require('../core/symbols')
 const Pool = require('./pool')
 const buildConnector = require('../core/connect')
-const { setupConnectTimeout } = require('../core/util')
 const { debuglog } = require('node:util')
 
 const debug = debuglog('undici:socks5-proxy')
 
-const DEFAULT_SOCKS5_CONNECT_TIMEOUT = 5000
-
 const kProxyUrl = Symbol('proxy url')
 const kProxyHeaders = Symbol('proxy headers')
 const kProxyAuth = Symbol('proxy auth')
 const kProxyProtocol = Symbol('proxy protocol')
 const kPools = Symbol('pools')
 const kConnector = Symbol('connector')
-const kConnectTimeout = Symbol('connect timeout')
 const kRequestTls = Symbol('request tls settings')
-const kRequestTlsTimeout = Symbol('request tls timeout')
-
-function createConnectTimeoutError (hostname, port, timeout) {
-  return new ConnectTimeoutError(
-    `Connect Timeout Error (attempted address: ${hostname}:${port}, timeout: ${timeout}ms)`
-  )
-}
 
 // Static flag to ensure warning is only emitted once per process
 let experimentalWarningEmitted = false
@@ -40,7 +29,7 @@ let experimentalWarningEmitted = false
  */
 class Socks5ProxyAgent extends DispatcherBase {
   constructor (proxyUrl, options = {}) {
-    super(options)
+    super()
 
     // Emit experimental warning only once
     if (!experimentalWarningEmitted) {
@@ -65,20 +54,7 @@ class Socks5ProxyAgent extends DispatcherBase {
     this[kProxyUrl] = url
     this[kProxyHeaders] = options.headers || {}
     this[kProxyProtocol] = options.proxyTls ? 'https:' : 'http:'
-
-    const connectTimeout = options.connectTimeout ?? DEFAULT_SOCKS5_CONNECT_TIMEOUT
-    if (!Number.isFinite(connectTimeout) || connectTimeout < 0) {
-      throw new InvalidArgumentError('invalid connectTimeout')
-    }
-    this[kConnectTimeout] = connectTimeout
-
-    const { timeout, ...requestTls } = options.requestTls || {}
-    const requestTlsTimeout = timeout ?? connectTimeout
-    if (!Number.isFinite(requestTlsTimeout) || requestTlsTimeout < 0) {
-      throw new InvalidArgumentError('invalid requestTls.timeout')
-    }
-    this[kRequestTls] = requestTls
-    this[kRequestTlsTimeout] = requestTlsTimeout
+    this[kRequestTls] = options.requestTls
 
     // Extract auth from URL or options
     this[kProxyAuth] = {
@@ -87,13 +63,8 @@ class Socks5ProxyAgent extends DispatcherBase {
     }
 
     // Create connector for proxy connection
-    const proxyTlsTimeout = options.proxyTls?.timeout ?? connectTimeout
-    if (!Number.isFinite(proxyTlsTimeout) || proxyTlsTimeout < 0) {
-      throw new InvalidArgumentError('invalid proxyTls.timeout')
-    }
     this[kConnector] = options.connect || buildConnector({
       ...options.proxyTls,
-      timeout: proxyTlsTimeout,
       servername: options.proxyTls?.servername || url.hostname
     })
 
@@ -111,23 +82,21 @@ class Socks5ProxyAgent extends DispatcherBase {
     debug('creating SOCKS5 connection to', proxyHost, proxyPort)
 
     // Connect to the SOCKS5 proxy
-    const socketReady = Promise.withResolvers()
-
-    this[kConnector]({
-      hostname: proxyHost,
-      host: proxyHost,
-      port: proxyPort,
-      protocol: this[kProxyProtocol]
-    }, (err, socket) => {
-      if (err) {
-        socketReady.reject(err)
-      } else {
-        socketReady.resolve(socket)
-      }
+    const socket = await new Promise((resolve, reject) => {
+      this[kConnector]({
+        hostname: proxyHost,
+        host: proxyHost,
+        port: proxyPort,
+        protocol: this[kProxyProtocol]
+      }, (err, socket) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(socket)
+        }
+      })
     })
 
-    const socket = await socketReady.promise
-
     // Create SOCKS5 client
     const socks5Client = new Socks5Client(socket, this[kProxyAuth])
 
@@ -141,80 +110,58 @@ class Socks5ProxyAgent extends DispatcherBase {
     await socks5Client.handshake()
 
     // Wait for authentication (if required)
-    const authenticationReady = Promise.withResolvers()
-    const authenticationTimeout = this[kConnectTimeout] === 0
-      ? null
-      : setTimeout(() => {
-        cleanupAuthenticationListeners()
-        socks5Client.destroy()
-        authenticationReady.reject(
-          createConnectTimeoutError(proxyHost, proxyPort, this[kConnectTimeout])
-        )
-      }, this[kConnectTimeout])
-
-    const cleanupAuthenticationListeners = () => {
-      clearTimeout(authenticationTimeout)
-      socks5Client.removeListener('authenticated', onAuthenticated)
-      socks5Client.removeListener('error', onAuthenticationError)
-    }
-
-    const onAuthenticated = () => {
-      cleanupAuthenticationListeners()
-      authenticationReady.resolve()
-    }
-
-    const onAuthenticationError = (err) => {
-      cleanupAuthenticationListeners()
-      authenticationReady.reject(err)
-    }
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('SOCKS5 authentication timeout'))
+      }, 5000)
+
+      const onAuthenticated = () => {
+        clearTimeout(timeout)
+        socks5Client.removeListener('error', onError)
+        resolve()
+      }
 
-    // Check if already authenticated (for NO_AUTH method)
-    if (socks5Client.state === STATES.AUTHENTICATED) {
-      clearTimeout(authenticationTimeout)
-      authenticationReady.resolve()
-    } else {
-      socks5Client.once('authenticated', onAuthenticated)
-      socks5Client.once('error', onAuthenticationError)
-    }
+      const onError = (err) => {
+        clearTimeout(timeout)
+        socks5Client.removeListener('authenticated', onAuthenticated)
+        reject(err)
+      }
 
-    await authenticationReady.promise
+      // Check if already authenticated (for NO_AUTH method)
+      if (socks5Client.state === STATES.AUTHENTICATED) {
+        clearTimeout(timeout)
+        resolve()
+      } else {
+        socks5Client.once('authenticated', onAuthenticated)
+        socks5Client.once('error', onError)
+      }
+    })
 
     // Send CONNECT command
     await socks5Client.connect(targetHost, targetPort)
 
     // Wait for connection
-    const connectionReady = Promise.withResolvers()
-    const connectionTimeout = this[kConnectTimeout] === 0
-      ? null
-      : setTimeout(() => {
-        cleanupConnectionListeners()
-        socks5Client.destroy()
-        connectionReady.reject(
-          createConnectTimeoutError(targetHost, targetPort, this[kConnectTimeout])
-        )
-      }, this[kConnectTimeout])
-
-    const cleanupConnectionListeners = () => {
-      clearTimeout(connectionTimeout)
-      socks5Client.removeListener('connected', onConnected)
-      socks5Client.removeListener('error', onConnectionError)
-    }
-
-    const onConnected = (info) => {
-      debug('SOCKS5 tunnel established to', targetHost, targetPort, 'via', info)
-      cleanupConnectionListeners()
-      connectionReady.resolve()
-    }
-
-    const onConnectionError = (err) => {
-      cleanupConnectionListeners()
-      connectionReady.reject(err)
-    }
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('SOCKS5 connection timeout'))
+      }, 5000)
+
+      const onConnected = (info) => {
+        debug('SOCKS5 tunnel established to', targetHost, targetPort, 'via', info)
+        clearTimeout(timeout)
+        socks5Client.removeListener('error', onError)
+        resolve()
+      }
 
-    socks5Client.once('connected', onConnected)
-    socks5Client.once('error', onConnectionError)
+      const onError = (err) => {
+        clearTimeout(timeout)
+        socks5Client.removeListener('connected', onConnected)
+        reject(err)
+      }
 
-    await connectionReady.promise
+      socks5Client.once('connected', onConnected)
+      socks5Client.once('error', onError)
+    })
 
     return socket
   }
@@ -259,33 +206,10 @@ class Socks5ProxyAgent extends DispatcherBase {
                   servername: this[kRequestTls]?.servername || targetHost
                 })
 
-                const tlsReady = Promise.withResolvers()
-
-                const cleanupTlsListeners = () => {
-                  queueMicrotask(clearTlsTimeout)
-                  finalSocket.removeListener('secureConnect', onSecureConnect)
-                  finalSocket.removeListener('error', onTlsError)
-                }
-
-                const onSecureConnect = () => {
-                  cleanupTlsListeners()
-                  tlsReady.resolve()
-                }
-
-                const onTlsError = (err) => {
-                  cleanupTlsListeners()
-                  tlsReady.reject(err)
-                }
-
-                const clearTlsTimeout = setupConnectTimeout(new WeakRef(finalSocket), {
-                  timeout: this[kRequestTlsTimeout],
-                  hostname: targetHost,
-                  port: targetPort
+                await new Promise((resolve, reject) => {
+                  finalSocket.once('secureConnect', resolve)
+                  finalSocket.once('error', reject)
                 })
-
-                finalSocket.once('secureConnect', onSecureConnect)
-                finalSocket.once('error', onTlsError)
-                await tlsReady.promise
               }
 
               callback(null, finalSocket)
@@ -296,20 +220,6 @@ class Socks5ProxyAgent extends DispatcherBase {
           }
         })
         this[kPools].set(originKey, pool)
-
-        const closePoolIfUnused = () => {
-          if (this[kPools].get(originKey) !== pool || pool[kConnected] > 0 || pool[kBusy]) {
-            return
-          }
-
-          this[kPools].delete(originKey)
-          if (!pool.destroyed) {
-            pool.close()
-          }
-        }
-
-        pool.on('disconnect', closePoolIfUnused)
-        pool.on('connectionError', closePoolIfUnused)
       }
 
       // Dispatch the request through the per-origin pool

package/node_modules/@mytools/fst-platform/node_modules/undici/lib/global.js

@@ -0,0 +1,59 @@
+'use strict'
+
+// 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 { InvalidArgumentError } = require('./core/errors')
+const Agent = require('./dispatcher/agent')
+
+if (getGlobalDispatcher() === undefined) {
+  setGlobalDispatcher(new Agent())
+}
+
+function setGlobalDispatcher (agent) {
+  if (!agent || typeof agent.dispatch !== 'function') {
+    throw new InvalidArgumentError('Argument agent must implement Agent')
+  }
+
+  Object.defineProperty(globalThis, globalDispatcher, {
+    value: agent,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
+
+  Object.defineProperty(globalThis, legacyGlobalDispatcher, {
+    value: agent,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
+}
+
+function getGlobalDispatcher () {
+  return globalThis[legacyGlobalDispatcher]
+}
+
+// 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
+}

package/node_modules/{undici → @mytools/fst-platform/node_modules/undici}/lib/handler/cache-handler.js

@@ -29,10 +29,6 @@ const NOT_UNDERSTOOD_STATUS_CODES = [
 
 const MAX_RESPONSE_AGE = 2147483647000
 
-// Retention for revalidation-only entries (zero freshness lifetime but a
-// validator present); each successful revalidation re-stores the entry.
-const REVALIDATION_ONLY_RETENTION = 86400000 // 24 hours
-
 function trimOWS (value) {
   return value.replace(/^[\t ]+|[\t ]+$/g, '')
 }
@@ -118,6 +114,7 @@ function invalidateUnsafeRequest (store, cacheKey, resHeaders) {
   deleteLocationTargets(store, cacheKey, resHeaders.location)
   deleteLocationTargets(store, cacheKey, resHeaders['content-location'])
 }
+
 /**
  * @typedef {import('../../types/dispatcher.d.ts').default.DispatchHandler} DispatchHandler
  *
@@ -173,14 +170,6 @@ class CacheHandler {
     this.#handler.onRequestStart?.(controller, context)
   }
 
-  onBodySent (chunk) {
-    this.#handler.onBodySent?.(chunk)
-  }
-
-  onRequestSent () {
-    this.#handler.onRequestSent?.()
-  }
-
   onRequestUpgrade (controller, statusCode, headers, socket) {
     this.#handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
   }
@@ -266,18 +255,10 @@ class CacheHandler {
     const apparentAge = resDate ? Math.max(0, now - resDate.getTime()) : 0
     const currentAge = Math.max(apparentAge, resAge ?? 0)
 
-    const hasValidator =
-      (typeof resHeaders.etag === 'string' && isEtagUsable(resHeaders.etag)) ||
-      typeof resHeaders['last-modified'] === 'string'
-
     const staleAt =
-      determineStaleAt(this.#cacheType, now, resAge, resHeaders, resDate, cacheControlDirectives, hasValidator) ??
+      determineStaleAt(this.#cacheType, now, resAge, resHeaders, resDate, cacheControlDirectives) ??
       this.#cacheByDefault
-    // Zero freshness lifetime but a validator: stale from the start, yet still
-    // storable since each reuse is preceded by a revalidation request.
-    // https://www.rfc-editor.org/rfc/rfc9111.html#section-5.2.2.4
-    const revalidationOnly = staleAt === 0 && hasValidator
-    if (staleAt === undefined || (currentAge >= staleAt && !revalidationOnly)) {
+    if (staleAt === undefined || currentAge >= staleAt) {
       if (cacheControlHeader || staleAt !== undefined) {
         deleteCachedValueIfNotModified(statusCode, this.#store, this.#cacheKey)
       }
@@ -287,7 +268,7 @@ class CacheHandler {
 
     const baseTime = now - currentAge
     const absoluteStaleAt = staleAt + baseTime
-    if (now >= absoluteStaleAt && !revalidationOnly) {
+    if (now >= absoluteStaleAt) {
       // Response is already stale
       deleteCachedValueIfNotModified(statusCode, this.#store, this.#cacheKey)
       return downstreamOnHeaders()
@@ -629,12 +610,10 @@ function getAge (ageHeader) {
  * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
  * @param {Date | undefined} responseDate
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
- * @param {boolean} hasValidator whether the response has a validator (etag or
- *  last-modified) that revalidation requests can be made with
  *
  * @returns {number | undefined} time that the value is stale at in seconds or undefined if it shouldn't be cached
  */
-function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheControlDirectives, hasValidator) {
+function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheControlDirectives) {
   if (cacheType === 'shared') {
     // Prioritize s-maxage since we're a shared cache
     //  s-maxage > max-age > Expire
@@ -645,12 +624,7 @@ function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheC
 
     const sMaxAge = cacheControlDirectives['s-maxage']
     if (sMaxAge !== undefined) {
-      if (sMaxAge > 0) {
-        return sMaxAge * 1000
-      }
-
-      // Immediately stale, but storable if we can revalidate it before reuse.
-      return 0
+      return sMaxAge * 1000
     }
   }
 
@@ -660,12 +634,7 @@ function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheC
 
   const maxAge = cacheControlDirectives['max-age']
   if (maxAge !== undefined) {
-    if (maxAge > 0) {
-      return maxAge * 1000
-    }
-
-    // Immediately stale, but storable if we can revalidate it before reuse.
-    return 0
+    return maxAge * 1000
   }
 
   if (Object.hasOwn(resHeaders, 'expires')) {
@@ -718,12 +687,6 @@ function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheC
     return 31536000000
   }
 
-  if (cacheControlDirectives['no-cache'] === true && hasValidator) {
-    // No freshness source, but a validator lets us revalidate before reuse.
-    //  https://www.rfc-editor.org/rfc/rfc9111.html#section-5.2.2.4
-    return 0
-  }
-
   return undefined
 }
 
@@ -760,11 +723,6 @@ function determineDeleteAt (baseTime, cachedAt, cacheControlDirectives, staleAt)
   // revalidated.
   if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity && immutable === -Infinity) {
     const freshnessLifetime = staleAt - baseTime
-    if (freshnessLifetime <= 0) {
-      // Revalidation-only entry: no freshness lifetime to size the buffer on,
-      //  so retain it for a bounded window instead.
-      return cachedAt + REVALIDATION_ONLY_RETENTION
-    }
     const datePrecisionPadding = Math.min(Math.max(cachedAt - baseTime, 0), 1000)
     return staleAt + freshnessLifetime + datePrecisionPadding
   }

package/node_modules/{undici → @mytools/fst-platform/node_modules/undici}/lib/handler/cache-revalidation-handler.js

@@ -109,16 +109,6 @@ class CacheRevalidationHandler {
     }
 
     if (this.#callback) {
-      // Serve the stale cached response on a connection error, per stale-if-error:
-      //  RFC 5861 counts an unreachable origin (a would-be 5xx) as an error.
-      // https://datatracker.ietf.org/doc/html/rfc5861#section-4
-      if (this.#allowErrorStatusCodes) {
-        this.#successful = true
-        this.#callback(true, this.#context)
-        this.#callback = null
-        return
-      }
-
       this.#callback(false)
       this.#callback = null
     }

package/node_modules/@mytools/fst-platform/node_modules/undici/lib/handler/decorator-handler.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const assert = require('node:assert')
+const WrapHandler = require('./wrap-handler')
+
+/**
+ * @deprecated
+ */
+module.exports = class DecoratorHandler {
+  #handler
+  #onCompleteCalled = false
+  #onErrorCalled = false
+  #onResponseStartCalled = false
+
+  constructor (handler) {
+    if (typeof handler !== 'object' || handler === null) {
+      throw new TypeError('handler must be an object')
+    }
+    this.#handler = WrapHandler.wrap(handler)
+  }
+
+  onRequestStart (...args) {
+    this.#handler.onRequestStart?.(...args)
+  }
+
+  onRequestUpgrade (...args) {
+    assert(!this.#onCompleteCalled)
+    assert(!this.#onErrorCalled)
+
+    return this.#handler.onRequestUpgrade?.(...args)
+  }
+
+  onResponseStart (...args) {
+    assert(!this.#onCompleteCalled)
+    assert(!this.#onErrorCalled)
+    assert(!this.#onResponseStartCalled)
+
+    this.#onResponseStartCalled = true
+
+    return this.#handler.onResponseStart?.(...args)
+  }
+
+  onResponseData (...args) {
+    assert(!this.#onCompleteCalled)
+    assert(!this.#onErrorCalled)
+
+    return this.#handler.onResponseData?.(...args)
+  }
+
+  onResponseEnd (...args) {
+    assert(!this.#onCompleteCalled)
+    assert(!this.#onErrorCalled)
+
+    this.#onCompleteCalled = true
+    return this.#handler.onResponseEnd?.(...args)
+  }
+
+  onResponseError (...args) {
+    this.#onErrorCalled = true
+    return this.#handler.onResponseError?.(...args)
+  }
+
+  /**
+   * @deprecated
+   */
+  onBodySent () {}
+}