pi-cursor-sdk 0.1.50 → 0.1.52

package/node_modules/undici/lib/dispatcher/pool-base.js

@@ -1,214 +0,0 @@
-'use strict'
-
-const { PoolStats } = require('../util/stats.js')
-const DispatcherBase = require('./dispatcher-base')
-const FixedQueue = require('./fixed-queue')
-const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require('../core/symbols')
-
-const kClients = Symbol('clients')
-const kNeedDrain = Symbol('needDrain')
-const kQueue = Symbol('queue')
-const kClosedResolve = Symbol('closed resolve')
-const kOnDrain = Symbol('onDrain')
-const kOnConnect = Symbol('onConnect')
-const kOnDisconnect = Symbol('onDisconnect')
-const kOnConnectionError = Symbol('onConnectionError')
-const kGetDispatcher = Symbol('get dispatcher')
-const kAddClient = Symbol('add client')
-const kRemoveClient = Symbol('remove client')
-
-class PoolBase extends DispatcherBase {
-  [kQueue] = new FixedQueue();
-
-  [kQueued] = 0;
-
-  [kClients] = [];
-
-  [kNeedDrain] = false;
-
-  [kOnDrain] (client, origin, targets) {
-    const queue = this[kQueue]
-
-    let needDrain = false
-
-    while (!needDrain) {
-      const item = queue.shift()
-      if (!item) {
-        break
-      }
-      this[kQueued]--
-      needDrain = !client.dispatch(item.opts, item.handler)
-    }
-
-    client[kNeedDrain] = needDrain
-
-    if (!needDrain && this[kNeedDrain]) {
-      this[kNeedDrain] = false
-      this.emit('drain', origin, [this, ...targets])
-    }
-
-    if (this[kClosedResolve] && queue.isEmpty()) {
-      const closeAll = []
-      for (let i = 0; i < this[kClients].length; i++) {
-        const client = this[kClients][i]
-        if (!client.destroyed) {
-          closeAll.push(client.close())
-        }
-      }
-      return Promise.all(closeAll)
-        .then(this[kClosedResolve])
-    }
-  }
-
-  [kOnConnect] = (origin, targets) => {
-    this.emit('connect', origin, [this, ...targets])
-  };
-
-  [kOnDisconnect] = (origin, targets, err) => {
-    this.emit('disconnect', origin, [this, ...targets], err)
-  };
-
-  [kOnConnectionError] = (origin, targets, err) => {
-    this.emit('connectionError', origin, [this, ...targets], err)
-  }
-
-  get [kBusy] () {
-    return this[kNeedDrain]
-  }
-
-  get [kConnected] () {
-    let ret = 0
-    for (const { [kConnected]: connected } of this[kClients]) {
-      ret += connected
-    }
-    return ret
-  }
-
-  get [kFree] () {
-    let ret = 0
-    for (const { [kConnected]: connected, [kNeedDrain]: needDrain } of this[kClients]) {
-      ret += connected && !needDrain
-    }
-    return ret
-  }
-
-  get [kPending] () {
-    let ret = this[kQueued]
-    for (const { [kPending]: pending } of this[kClients]) {
-      ret += pending
-    }
-    return ret
-  }
-
-  get [kRunning] () {
-    let ret = 0
-    for (const { [kRunning]: running } of this[kClients]) {
-      ret += running
-    }
-    return ret
-  }
-
-  get [kSize] () {
-    let ret = this[kQueued]
-    for (const { [kSize]: size } of this[kClients]) {
-      ret += size
-    }
-    return ret
-  }
-
-  get stats () {
-    return new PoolStats(this)
-  }
-
-  [kClose] () {
-    if (this[kQueue].isEmpty()) {
-      const closeAll = []
-      for (let i = 0; i < this[kClients].length; i++) {
-        const client = this[kClients][i]
-        if (!client.destroyed) {
-          closeAll.push(client.close())
-        }
-      }
-      return Promise.all(closeAll)
-    } else {
-      return new Promise((resolve) => {
-        this[kClosedResolve] = resolve
-      })
-    }
-  }
-
-  [kDestroy] (err) {
-    while (true) {
-      const item = this[kQueue].shift()
-      if (!item) {
-        break
-      }
-      item.handler.onError(err)
-    }
-
-    const destroyAll = new Array(this[kClients].length)
-    for (let i = 0; i < this[kClients].length; i++) {
-      destroyAll[i] = this[kClients][i].destroy(err)
-    }
-    return Promise.all(destroyAll)
-  }
-
-  [kDispatch] (opts, handler) {
-    const dispatcher = this[kGetDispatcher]()
-
-    if (!dispatcher) {
-      this[kNeedDrain] = true
-      this[kQueue].push({ opts, handler })
-      this[kQueued]++
-    } else if (!dispatcher.dispatch(opts, handler)) {
-      dispatcher[kNeedDrain] = true
-      this[kNeedDrain] = !this[kGetDispatcher]()
-    }
-
-    return !this[kNeedDrain]
-  }
-
-  [kAddClient] (client) {
-    client
-      .on('drain', this[kOnDrain].bind(this, client))
-      .on('connect', this[kOnConnect])
-      .on('disconnect', this[kOnDisconnect])
-      .on('connectionError', this[kOnConnectionError])
-
-    this[kClients].push(client)
-
-    if (this[kNeedDrain]) {
-      queueMicrotask(() => {
-        if (this[kNeedDrain]) {
-          this[kOnDrain](client, client[kUrl], [client, this])
-        }
-      })
-    }
-
-    return this
-  }
-
-  [kRemoveClient] (client) {
-    client.close(() => {
-      const idx = this[kClients].indexOf(client)
-      if (idx !== -1) {
-        this[kClients].splice(idx, 1)
-      }
-    })
-
-    this[kNeedDrain] = this[kClients].some(dispatcher => (
-      !dispatcher[kNeedDrain] &&
-      dispatcher.closed !== true &&
-      dispatcher.destroyed !== true
-    ))
-  }
-}
-
-module.exports = {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kRemoveClient,
-  kGetDispatcher
-}

