pi-cursor-sdk 0.1.50 → 0.1.51

package/node_modules/undici/lib/core/socks5-client.js

@@ -1,422 +0,0 @@
-'use strict'
-
-const { EventEmitter } = require('node:events')
-const { Buffer } = require('node:buffer')
-const { InvalidArgumentError, Socks5ProxyError } = require('./errors')
-const { debuglog } = require('node:util')
-const { parseAddress } = require('./socks5-utils')
-
-const debug = debuglog('undici:socks5')
-const EMPTY_BUFFER = Buffer.alloc(0)
-
-// SOCKS5 constants
-const SOCKS_VERSION = 0x05
-
-// Authentication methods
-const AUTH_METHODS = {
-  NO_AUTH: 0x00,
-  GSSAPI: 0x01,
-  USERNAME_PASSWORD: 0x02,
-  NO_ACCEPTABLE: 0xFF
-}
-
-// SOCKS5 commands
-const COMMANDS = {
-  CONNECT: 0x01,
-  BIND: 0x02,
-  UDP_ASSOCIATE: 0x03
-}
-
-// Address types
-const ADDRESS_TYPES = {
-  IPV4: 0x01,
-  DOMAIN: 0x03,
-  IPV6: 0x04
-}
-
-// Reply codes
-const REPLY_CODES = {
-  SUCCEEDED: 0x00,
-  GENERAL_FAILURE: 0x01,
-  CONNECTION_NOT_ALLOWED: 0x02,
-  NETWORK_UNREACHABLE: 0x03,
-  HOST_UNREACHABLE: 0x04,
-  CONNECTION_REFUSED: 0x05,
-  TTL_EXPIRED: 0x06,
-  COMMAND_NOT_SUPPORTED: 0x07,
-  ADDRESS_TYPE_NOT_SUPPORTED: 0x08
-}
-
-// State machine states
-const STATES = {
-  INITIAL: 'initial',
-  HANDSHAKING: 'handshaking',
-  AUTHENTICATING: 'authenticating',
-  AUTHENTICATED: 'authenticated',
-  CONNECTING: 'connecting',
-  CONNECTED: 'connected',
-  ERROR: 'error',
-  CLOSED: 'closed'
-}
-
-/**
- * SOCKS5 client implementation
- * Handles SOCKS5 protocol negotiation and connection establishment
- */
-class Socks5Client extends EventEmitter {
-  constructor (socket, options = {}) {
-    super()
-
-    if (!socket) {
-      throw new InvalidArgumentError('socket is required')
-    }
-
-    this.socket = socket
-    this.options = options
-    this.state = STATES.INITIAL
-    this.buffer = EMPTY_BUFFER
-    this.onSocketData = this.onData.bind(this)
-    this.onSocketError = this.onError.bind(this)
-    this.onSocketClose = this.onClose.bind(this)
-
-    // Authentication settings
-    this.authMethods = []
-    if (options.username && options.password) {
-      this.authMethods.push(AUTH_METHODS.USERNAME_PASSWORD)
-    }
-    this.authMethods.push(AUTH_METHODS.NO_AUTH)
-
-    // Socket event handlers
-    this.socket.on('data', this.onSocketData)
-    this.socket.on('error', this.onSocketError)
-    this.socket.on('close', this.onSocketClose)
-  }
-
-  /**
-   * Handle incoming data from the socket
-   */
-  onData (data) {
-    debug('received data', data.length, 'bytes in state', this.state)
-    this.buffer = Buffer.concat([this.buffer, data])
-
-    try {
-      switch (this.state) {
-        case STATES.HANDSHAKING:
-          this.handleHandshakeResponse()
-          break
-        case STATES.AUTHENTICATING:
-          this.handleAuthResponse()
-          break
-        case STATES.CONNECTING:
-          this.handleConnectResponse()
-          break
-      }
-    } catch (err) {
-      this.onError(err)
-    }
-  }
-
-  /**
-   * Handle socket errors
-   */
-  onError (err) {
-    debug('socket error', err)
-    this.state = STATES.ERROR
-    this.emit('error', err)
-    this.destroy()
-  }
-
-  /**
-   * Handle socket close
-   */
-  onClose () {
-    debug('socket closed')
-    this.state = STATES.CLOSED
-    this.emit('close')
-  }
-
-  /**
-   * Destroy the client and underlying socket
-   */
-  destroy () {
-    if (this.socket && !this.socket.destroyed) {
-      this.socket.destroy()
-    }
-  }
-
-  markAuthenticated () {
-    this.state = STATES.AUTHENTICATED
-    this.emit('authenticated')
-  }
-
-  /**
-   * Start the SOCKS5 handshake
-   */
-  handshake () {
-    if (this.state !== STATES.INITIAL) {
-      throw new InvalidArgumentError('Handshake already started')
-    }
-
-    debug('starting handshake with', this.authMethods.length, 'auth methods')
-    this.state = STATES.HANDSHAKING
-
-    // Build handshake request
-    // +----+----------+----------+
-    // |VER | NMETHODS | METHODS  |
-    // +----+----------+----------+
-    // | 1  |    1     | 1 to 255 |
-    // +----+----------+----------+
-    const request = Buffer.alloc(2 + this.authMethods.length)
-    request[0] = SOCKS_VERSION
-    request[1] = this.authMethods.length
-    this.authMethods.forEach((method, i) => {
-      request[2 + i] = method
-    })
-
-    this.socket.write(request)
-  }
-
-  /**
-   * Handle handshake response from server
-   */
-  handleHandshakeResponse () {
-    if (this.buffer.length < 2) {
-      return // Not enough data yet
-    }
-
-    const version = this.buffer[0]
-    const method = this.buffer[1]
-
-    if (version !== SOCKS_VERSION) {
-      throw new Socks5ProxyError(`Invalid SOCKS version: ${version}`, 'UND_ERR_SOCKS5_VERSION')
-    }
-
-    if (method === AUTH_METHODS.NO_ACCEPTABLE) {
-      throw new Socks5ProxyError('No acceptable authentication method', 'UND_ERR_SOCKS5_AUTH_REJECTED')
-    }
-
-    this.buffer = this.buffer.subarray(2)
-    debug('server selected auth method', method)
-
-    if (method === AUTH_METHODS.NO_AUTH) {
-      this.markAuthenticated()
-    } else if (method === AUTH_METHODS.USERNAME_PASSWORD) {
-      this.state = STATES.AUTHENTICATING
-      this.sendAuthRequest()
-    } else {
-      throw new Socks5ProxyError(`Unsupported authentication method: ${method}`, 'UND_ERR_SOCKS5_AUTH_METHOD')
-    }
-  }
-
-  /**
-   * Send username/password authentication request
-   */
-  sendAuthRequest () {
-    const { username, password } = this.options
-
-    if (!username || !password) {
-      throw new InvalidArgumentError('Username and password required for authentication')
-    }
-
-    debug('sending username/password auth')
-
-    // Username/Password authentication request (RFC 1929)
-    // +----+------+----------+------+----------+
-    // |VER | ULEN |  UNAME   | PLEN |  PASSWD  |
-    // +----+------+----------+------+----------+
-    // | 1  |  1   | 1 to 255 |  1   | 1 to 255 |
-    // +----+------+----------+------+----------+
-    const usernameBuffer = Buffer.from(username)
-    const passwordBuffer = Buffer.from(password)
-
-    if (usernameBuffer.length > 255 || passwordBuffer.length > 255) {
-      throw new InvalidArgumentError('Username or password too long')
-    }
-
-    const request = Buffer.alloc(3 + usernameBuffer.length + passwordBuffer.length)
-    request[0] = 0x01 // Sub-negotiation version
-    request[1] = usernameBuffer.length
-    usernameBuffer.copy(request, 2)
-    request[2 + usernameBuffer.length] = passwordBuffer.length
-    passwordBuffer.copy(request, 3 + usernameBuffer.length)
-
-    this.socket.write(request)
-  }
-
-  /**
-   * Handle authentication response
-   */
-  handleAuthResponse () {
-    if (this.buffer.length < 2) {
-      return // Not enough data yet
-    }
-
-    const version = this.buffer[0]
-    const status = this.buffer[1]
-
-    if (version !== 0x01) {
-      throw new Socks5ProxyError(`Invalid auth sub-negotiation version: ${version}`, 'UND_ERR_SOCKS5_AUTH_VERSION')
-    }
-
-    if (status !== 0x00) {
-      throw new Socks5ProxyError('Authentication failed', 'UND_ERR_SOCKS5_AUTH_FAILED')
-    }
-
-    this.buffer = this.buffer.subarray(2)
-    debug('authentication successful')
-    this.markAuthenticated()
-  }
-
-  /**
-   * Send CONNECT command
-   * @param {string} address - Target address (IP or domain)
-   * @param {number} port - Target port
-   */
-  connect (address, port) {
-    if (this.state === STATES.CONNECTING || this.state === STATES.CONNECTED) {
-      throw new InvalidArgumentError('Connection already in progress')
-    }
-
-    if (this.state !== STATES.AUTHENTICATED) {
-      throw new InvalidArgumentError('Client must be authenticated before CONNECT')
-    }
-
-    debug('connecting to', address, port)
-    this.state = STATES.CONNECTING
-
-    const request = this.buildConnectRequest(COMMANDS.CONNECT, address, port)
-    this.socket.write(request)
-  }
-
-  /**
-   * Build a SOCKS5 request
-   */
-  buildConnectRequest (command, address, port) {
-    // Parse address to determine type and buffer
-    const { type: addressType, buffer: addressBuffer } = parseAddress(address)
-
-    // Build request
-    // +----+-----+-------+------+----------+----------+
-    // |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
-    // +----+-----+-------+------+----------+----------+
-    // | 1  |  1  | X'00' |  1   | Variable |    2     |
-    // +----+-----+-------+------+----------+----------+
-    const request = Buffer.alloc(4 + addressBuffer.length + 2)
-    request[0] = SOCKS_VERSION
-    request[1] = command
-    request[2] = 0x00 // Reserved
-    request[3] = addressType
-    addressBuffer.copy(request, 4)
-    request.writeUInt16BE(port, 4 + addressBuffer.length)
-
-    return request
-  }
-
-  /**
-   * Handle CONNECT response
-   */
-  handleConnectResponse () {
-    if (this.buffer.length < 4) {
-      return // Not enough data for header
-    }
-
-    const version = this.buffer[0]
-    const reply = this.buffer[1]
-    const addressType = this.buffer[3]
-
-    if (version !== SOCKS_VERSION) {
-      throw new Socks5ProxyError(`Invalid SOCKS version in reply: ${version}`, 'UND_ERR_SOCKS5_REPLY_VERSION')
-    }
-
-    // Calculate the expected response length
-    let responseLength = 4 // VER + REP + RSV + ATYP
-    if (addressType === ADDRESS_TYPES.IPV4) {
-      responseLength += 4 + 2 // IPv4 + port
-    } else if (addressType === ADDRESS_TYPES.DOMAIN) {
-      if (this.buffer.length < 5) {
-        return // Need domain length byte
-      }
-      responseLength += 1 + this.buffer[4] + 2 // length byte + domain + port
-    } else if (addressType === ADDRESS_TYPES.IPV6) {
-      responseLength += 16 + 2 // IPv6 + port
-    } else {
-      throw new Socks5ProxyError(`Invalid address type in reply: ${addressType}`, 'UND_ERR_SOCKS5_ADDR_TYPE')
-    }
-
-    if (this.buffer.length < responseLength) {
-      return // Not enough data for full response
-    }
-
-    if (reply !== REPLY_CODES.SUCCEEDED) {
-      const errorMessage = this.getReplyErrorMessage(reply)
-      throw new Socks5ProxyError(`SOCKS5 connection failed: ${errorMessage}`, `UND_ERR_SOCKS5_REPLY_${reply}`)
-    }
-
-    // Parse bound address and port
-    let boundAddress
-    let offset = 4
-
-    if (addressType === ADDRESS_TYPES.IPV4) {
-      boundAddress = Array.from(this.buffer.subarray(offset, offset + 4)).join('.')
-      offset += 4
-    } else if (addressType === ADDRESS_TYPES.DOMAIN) {
-      const domainLength = this.buffer[offset]
-      offset += 1
-      boundAddress = this.buffer.subarray(offset, offset + domainLength).toString()
-      offset += domainLength
-    } else if (addressType === ADDRESS_TYPES.IPV6) {
-      // Parse IPv6 address from 16-byte buffer
-      const parts = []
-      for (let i = 0; i < 8; i++) {
-        const value = this.buffer.readUInt16BE(offset + i * 2)
-        parts.push(value.toString(16))
-      }
-      boundAddress = parts.join(':')
-      offset += 16
-    }
-
-    const boundPort = this.buffer.readUInt16BE(offset)
-
-    this.buffer = EMPTY_BUFFER
-    this.state = STATES.CONNECTED
-    this.socket.removeListener('data', this.onSocketData)
-
-    debug('connected, bound address:', boundAddress, 'port:', boundPort)
-    this.emit('connected', { address: boundAddress, port: boundPort })
-  }
-
-  /**
-   * Get human-readable error message for reply code
-   */
-  getReplyErrorMessage (reply) {
-    switch (reply) {
-      case REPLY_CODES.GENERAL_FAILURE:
-        return 'General SOCKS server failure'
-      case REPLY_CODES.CONNECTION_NOT_ALLOWED:
-        return 'Connection not allowed by ruleset'
-      case REPLY_CODES.NETWORK_UNREACHABLE:
-        return 'Network unreachable'
-      case REPLY_CODES.HOST_UNREACHABLE:
-        return 'Host unreachable'
-      case REPLY_CODES.CONNECTION_REFUSED:
-        return 'Connection refused'
-      case REPLY_CODES.TTL_EXPIRED:
-        return 'TTL expired'
-      case REPLY_CODES.COMMAND_NOT_SUPPORTED:
-        return 'Command not supported'
-      case REPLY_CODES.ADDRESS_TYPE_NOT_SUPPORTED:
-        return 'Address type not supported'
-      default:
-        return `Unknown error code: ${reply}`
-    }
-  }
-}
-
-module.exports = {
-  Socks5Client,
-  AUTH_METHODS,
-  COMMANDS,
-  ADDRESS_TYPES,
-  REPLY_CODES,
-  STATES
-}

