fix(devframe): publish a shared server's WS endpoint once it listens

Author: erkamyaman

packages/devframe/src/adapters/__tests__/initiate.test.ts

@@ -232,6 +232,33 @@ describe('adapters/handler', () => {
     }
   })
 
+  it('shared-server tier: publishes the endpoint once a not-yet-listening TLS server listens', async () => {
+    const host = '127.0.0.1'
+    const server = createSecureServer({ allowHTTP1: true })
+    const devtools = initDevframe(defineTestDef('handler-tls-late'), {
+      base: '/__handler-tls-late/',
+      auth: false,
+      host,
+      server: server as any,
+    })
+
+    try {
+      await devtools.ready
+      const internal = getInternalContext(await devtools.context)
+      expect(internal.wsEndpoint).toBeUndefined()
+
+      await new Promise<void>(resolve => server.listen(0, host, resolve))
+      const { port } = server.address() as { port: number }
+      expect(internal.wsEndpoint).toEqual({
+        url: `wss://localhost:${port}/__handler-tls-late/__ws`,
+      })
+    }
+    finally {
+      await devtools.close()
+      await new Promise<void>(resolve => server.close(() => resolve()))
+    }
+  })
+
   it('ws.url tier: advertises the external endpoint verbatim, owns no transport', async () => {
     const devtools = initDevframe(defineTestDef('handler-remote'), { base: '/__handler-remote/', ws: { url: 'wss://devtools.example.com/relay/__ws' } })
 

packages/devframe/src/node/instance-shell.ts

@@ -5,6 +5,7 @@ import type { DevframeRpcConnection, WsOriginRegistry, WsRpcTransport } from 'de
 import type { H3, H3Event } from 'h3'
 import type { Buffer } from 'node:buffer'
 import type { IncomingMessage, Server as NodeHttpServer, ServerResponse } from 'node:http'
+import type { AddressInfo } from 'node:net'
 import type { Duplex } from 'node:stream'
 import type { ConnectionMeta, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcServerFunctions } from '../types'
 import type { DevframeSseOptions, DevframeWsOptions } from '../types/devframe'
@@ -144,14 +145,16 @@ async function bindHttpAndWs(options: BindHttpAndWsOptions): Promise<StartedServ
 
   const address = httpServer.address()
   const resolvedPort = typeof address === 'object' && address ? address.port : port
-  const secure = httpServer instanceof TlsServer
-  const origin = secure
+  const origin = httpServer instanceof TlsServer
     ? `https://${formatHostForUrl(bindHost)}:${resolvedPort}`
     : normalizeHttpServerUrl(bindHost, resolvedPort)
-  const internal = getInternalContext(context)
-  const wsUrl = `${secure ? 'wss' : 'ws'}://${formatHostForUrl(bindHost)}:${resolvedPort}${options.path ?? ''}`
-  if (websocket)
-    internal.setWsEndpoint({ url: wsUrl })
+  let wsUrl: string | undefined
+  const cancelPublish = websocket
+    ? whenListening(httpServer, (boundPort) => {
+        wsUrl = `${wsScheme(httpServer)}://${formatHostForUrl(bindHost)}:${boundPort}${options.path ?? ''}`
+        getInternalContext(context).setWsEndpoint({ url: wsUrl })
+      })
+    : () => {}
 
   return {
     origin,
@@ -161,15 +164,34 @@ async function bindHttpAndWs(options: BindHttpAndWsOptions): Promise<StartedServ
     rpcGroup: core.rpcGroup,
     connectionMeta: () => websocketConnectionMeta(rpcHost, options.path),
     async close() {
+      cancelPublish()
       await closeWs()
       if (ownsHttpServer)
         await new Promise<void>(r => httpServer.close(() => r()))
-      if (websocket && getInternalContext(context).wsEndpoint?.url === wsUrl)
+      if (wsUrl && getInternalContext(context).wsEndpoint?.url === wsUrl)
         getInternalContext(context).setWsEndpoint(undefined)
     },
   }
 }
 
+function wsScheme(server: NodeHttpServer): 'ws' | 'wss' {
+  return server instanceof TlsServer ? 'wss' : 'ws'
+}
+
+function whenListening(server: NodeHttpServer, fn: (port: number, address: AddressInfo) => void): () => void {
+  const run = (): void => {
+    const address = server.address()
+    if (typeof address === 'object' && address)
+      fn(address.port, address)
+  }
+  if (server.listening) {
+    run()
+    return () => {}
+  }
+  server.once('listening', run)
+  return () => server.off('listening', run)
+}
+
 /**
  * Structural view of `Bun.serve`, typed loosely so devframe carries no
  * dependency on Bun's own types (`tsc` runs with Node lib only).
@@ -943,19 +965,12 @@ export function createInstanceShell<TContext extends DevframeNodeContext>(
    * {@link bindHttpAndWs} does the same for the tiers it owns.
    */
   function publishWsEndpoint(server: NodeHttpServer): void {
-    const record = (): void => {
-      const address = server.address()
-      if (typeof address !== 'object' || !address)
-        return
+    whenListening(server, (boundPort, address) => {
       const host = options.host ?? (address.address === '::' || address.address === '0.0.0.0' ? 'localhost' : address.address)
       getInternalContext(ctx).setWsEndpoint({
-        url: `ws://${formatHostForUrl(host)}:${address.port}${routePath}`,
+        url: `${wsScheme(server)}://${formatHostForUrl(host)}:${boundPort}${routePath}`,
       })
-    }
-    if (server.listening)
-      record()
-    else
-      server.once('listening', record)
+    })
   }
 
   function handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): void {