package/node_modules/undici/lib/dispatcher/pool.js

@@ -1,118 +0,0 @@
-'use strict'
-
-const {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kGetDispatcher,
-  kRemoveClient
-} = require('./pool-base')
-const Client = require('./client')
-const {
-  InvalidArgumentError
-} = require('../core/errors')
-const util = require('../core/util')
-const { kUrl } = require('../core/symbols')
-const buildConnector = require('../core/connect')
-
-const kOptions = Symbol('options')
-const kConnections = Symbol('connections')
-const kFactory = Symbol('factory')
-
-function defaultFactory (origin, opts) {
-  return new Client(origin, opts)
-}
-
-class Pool extends PoolBase {
-  constructor (origin, {
-    connections,
-    factory = defaultFactory,
-    connect,
-    connectTimeout,
-    tls,
-    maxCachedSessions,
-    socketPath,
-    autoSelectFamily,
-    autoSelectFamilyAttemptTimeout,
-    allowH2,
-    clientTtl,
-    ...options
-  } = {}) {
-    if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
-      throw new InvalidArgumentError('invalid connections')
-    }
-
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
-
-    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
-      throw new InvalidArgumentError('connect must be a function or an object')
-    }
-
-    if (typeof connect !== 'function') {
-      connect = buildConnector({
-        ...tls,
-        maxCachedSessions,
-        allowH2,
-        socketPath,
-        timeout: connectTimeout,
-        ...(typeof autoSelectFamily === 'boolean' ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
-        ...connect
-      })
-    }
-
-    super(options)
-
-    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.on('connect', (origin, targets) => {
-      if (clientTtl != null && clientTtl > 0) {
-        for (const target of targets) {
-          Object.assign(target, { ttl: Date.now() })
-        }
-      }
-    })
-
-    this.on('connectionError', (origin, targets, error) => {
-      // If a connection error occurs, we remove the client from the pool,
-      // and emit a connectionError event. They will not be re-used.
-      // Fixes https://github.com/nodejs/undici/issues/3895
-      for (const target of targets) {
-        // Do not use kRemoveClient here, as it will close the client,
-        // but the client cannot be closed in this state.
-        const idx = this[kClients].indexOf(target)
-        if (idx !== -1) {
-          this[kClients].splice(idx, 1)
-        }
-      }
-    })
-  }
-
-  [kGetDispatcher] () {
-    const clientTtlOption = this[kOptions].clientTtl
-    for (const client of this[kClients]) {
-      // check ttl of client and if it's stale, remove it from the pool
-      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
-        this[kRemoveClient](client)
-      } else if (!client[kNeedDrain]) {
-        return client
-      }
-    }
-
-    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
-      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
-      this[kAddClient](dispatcher)
-      return dispatcher
-    }
-  }
-}
-
-module.exports = Pool

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