package/node_modules/undici/lib/core/socks5-utils.js

@@ -1,212 +0,0 @@
-'use strict'
-
-const { Buffer } = require('node:buffer')
-const net = require('node:net')
-const { InvalidArgumentError } = require('./errors')
-
-/**
- * Parse an address and determine its type
- * @param {string} address - The address to parse
- * @returns {{type: number, buffer: Buffer}} Address type and buffer
- */
-function parseAddress (address) {
-  // Check if it's an IPv4 address
-  if (net.isIPv4(address)) {
-    const parts = address.split('.').map(Number)
-    return {
-      type: 0x01, // IPv4
-      buffer: Buffer.from(parts)
-    }
-  }
-
-  // Check if it's an IPv6 address
-  if (net.isIPv6(address)) {
-    return {
-      type: 0x04, // IPv6
-      buffer: parseIPv6(address)
-    }
-  }
-
-  // Otherwise, treat as domain name
-  const domainBuffer = Buffer.from(address, 'utf8')
-  if (domainBuffer.length > 255) {
-    throw new InvalidArgumentError('Domain name too long (max 255 bytes)')
-  }
-
-  return {
-    type: 0x03, // Domain
-    buffer: Buffer.concat([Buffer.from([domainBuffer.length]), domainBuffer])
-  }
-}
-
-/**
- * Parse IPv6 address to buffer
- * @param {string} address - IPv6 address string
- * @returns {Buffer} 16-byte buffer
- */
-function parseIPv6 (address) {
-  const buffer = Buffer.alloc(16)
-  let normalizedAddress = address
-
-  // Expand an embedded IPv4 tail into the last two IPv6 groups.
-  if (address.includes('.')) {
-    const lastColonIndex = address.lastIndexOf(':')
-    const ipv4Part = address.slice(lastColonIndex + 1)
-
-    if (net.isIPv4(ipv4Part)) {
-      const octets = ipv4Part.split('.').map(Number)
-      const high = ((octets[0] << 8) | octets[1]).toString(16)
-      const low = ((octets[2] << 8) | octets[3]).toString(16)
-      normalizedAddress = `${address.slice(0, lastColonIndex)}:${high}:${low}`
-    }
-  }
-
-  // Handle compressed notation (::)
-  const doubleColonIndex = normalizedAddress.indexOf('::')
-  if (doubleColonIndex !== -1) {
-    const before = normalizedAddress.slice(0, doubleColonIndex)
-    const after = normalizedAddress.slice(doubleColonIndex + 2)
-    const beforeParts = before === '' ? [] : before.split(':')
-    const afterParts = after === '' ? [] : after.split(':')
-
-    let bufferIndex = 0
-    for (const part of beforeParts) {
-      buffer.writeUInt16BE(parseInt(part, 16), bufferIndex)
-      bufferIndex += 2
-    }
-    bufferIndex = 16 - afterParts.length * 2
-    for (const part of afterParts) {
-      buffer.writeUInt16BE(parseInt(part, 16), bufferIndex)
-      bufferIndex += 2
-    }
-  } else {
-    const parts = normalizedAddress.split(':')
-    for (let i = 0; i < parts.length; i++) {
-      buffer.writeUInt16BE(parseInt(parts[i], 16), i * 2)
-    }
-  }
-
-  return buffer
-}
-
-/**
- * Build a SOCKS5 address buffer
- * @param {number} type - Address type (1=IPv4, 3=Domain, 4=IPv6)
- * @param {Buffer} addressBuffer - The address data
- * @param {number} port - Port number
- * @returns {Buffer} Complete address buffer including type, address, and port
- */
-function buildAddressBuffer (type, addressBuffer, port) {
-  const portBuffer = Buffer.allocUnsafe(2)
-  portBuffer.writeUInt16BE(port, 0)
-
-  return Buffer.concat([
-    Buffer.from([type]),
-    addressBuffer,
-    portBuffer
-  ])
-}
-
-/**
- * Parse address from SOCKS5 response
- * @param {Buffer} buffer - Buffer containing the address
- * @param {number} offset - Starting offset in buffer
- * @returns {{address: string, port: number, bytesRead: number}}
- */
-function parseResponseAddress (buffer, offset = 0) {
-  if (buffer.length < offset + 1) {
-    throw new InvalidArgumentError('Buffer too small to contain address type')
-  }
-
-  const addressType = buffer[offset]
-  let address
-  let currentOffset = offset + 1
-
-  switch (addressType) {
-    case 0x01: { // IPv4
-      if (buffer.length < currentOffset + 6) {
-        throw new InvalidArgumentError('Buffer too small for IPv4 address')
-      }
-      address = Array.from(buffer.subarray(currentOffset, currentOffset + 4)).join('.')
-      currentOffset += 4
-      break
-    }
-
-    case 0x03: { // Domain
-      if (buffer.length < currentOffset + 1) {
-        throw new InvalidArgumentError('Buffer too small for domain length')
-      }
-      const domainLength = buffer[currentOffset]
-      currentOffset += 1
-
-      if (buffer.length < currentOffset + domainLength + 2) {
-        throw new InvalidArgumentError('Buffer too small for domain address')
-      }
-      address = buffer.subarray(currentOffset, currentOffset + domainLength).toString('utf8')
-      currentOffset += domainLength
-      break
-    }
-
-    case 0x04: { // IPv6
-      if (buffer.length < currentOffset + 18) {
-        throw new InvalidArgumentError('Buffer too small for IPv6 address')
-      }
-      // Convert buffer to IPv6 string
-      const parts = []
-      for (let i = 0; i < 8; i++) {
-        const value = buffer.readUInt16BE(currentOffset + i * 2)
-        parts.push(value.toString(16))
-      }
-      address = parts.join(':')
-      currentOffset += 16
-      break
-    }
-
-    default:
-      throw new InvalidArgumentError(`Invalid address type: ${addressType}`)
-  }
-
-  // Parse port
-  if (buffer.length < currentOffset + 2) {
-    throw new InvalidArgumentError('Buffer too small for port')
-  }
-  const port = buffer.readUInt16BE(currentOffset)
-  currentOffset += 2
-
-  return {
-    address,
-    port,
-    bytesRead: currentOffset - offset
-  }
-}
-
-/**
- * Create error for SOCKS5 reply code
- * @param {number} replyCode - SOCKS5 reply code
- * @returns {Error} Appropriate error object
- */
-function createReplyError (replyCode) {
-  const messages = {
-    0x01: 'General SOCKS server failure',
-    0x02: 'Connection not allowed by ruleset',
-    0x03: 'Network unreachable',
-    0x04: 'Host unreachable',
-    0x05: 'Connection refused',
-    0x06: 'TTL expired',
-    0x07: 'Command not supported',
-    0x08: 'Address type not supported'
-  }
-
-  const message = messages[replyCode] || `Unknown SOCKS5 error code: ${replyCode}`
-  const error = new Error(message)
-  error.code = `SOCKS5_${replyCode}`
-  return error
-}
-
-module.exports = {
-  parseAddress,
-  parseIPv6,
-  buildAddressBuffer,
-  parseResponseAddress,
-  createReplyError
-}

