Part 2

This version tries to expose less sketchiness -- it's not particularly well organized yet, and
I'm sure it could be cleaned up a lot.

Instead of adding the "rawSocket" stuff to RequestOptions, there's a new wrapper ProxyClient added,
which intercepts the CONNECT message and prevents it from being dispatched.

Unfortunately the wrapper client isn't quite written in a way to manage all of the client-ness,
so ProxyAgent is still responsible for updating the PATH of HTTP->HTTP Proxy requests to include
the endpoint domain.

It is messy though, admittedly.

Author: caitp

lib/core/request.js

@@ -42,8 +42,7 @@ class Request {
     reset,
     expectContinue,
     servername,
-    throwOnError,
-    rawSocket
+    throwOnError
   }, handler) {
     if (typeof path !== 'string') {
       throw new InvalidArgumentError('path must be a string')
@@ -95,12 +94,6 @@ class Request {
 
     this.abort = null
 
-    if (rawSocket) {
-      assert(body == null, 'rawSocket cannot be used with body')
-      assert(method === 'CONNECT', 'rawSocket can only be used with CONNECT method')
-    }
-    this.rawSocket = rawSocket
-
     if (body == null) {
       this.body = null
     } else if (isStream(body)) {

lib/dispatcher/client.js

@@ -51,7 +51,7 @@ const {
   kOnError,
   kHTTPContext,
   kMaxConcurrentStreams,
-  kResume, kSocket
+  kResume
 } = require('../core/symbols.js')
 const connectH1 = require('./client-h1.js')
 const connectH2 = require('./client-h2.js')
@@ -598,12 +598,6 @@ function _resume (client, sync) {
       return
     }
 
-    if (!request.aborted && request.rawSocket) {
-      assert(request.method === 'CONNECT')
-      request.onUpgrade(200, [], client[kSocket])
-      request.aborted = true
-    }
-
     if (!request.aborted && client[kHTTPContext].write(request)) {
       client[kPendingIdx]++
     } else {

lib/dispatcher/proxy-agent.js

@@ -1,12 +1,13 @@
 'use strict'
 
-const { kProxy, kClose, kDestroy } = require('../core/symbols')
+const { kProxy, kClose, kDestroy, kDispatch, kConnector } = 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 } = require('../core/errors')
 const buildConnector = require('../core/connect')
+const Client = require('./client')
 
 const kAgent = Symbol('proxy agent')
 const kClient = Symbol('proxy client')
@@ -26,6 +27,61 @@ function defaultFactory (origin, opts) {
 
 const noop = () => {}
 
+class ProxyClient extends DispatcherBase {
+  #client = null
+  constructor (origin, opts) {
+    if (typeof origin === 'string') {
+      origin = new URL(origin)
+    }
+
+    if (origin.protocol !== 'http:' && origin.protocol !== 'https:') {
+      throw new InvalidArgumentError('ProxyClient only supports http and https protocols')
+    }
+
+    super()
+
+    this.#client = new Client(origin, opts)
+  }
+
+  async [kClose] () {
+    await this.#client.close()
+  }
+
+  async [kDestroy] () {
+    await this.#client.destroy()
+  }
+
+  async [kDispatch] (opts, handler) {
+    const { method, origin } = opts
+    if (method === 'CONNECT') {
+      this.#client[kConnector]({
+        origin,
+        port: opts.port || defaultProtocolPort(opts.protocol),
+        path: opts.host,
+        signal: opts.signal,
+        headers: {
+          ...this[kProxyHeaders],
+          host: opts.host
+        },
+        servername: this[kProxyTls]?.servername || opts.servername
+      },
+      (err, socket) => {
+        if (err) {
+          handler.callback(err)
+        } else {
+          handler.callback(null, { socket, statusCode: 200 })
+        }
+      }
+      )
+      return
+    }
+    if (typeof origin === 'string') {
+      opts.origin = new URL(origin)
+    }
+
+    return this.#client.dispatch(opts, handler)
+  }
+}
 class ProxyAgent extends DispatcherBase {
   constructor (opts) {
     if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
@@ -60,9 +116,18 @@ class ProxyAgent extends DispatcherBase {
       this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
     }
 
+    const factory = (!tunnelProxy && protocol === 'http:')
+      ? (origin, options) => {
+          if (origin.protocol === 'http:') {
+            return new ProxyClient(origin, options)
+          }
+          return new Client(origin, options)
+        }
+      : undefined
+
     const connect = buildConnector({ ...opts.proxyTls })
     this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
-    this[kClient] = clientFactory(url, { connect })
+    this[kClient] = clientFactory(url, { connect, factory })
     this[kTunnelProxy] = tunnelProxy
     this[kAgent] = new Agent({
       ...opts,
@@ -71,7 +136,6 @@ class ProxyAgent extends DispatcherBase {
         if (!opts.port) {
           requestedPath += `:${defaultProtocolPort(opts.protocol)}`
         }
-        const shouldConnect = this[kTunnelProxy] || protocol !== 'http:' || opts.protocol !== 'http:'
         try {
           const { socket, statusCode } = await this[kClient].connect({
             origin,
@@ -82,7 +146,6 @@ class ProxyAgent extends DispatcherBase {
               ...this[kProxyHeaders],
               host: opts.host
             },
-            rawSocket: !shouldConnect,
             servername: this[kProxyTls]?.servername || proxyHostname
           })
           if (statusCode !== 200) {
@@ -121,10 +184,8 @@ class ProxyAgent extends DispatcherBase {
       headers.host = host
     }
 
-    // If we have a non-secure, non-tunneling proxy, the server URL is prepended to the
-    // path to ensure that the Proxy can handle the request appropriately.
-    if (!this[kTunnelProxy] && opts.path && opts.origin) {
-      opts.path = `${opts.origin}${opts.path}`
+    if (!this.#shouldConnect(new URL(opts.origin))) {
+      opts.path = opts.origin + opts.path
     }
 
     return this[kAgent].dispatch(
@@ -159,6 +220,19 @@ class ProxyAgent extends DispatcherBase {
     await this[kAgent].destroy()
     await this[kClient].destroy()
   }
+
+  #shouldConnect (uri) {
+    if (typeof uri === 'string') {
+      uri = new URL(uri)
+    }
+    if (this[kTunnelProxy]) {
+      return true
+    }
+    if (uri.protocol !== 'http:' || this[kProxy].protocol !== 'http:') {
+      return true
+    }
+    return false
+  }
 }
 
 /**