@@ -1,319 +0,0 @@
-'use strict'
-
-const { kProxy, kClose, kDestroy, kDispatch } = require('../core/symbols')
-const Agent = require('./agent')
-const Pool = require('./pool')
-const DispatcherBase = require('./dispatcher-base')
-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 kAgent = Symbol('proxy agent')
-const kClient = Symbol('proxy client')
-const kProxyHeaders = Symbol('proxy headers')
-const kRequestTls = Symbol('request tls settings')
-const kProxyTls = Symbol('proxy tls settings')
-const kConnectEndpoint = Symbol('connect endpoint function')
-const kTunnelProxy = Symbol('tunnel proxy')
-
-function defaultProtocolPort (protocol) {
-  return protocol === 'https:' ? 443 : 80
-}
-
-function defaultFactory (origin, opts) {
-  return new Pool(origin, opts)
-}
-
-const noop = () => {}
-
-function defaultAgentFactory (origin, opts) {
-  if (opts.connections === 1) {
-    return new Client(origin, opts)
-  }
-  return new Pool(origin, opts)
-}
-
-class Http1ProxyWrapper extends DispatcherBase {
-  #client
-
-  constructor (proxyUrl, { headers = {}, connect, factory }) {
-    if (!proxyUrl) {
-      throw new InvalidArgumentError('Proxy URL is mandatory')
-    }
-
-    super()
-
-    this[kProxyHeaders] = headers
-    if (factory) {
-      this.#client = factory(proxyUrl, { connect })
-    } else {
-      this.#client = new Client(proxyUrl, { connect })
-    }
-  }
-
-  [kDispatch] (opts, handler) {
-    const onHeaders = handler.onHeaders
-    handler.onHeaders = function (statusCode, data, resume) {
-      if (statusCode === 407) {
-        if (typeof handler.onError === 'function') {
-          handler.onError(new InvalidArgumentError('Proxy Authentication Required (407)'))
-        }
-        return
-      }
-      if (onHeaders) onHeaders.call(this, statusCode, data, resume)
-    }
-
-    // Rewrite request as an HTTP1 Proxy request, without tunneling.
-    const {
-      origin,
-      path = '/',
-      headers = {}
-    } = opts
-
-    opts.path = origin + path
-
-    if (!('host' in headers) && !('Host' in headers)) {
-      const { host } = new URL(origin)
-      headers.host = host
-    }
-    opts.headers = { ...this[kProxyHeaders], ...headers }
-
-    return this.#client[kDispatch](opts, handler)
-  }
-
-  [kClose] () {
-    return this.#client.close()
-  }
-
-  [kDestroy] (err) {
-    return this.#client.destroy(err)
-  }
-}
-
-class ProxyAgent extends DispatcherBase {
-  constructor (opts) {
-    if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
-      throw new InvalidArgumentError('Proxy uri is mandatory')
-    }
-
-    const { clientFactory = defaultFactory } = opts
-    if (typeof clientFactory !== 'function') {
-      throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
-    }
-
-    const { proxyTunnel = true } = opts
-
-    super()
-
-    const url = this.#getUrl(opts)
-    const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
-
-    this[kProxy] = { uri: href, protocol }
-    this[kRequestTls] = opts.requestTls
-    this[kProxyTls] = opts.proxyTls
-    this[kProxyHeaders] = opts.headers || {}
-    this[kTunnelProxy] = proxyTunnel
-
-    if (opts.auth && opts.token) {
-      throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
-    } else if (opts.auth) {
-      /* @deprecated in favour of opts.token */
-      this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
-    } else if (opts.token) {
-      this[kProxyHeaders]['proxy-authorization'] = opts.token
-    } else if (username && password) {
-      this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
-    }
-
-    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,
-          proxyTls: opts.proxyTls,
-          requestTls: opts.requestTls
-        })
-      }
-
-      if (!this[kTunnelProxy] && protocol === 'http:' && this[kProxy].protocol === 'http:') {
-        return new Http1ProxyWrapper(this[kProxy].uri, {
-          headers: this[kProxyHeaders],
-          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[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 = {
-            origin,
-            port,
-            path: requestedPath,
-            signal: opts.signal,
-            headers: {
-              ...this[kProxyHeaders],
-              host: opts.host,
-              ...(opts.connections == null || opts.connections > 0 ? { 'proxy-connection': 'keep-alive' } : {})
-            },
-            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
-          }
-          let servername
-          if (this[kRequestTls]) {
-            servername = this[kRequestTls].servername
-          } else {
-            servername = opts.servername
-          }
-          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 {
-            callback(err)
-          }
-        }
-      }
-    })
-  }
-
-  dispatch (opts, handler) {
-    const headers = buildHeaders(opts.headers)
-    throwIfProxyAuthIsSent(headers)
-
-    if (headers && !('host' in headers) && !('Host' in headers)) {
-      const { host } = new URL(opts.origin)
-      headers.host = host
-    }
-
-    return this[kAgent].dispatch(
-      {
-        ...opts,
-        headers
-      },
-      handler
-    )
-  }
-
-  /**
-   * @param {import('../../types/proxy-agent').ProxyAgent.Options | string | URL} opts
-   * @returns {URL}
-   */
-  #getUrl (opts) {
-    if (typeof opts === 'string') {
-      return new URL(opts)
-    } else if (opts instanceof URL) {
-      return opts
-    } else {
-      return new URL(opts.uri)
-    }
-  }
-
-  [kClose] () {
-    const promises = [this[kAgent].close()]
-    if (this[kClient]) {
-      promises.push(this[kClient].close())
-    }
-    return Promise.all(promises)
-  }
-
-  [kDestroy] () {
-    const promises = [this[kAgent].destroy()]
-    if (this[kClient]) {
-      promises.push(this[kClient].destroy())
-    }
-    return Promise.all(promises)
-  }
-}
-
-/**
- * @param {string[] | Record<string, string>} headers
- * @returns {Record<string, string>}
- */
-function buildHeaders (headers) {
-  // When using undici.fetch, the headers list is stored
-  // as an array.
-  if (Array.isArray(headers)) {
-    /** @type {Record<string, string>} */
-    const headersPair = {}
-
-    for (let i = 0; i < headers.length; i += 2) {
-      headersPair[headers[i]] = headers[i + 1]
-    }
-
-    return headersPair
-  }
-
-  return headers
-}
-
-/**
- * @param {Record<string, string>} headers
- *
- * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
- * Nevertheless, it was changed and to avoid a security vulnerability by end users
- * this check was created.
- * It should be removed in the next major version for performance reasons
- */
-function throwIfProxyAuthIsSent (headers) {
-  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')
-  }
-}
-
-module.exports = ProxyAgent

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

@@ -1,35 +0,0 @@
-'use strict'
-
-const Dispatcher = require('./dispatcher')
-const RetryHandler = require('../handler/retry-handler')
-
-class RetryAgent extends Dispatcher {
-  #agent = null
-  #options = null
-  constructor (agent, options = {}) {
-    super(options)
-    this.#agent = agent
-    this.#options = options
-  }
-
-  dispatch (opts, handler) {
-    const retry = new RetryHandler({
-      ...opts,
-      retryOptions: this.#options
-    }, {
-      dispatch: this.#agent.dispatch.bind(this.#agent),
-      handler
-    })
-    return this.#agent.dispatch(opts, retry)
-  }
-
-  close () {
-    return this.#agent.close()
-  }
-
-  destroy () {
-    return this.#agent.destroy()
-  }
-}
-
-module.exports = RetryAgent