fix: handle ECONNRESET errors in Node.js 24.x (#7772)

* fix: handle ECONNRESET errors in Node.js 24.x

- Replace wait-port dependency with custom implementation
- Add retry logic with ECONNRESET error handling
- Add HTTP agent with ECONNRESET handling in proxy
- Enable framework host detection for Node 24+
- Update tests to use new wait-port API

Fixes Node.js 24.x dev server startup failures

* fix: revert detectFrameworkHost change to avoid breaking env injection

* fix: correct ECONNRESET handling in waitPort - reject to trigger retry

* refactor: remove redundant cleanup function per reviewer feedback

* fix: removed proxy.ts handling, setting up for full wait-port.ts handling for econnreset errors

* fix: readded prior retry count to see if it works

Author: ElijahJunaid

package-lock.json

@@ -150,7 +150,6 @@
     "ulid": "3.0.1",
     "update-notifier": "7.3.1",
     "uuid": "11.1.0",
-    "wait-port": "1.1.0",
     "write-file-atomic": "5.0.1",
     "ws": "8.18.3"
   },

package.json

@@ -1,9 +1,9 @@
 import { readFile } from 'fs/promises'
 
 import { HttpsProxyAgent } from 'https-proxy-agent'
-import waitPort from 'wait-port'
 
 import { NETLIFYDEVERR, NETLIFYDEVWARN, exit, log } from '../utils/command-helpers.js'
+import { waitPort } from './wait-port.js'
 
 // https://github.com/TooTallNate/node-https-proxy-agent/issues/89
 // Maybe replace with https://github.com/delvedor/hpagent
@@ -29,7 +29,7 @@ class HttpsProxyAgentWithCA extends HttpsProxyAgent {
 const DEFAULT_HTTP_PORT = 80
 const DEFAULT_HTTPS_PORT = 443
 // 50 seconds
-const AGENT_PORT_TIMEOUT = 50
+const AGENT_PORT_TIMEOUT = 50_000
 
 export const tryGetAgent = async ({
   certificateFile,
@@ -66,12 +66,11 @@ export const tryGetAgent = async ({
 
   let port
   try {
-    port = await waitPort({
-      port: Number.parseInt(proxyUrl.port) || (scheme === 'http' ? DEFAULT_HTTP_PORT : DEFAULT_HTTPS_PORT),
-      host: proxyUrl.hostname,
-      timeout: AGENT_PORT_TIMEOUT,
-      output: 'silent',
-    })
+    port = await waitPort(
+      Number.parseInt(proxyUrl.port) || (scheme === 'http' ? DEFAULT_HTTP_PORT : DEFAULT_HTTPS_PORT),
+      proxyUrl.hostname,
+      AGENT_PORT_TIMEOUT,
+    )
   } catch (error) {
     // unknown error
     // @ts-expect-error TS(2571) FIXME: Object is of type 'unknown'.

src/lib/http-agent.ts

@@ -0,0 +1,57 @@
+import net from 'net'
+
+export const waitPort = async (
+  port: number,
+  host: string,
+  timeout: number,
+  maxRetries?: number,
+): Promise<{ open: boolean; ipVersion?: 4 | 6 }> => {
+  const startTime = Date.now()
+  const retries = maxRetries ?? Math.ceil(timeout / 2000)
+
+  for (let attempt = 0; attempt < retries; attempt++) {
+    if (Date.now() - startTime > timeout) {
+      return { open: false }
+    }
+
+    try {
+      const ipVersion = await new Promise<4 | 6>((resolve, reject) => {
+        const socket = new net.Socket()
+        let isResolved = false
+
+        socket.on('connect', () => {
+          isResolved = true
+          // Detect actual IP version from the connection
+          const detectedVersion = socket.remoteFamily === 'IPv6' ? 6 : 4
+          socket.end()
+          resolve(detectedVersion)
+        })
+
+        socket.on('error', (error) => {
+          if (!isResolved) {
+            isResolved = true
+            socket.destroy()
+            reject(error)
+          }
+        })
+
+        socket.setTimeout(1000, () => {
+          if (!isResolved) {
+            isResolved = true
+            socket.destroy()
+            reject(new Error('Socket timeout'))
+          }
+        })
+
+        socket.connect(port, host)
+      })
+
+      return { open: true, ipVersion }
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100 * (attempt + 1), 1000)))
+      continue
+    }
+  }
+
+  return { open: false }
+}

src/lib/wait-port.ts

@@ -1,8 +1,7 @@
 import { rm } from 'node:fs/promises'
 
-import waitPort from 'wait-port'
-
 import { startSpinner, stopSpinner } from '../lib/spinner.js'
+import { waitPort } from '../lib/wait-port.js'
 
 import { logAndThrowError, log, NETLIFYDEVERR, NETLIFYDEVLOG, chalk } from './command-helpers.js'
 import { runCommand } from './shell.js'
@@ -56,14 +55,13 @@ export const startFrameworkServer = async function ({
       const ipVersion = parseInt(process.versions.node.split('.')[0]) >= 18 ? 6 : 4
       port = { open: true, ipVersion }
     } else {
-      const waitPortPromise = waitPort({
+      const waitPortPromise = waitPort(
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        port: settings.frameworkPort!,
-        host: 'localhost',
-        output: 'silent',
-        timeout: FRAMEWORK_PORT_TIMEOUT_MS,
-        ...(settings.pollingStrategies?.includes('HTTP') && { protocol: 'http' }),
-      })
+        settings.frameworkPort!,
+        'localhost',
+        FRAMEWORK_PORT_TIMEOUT_MS,
+        20,
+      )
 
       const timerId = setTimeout(() => {
         if (!port?.open) {

src/utils/framework-server.ts

@@ -5,8 +5,8 @@ import getPort from 'get-port'
 import fetch from 'node-fetch'
 import semver from 'semver'
 import { describe, test } from 'vitest'
-import waitPort from 'wait-port'
 
+import { waitPort } from '../../../../src/lib/wait-port.js'
 import { cliPath } from '../../utils/cli-path.js'
 import { withMockApi } from '../../utils/mock-api.js'
 import { type SiteBuilder, withSiteBuilder } from '../../utils/site-builder.js'
@@ -48,12 +48,8 @@ const withFunctionsServer = async (
       console.log(data.toString())
     })
 
-    const { open } = await waitPort({
-      port,
-      output: 'silent',
-      timeout: SERVE_TIMEOUT,
-    })
-    if (!open) {
+    const result = await waitPort(port, 'localhost', SERVE_TIMEOUT)
+    if (!result.open) {
       throw new Error('Timed out waiting for functions server')
     }
     return await testHandler()