package/node_modules/undici/lib/core/symbols.js

@@ -1,75 +0,0 @@
-'use strict'
-
-module.exports = {
-  kClose: Symbol('close'),
-  kDestroy: Symbol('destroy'),
-  kDispatch: Symbol('dispatch'),
-  kUrl: Symbol('url'),
-  kWriting: Symbol('writing'),
-  kResuming: Symbol('resuming'),
-  kQueue: Symbol('queue'),
-  kConnect: Symbol('connect'),
-  kConnecting: Symbol('connecting'),
-  kKeepAliveDefaultTimeout: Symbol('default keep alive timeout'),
-  kKeepAliveMaxTimeout: Symbol('max keep alive timeout'),
-  kKeepAliveTimeoutThreshold: Symbol('keep alive timeout threshold'),
-  kKeepAliveTimeoutValue: Symbol('keep alive timeout'),
-  kKeepAlive: Symbol('keep alive'),
-  kHeadersTimeout: Symbol('headers timeout'),
-  kBodyTimeout: Symbol('body timeout'),
-  kServerName: Symbol('server name'),
-  kLocalAddress: Symbol('local address'),
-  kHost: Symbol('host'),
-  kNoRef: Symbol('no ref'),
-  kBodyUsed: Symbol('used'),
-  kBody: Symbol('abstracted request body'),
-  kRunning: Symbol('running'),
-  kBlocking: Symbol('blocking'),
-  kPending: Symbol('pending'),
-  kSize: Symbol('size'),
-  kBusy: Symbol('busy'),
-  kQueued: Symbol('queued'),
-  kFree: Symbol('free'),
-  kConnected: Symbol('connected'),
-  kClosed: Symbol('closed'),
-  kNeedDrain: Symbol('need drain'),
-  kReset: Symbol('reset'),
-  kDestroyed: Symbol.for('nodejs.stream.destroyed'),
-  kResume: Symbol('resume'),
-  kOnError: Symbol('on error'),
-  kMaxHeadersSize: Symbol('max headers size'),
-  kRunningIdx: Symbol('running index'),
-  kPendingIdx: Symbol('pending index'),
-  kError: Symbol('error'),
-  kClients: Symbol('clients'),
-  kClient: Symbol('client'),
-  kParser: Symbol('parser'),
-  kOnDestroyed: Symbol('destroy callbacks'),
-  kPipelining: Symbol('pipelining'),
-  kSocket: Symbol('socket'),
-  kHostHeader: Symbol('host header'),
-  kConnector: Symbol('connector'),
-  kStrictContentLength: Symbol('strict content length'),
-  kMaxRedirections: Symbol('maxRedirections'),
-  kMaxRequests: Symbol('maxRequestsPerClient'),
-  kProxy: Symbol('proxy agent options'),
-  kCounter: Symbol('socket request counter'),
-  kMaxResponseSize: Symbol('max response size'),
-  kHTTP2Session: Symbol('http2Session'),
-  kHTTP2SessionState: Symbol('http2Session state'),
-  kRetryHandlerDefaultRetry: Symbol('retry agent default retry'),
-  kConstruct: Symbol('constructable'),
-  kListeners: Symbol('listeners'),
-  kHTTPContext: Symbol('http context'),
-  kMaxConcurrentStreams: Symbol('max concurrent streams'),
-  kHTTP2InitialWindowSize: Symbol('http2 initial window size'),
-  kHTTP2ConnectionWindowSize: Symbol('http2 connection window size'),
-  kEnableConnectProtocol: Symbol('http2session connect protocol'),
-  kRemoteSettings: Symbol('http2session remote settings'),
-  kHTTP2Stream: Symbol('http2session client stream'),
-  kPingInterval: Symbol('ping interval'),
-  kNoProxyAgent: Symbol('no proxy agent'),
-  kHttpProxyAgent: Symbol('http proxy agent'),
-  kHttpsProxyAgent: Symbol('https proxy agent'),
-  kSocks5ProxyAgent: Symbol('socks5 proxy agent')
-}