feat: resolve server URLs before calling other listeners

packages/vite/src/node/__tests__/dev.spec.ts

@@ -1,5 +1,8 @@
-import { describe, expect, test } from 'vitest'
-import { resolveConfig } from '..'
+import { afterEach, describe, expect, test } from 'vitest'
+import type { ResolvedServerUrls } from 'vite'
+import { createServer, resolveConfig } from '..'
+import type { ViteDevServer } from '..'
+import { promiseWithResolvers } from '../../shared/utils'
 
 describe('resolveBuildEnvironmentOptions in dev', () => {
   test('build.rollupOptions should not have input in lib', async () => {
@@ -17,3 +20,49 @@ describe('resolveBuildEnvironmentOptions in dev', () => {
     expect(config.build.rollupOptions).not.toHaveProperty('input')
   })
 })
+
+describe('the dev server', () => {
+  let server: ViteDevServer
+
+  afterEach(() => {
+    server?.close()
+  })
+
+  test('resolves the server URLs before the httpServer listening events are called', async () => {
+    expect.assertions(1)
+
+    const options = {
+      port: 5013,
+    }
+
+    const { promise, resolve } =
+      promiseWithResolvers<ResolvedServerUrls | null>()
+    server = await createServer({
+      root: __dirname,
+      logLevel: 'error',
+      server: {
+        strictPort: true,
+        ws: false,
+        ...options,
+      },
+      plugins: [
+        {
+          name: 'test',
+          configureServer(server) {
+            server.httpServer?.on('listening', () => {
+              resolve(server.resolvedUrls)
+            })
+          },
+        },
+      ],
+    })
+
+    await server.listen()
+    const urls = await promise
+
+    expect(urls).toStrictEqual({
+      local: ['http://localhost:5013/'],
+      network: [],
+    })
+  })
+})

packages/vite/src/node/config.ts

@@ -1359,7 +1359,7 @@ export async function resolveConfig(
         )
       : ''
 
-  const server = resolveServerOptions(resolvedRoot, config.server, logger)
+  const server = await resolveServerOptions(resolvedRoot, config.server, logger)
 
   const builder = resolveBuilderOptions(config.builder)
 

packages/vite/src/node/server/__tests__/resolveServerOptions.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi } from 'vitest'
+import { resolveServerOptions } from '../index'
+
+describe('resolveServerOptions', () => {
+  const root = '/test'
+  const logger = {
+    warn: vi.fn(),
+  } as any
+
+  it('should use a default hostname when no host is provided', async () => {
+    const resolvedOptions = await resolveServerOptions(root, {}, logger)
+
+    expect(resolvedOptions.hostname).toStrictEqual({
+      host: 'localhost',
+      name: 'localhost',
+    })
+  })
+
+  it('should resolve the hostname correctly', async () => {
+    const options = {
+      host: '127.0.0.1',
+    }
+    const resolvedOptions = await resolveServerOptions(root, options, logger)
+
+    expect(resolvedOptions.hostname).toStrictEqual({
+      host: '127.0.0.1',
+      name: '127.0.0.1',
+    })
+  })
+})

packages/vite/src/node/server/index.ts

@@ -24,6 +24,7 @@ import {
 } from '../http'
 import type { InlineConfig, ResolvedConfig } from '../config'
 import { resolveConfig } from '../config'
+import type { Hostname } from '../utils'
 import {
   diffDnsOrderChange,
   getServerUrlByHost,
@@ -204,6 +205,8 @@ export interface ResolvedServerOptions
   > {
   fs: Required<FileSystemServeOptions>
   middlewareMode: NonNullable<ServerOptions['middlewareMode']>
+  /** @internal */
+  hostname: Hostname
   sourcemapIgnoreList: Exclude<
     ServerOptions['sourcemapIgnoreList'],
     false | undefined
@@ -646,14 +649,18 @@ export async function _createServer(
       }
     },
     async listen(port?: number, isRestart?: boolean) {
+      if (httpServer) {
+        httpServer.prependListener('listening', () => {
+          server.resolvedUrls = resolveServerUrls(
+            httpServer,
+            config.server,
+            httpsOptions,
+            config,
+          )
+        })
+      }
       await startServer(server, port)
       if (httpServer) {
-        server.resolvedUrls = await resolveServerUrls(
-          httpServer,
-          config.server,
-          httpsOptions,
-          config,
-        )
         if (!isRestart && config.server.open) server.openBrowser()
       }
       return server
@@ -994,7 +1001,6 @@ async function startServer(
   }
 
   const options = server.config.server
-  const hostname = await resolveHostname(options.host)
   const configPort = inlinePort ?? options.port
   // When using non strict port for the dev server, the running port can be different from the config one.
   // When restarting, the original port may be available but to avoid a switch of URL for the running
@@ -1008,7 +1014,7 @@ async function startServer(
   const serverPort = await httpServerStart(httpServer, {
     port,
     strictPort: options.strictPort,
-    host: hostname.host,
+    host: options.hostname.host,
     logger: server.config.logger,
   })
   server._currentServerPort = serverPort
@@ -1086,11 +1092,11 @@ export const serverConfigDefaults = Object.freeze({
   // hotUpdateEnvironments
 } satisfies ServerOptions)
 
-export function resolveServerOptions(
+export async function resolveServerOptions(
   root: string,
   raw: ServerOptions | undefined,
   logger: Logger,
-): ResolvedServerOptions {
+): Promise<ResolvedServerOptions> {
   const _server = mergeWithDefaults(
     {
       ...serverConfigDefaults,
@@ -1102,6 +1108,7 @@ export function resolveServerOptions(
 
   const server: ResolvedServerOptions = {
     ..._server,
+    hostname: await resolveHostname(_server.host),
     fs: {
       ..._server.fs,
       // run searchForWorkspaceRoot only if needed

packages/vite/src/node/utils.ts

@@ -983,12 +983,12 @@ export async function resolveHostname(
   return { host, name }
 }
 
-export async function resolveServerUrls(
+export function resolveServerUrls(
   server: Server,
   options: CommonServerOptions,
   httpsOptions: HttpsServerOptions | undefined,
   config: ResolvedConfig,
-): Promise<ResolvedServerUrls> {
+): ResolvedServerUrls {
   const address = server.address()
 
   const isAddressInfo = (x: any): x is AddressInfo => x?.address
@@ -998,7 +998,7 @@ export async function resolveServerUrls(
 
   const local: string[] = []
   const network: string[] = []
-  const hostname = await resolveHostname(options.host)
+  const hostname = config.server.hostname
   const protocol = options.https ? 'https' : 'http'
   const port = address.port
   const base =