fix: release keep-alive sockets when closing themes:preview server

Make the command's close() async and call server.closeAllConnections()
(Node 18.2+) before server.close(). Without this the undici fetch pool
keeps sockets alive on Linux, preventing server.close() from resolving
and leaving the Node event loop with live handles — which hung mocha
on ubuntu CI since .mocharc.json has no --exit flag. Also makes Ctrl-C
teardown reliable for users.

Also makes the serialize-uploads preview test deterministic by gating
the stubbed upload on a test-controlled resolver rather than asserting
upload counts against real chokidar fs events.

Author: luis-almeida

packages/zcli-themes/src/commands/themes/preview.ts

@@ -132,11 +132,17 @@ export default class Preview extends Command {
       .on('unlink', handleThemeChange)
 
     return {
-      close: () => {
-        // Stop watching file changes before terminating the server
-        watcher.close()
-        server.close()
+      close: async () => {
+        await watcher.close()
         wss.close()
+        // Destroy keep-alive sockets so server.close() doesn't wait on undici's
+        // idle timeout. closeAllConnections requires Node 18.2+; @types/node
+        // v14 doesn't know about it yet.
+        const serverWithCloseAll = server as typeof server & { closeAllConnections?: () => void }
+        serverWithCloseAll.closeAllConnections?.()
+        await new Promise<void>((resolve, reject) =>
+          server.close(err => err ? reject(err) : resolve())
+        )
       }
     }
   }

packages/zcli-themes/tests/functional/preview.test.ts

@@ -21,7 +21,7 @@ describe('themes:preview', function () {
   })
 
   describe('successful preview', () => {
-    let server: { close: () => void }
+    let server: { close: () => Promise<void> }
 
     const preview = test
       .stdout()
@@ -40,8 +40,8 @@ describe('themes:preview', function () {
         server = await PreviewCommand.run([baseThemePath, '--bind', '0.0.0.0', '--port', '9999'])
       })
 
-    afterEach(() => {
-      server.close()
+    afterEach(async () => {
+      await server.close()
     })
 
     preview
@@ -134,20 +134,35 @@ describe('themes:preview', function () {
     preview
       .it('should serialize rapid successive changes instead of uploading concurrently', async () => {
         await waitForWatcherReady()
+        // Gate each upload on a test-controlled resolver so assertions don't
+        // depend on how the OS's chokidar backend coalesces fs events.
+        const pendingResolvers: Array<() => void> = []
+        fetchStub.withArgs(sinon.match({
+          url: 'https://z3ntest.zendesk.com/hc/api/internal/theming/local_preview',
+          method: 'PUT'
+        })).callsFake(() => new Promise(resolve => {
+          pendingResolvers.push(() => resolve({
+            status: 200,
+            ok: true,
+            text: () => Promise.resolve('')
+          }))
+        }))
         const initialCalls = previewUploadCalls()
         const partialsDir = path.join(baseThemePath, 'templates/partials')
         fs.mkdirSync(partialsDir, { recursive: true })
         const paths = ['a.hbs', 'b.hbs', 'c.hbs'].map(name => path.join(partialsDir, name))
         try {
           for (const p of paths) fs.writeFileSync(p, '<div/>')
           await waitForUploadCount(initialCalls + 1)
-          // Let any queued rerun finish; a working serializer produces at
-          // most one in-flight upload plus one queued rerun.
-          await new Promise(resolve => setTimeout(resolve, 500))
-          const calls = previewUploadCalls() - initialCalls
-          expect(calls).to.be.greaterThan(0)
-          expect(calls).to.be.at.most(2)
+          expect(previewUploadCalls() - initialCalls).to.eq(1)
+          pendingResolvers.shift()?.()
+          await waitForUploadCount(initialCalls + 2)
+          pendingResolvers.shift()?.()
+          await new Promise(resolve => setTimeout(resolve, 100))
+          expect(previewUploadCalls() - initialCalls).to.eq(2)
         } finally {
+          // Drain pending uploads so server.close() in afterEach isn't blocked.
+          pendingResolvers.forEach(fn => fn())
           fs.rmSync(partialsDir, { recursive: true, force: true })
         }
       })