Trigger auto-upgrade when dev is quit via q or Ctrl+C

The legacy dev UI (Dev.tsx) tore down the process tree with a fixed 2s
setTimeout immediately after the user pressed q or hit Ctrl+C. Because
oclif only invokes the postrun hook after run() resolves, exiting that
early meant the auto-upgrade flow never had a chance to run. Users on
the standard `shopify app dev` path therefore stopped receiving CLI
auto-upgrades after quitting dev.

DevSessionUI.tsx already polled postRunHookHasCompleted() before
exiting, but its setInterval was never cleared and the 5s ceiling was
too tight for an actual upgrade.

This change extracts the shutdown logic into a single helper,
waitForPostRunHookAndExit, in cli-kit's postrun module. Both Dev.tsx
and DevSessionUI.tsx now call it. The helper:

- polls postRunHookHasCompleted() and exits as soon as the hook is done,
- caps the wait at a configurable maxWaitMs (default 30s) so a stuck
  upgrade still terminates the process,
- properly clears its interval and guards against double-exit,
- delegates to the existing treeKill+process.exit path.

Author: alfonso-noriega

packages/app/src/cli/services/dev/ui/components/Dev.test.tsx

@@ -27,6 +27,13 @@ vi.mock('@shopify/cli-kit/node/system', async () => {
 vi.mock('../../../context.js')
 vi.mock('../../fetch.js')
 vi.mock('../../processes/dev-session.js')
+vi.mock('@shopify/cli-kit/node/hooks/postrun', async () => {
+  const actual: any = await vi.importActual('@shopify/cli-kit/node/hooks/postrun')
+  return {
+    ...actual,
+    waitForPostRunHookAndExit: vi.fn(),
+  }
+})
 
 const developerPlatformClient = testDeveloperPlatformClient()
 

packages/app/src/cli/services/dev/ui/components/Dev.tsx

@@ -10,8 +10,7 @@ import {Box, Text, useInput, useStdin} from '@shopify/cli-kit/node/ink'
 import {handleCtrlC} from '@shopify/cli-kit/node/ui'
 import {openURL} from '@shopify/cli-kit/node/system'
 import figures from '@shopify/cli-kit/node/figures'
-import {isUnitTest} from '@shopify/cli-kit/node/context/local'
-import {treeKill} from '@shopify/cli-kit/node/tree-kill'
+import {waitForPostRunHookAndExit} from '@shopify/cli-kit/node/hooks/postrun'
 import {Writable} from 'stream'
 
 export interface DeveloperPreviewController {
@@ -74,12 +73,11 @@ const Dev: FunctionComponent<DevProps> = ({
       setIsShuttingDownMessage('Shutting down dev because of an error ...')
     } else {
       setIsShuttingDownMessage('Shutting down dev ...')
-      setTimeout(() => {
-        if (isUnitTest()) return
-        treeKill(process.pid, 'SIGINT', false, () => {
-          process.exit(0)
-        })
-      }, 2000)
+      // Wait for the oclif postrun hook (which triggers auto-upgrade) to finish before
+      // tree-killing the process tree. Exiting earlier — as we used to with a fixed 2s
+      // timeout — meant `shopify app dev` would never auto-upgrade after the user quit
+      // with `q` or Ctrl+C.
+      waitForPostRunHookAndExit()
     }
     clearInterval(pollingInterval.current)
     await developerPreview.disable()

packages/app/src/cli/services/dev/ui/components/DevSessionUI.test.tsx

@@ -24,6 +24,13 @@ vi.mock('@shopify/cli-kit/node/system', async () => {
 })
 vi.mock('@shopify/cli-kit/node/context/local')
 vi.mock('@shopify/cli-kit/node/tree-kill')
+vi.mock('@shopify/cli-kit/node/hooks/postrun', async () => {
+  const actual: any = await vi.importActual('@shopify/cli-kit/node/hooks/postrun')
+  return {
+    ...actual,
+    waitForPostRunHookAndExit: vi.fn(),
+  }
+})
 
 const mocks = vi.hoisted(() => {
   return {

packages/app/src/cli/services/dev/ui/components/DevSessionUI.tsx

@@ -17,9 +17,7 @@ import {Box, Text, useInput, useStdin} from '@shopify/cli-kit/node/ink'
 import {handleCtrlC} from '@shopify/cli-kit/node/ui'
 import {openURL, terminalSupportsHyperlinks} from '@shopify/cli-kit/node/system'
 import figures from '@shopify/cli-kit/node/figures'
-import {isUnitTest} from '@shopify/cli-kit/node/context/local'
-import {treeKill} from '@shopify/cli-kit/node/tree-kill'
-import {postRunHookHasCompleted} from '@shopify/cli-kit/node/hooks/postrun'
+import {waitForPostRunHookAndExit} from '@shopify/cli-kit/node/hooks/postrun'
 import {Writable} from 'stream'
 
 interface DevStatusShortcut extends TabShortcut {
@@ -70,18 +68,10 @@ const DevSessionUI: FunctionComponent<DevSesionUIProps> = ({
       setIsShuttingDownMessage('Shutting down dev ...')
       await onAbort()
     }
-    if (isUnitTest()) return
-
-    // Wait for the post run hook to complete or timeout after 5 seconds.
-    let totalTime = 0
-    setInterval(() => {
-      if (postRunHookHasCompleted() || totalTime > 5000) {
-        treeKill(process.pid, 'SIGINT', false, () => {
-          process.exit(0)
-        })
-      }
-      totalTime += 100
-    }, 100)
+    // Wait for the oclif postrun hook (which triggers auto-upgrade) to finish before
+    // tree-killing the process tree, otherwise quitting via `q` or Ctrl+C skips
+    // auto-upgrade.
+    waitForPostRunHookAndExit()
   })
 
   const errorHandledProcesses = useMemo(() => {

packages/cli-kit/src/public/node/hooks/postrun.ts

@@ -2,6 +2,7 @@
  * Postrun hook — uses dynamic imports to avoid loading heavy modules (base-command, analytics)
  * at module evaluation time. These are only needed after the command has already finished.
  */
+import {treeKill} from '../tree-kill.js'
 import {Command, Hook} from '@oclif/core'
 
 let postRunHookCompleted = false
@@ -15,6 +16,34 @@ export function postRunHookHasCompleted(): boolean {
   return postRunHookCompleted
 }
 
+/**
+ * Wait for the postrun hook to finish (so auto-upgrade has a chance to run) and then
+ * tree-kill the current process tree before exiting.
+ *
+ * Long-running interactive commands (e.g. `app dev`) need this when the user terminates
+ * the command via `q` or Ctrl+C: oclif only runs the postrun hook after `run()` resolves,
+ * so if we exit too early auto-upgrade never gets to run.
+ */
+export function waitForPostRunHookAndExit(): void {
+  const pollIntervalMs = 100
+  const maxWaitMs = 30000
+
+  let elapsed = 0
+  let terminating = false
+  const handle = setInterval(() => {
+    if (terminating) return
+    if (postRunHookHasCompleted() || elapsed >= maxWaitMs) {
+      terminating = true
+      clearInterval(handle)
+      treeKill(process.pid, 'SIGINT', false, () => {
+        process.exit(0)
+      })
+      return
+    }
+    elapsed += pollIntervalMs
+  }, pollIntervalMs)
+}
+
 // This hook is called after each successful command run. More info: https://oclif.io/docs/hooks
 export const hook: Hook.Postrun = async ({config, Command}) => {
   await detectStopCommand(Command as unknown as typeof Command)