fix(setup): launch the docker app the CLI is actually pointed at (#6253)

* fix(setup): detect OrbStack vs Docker Desktop before relaunching the daemon

ensureDocker() always ran `open -a Docker` to relaunch a stopped daemon on
macOS, which silently no-ops for OrbStack users (no Docker.app bundle
exists), leading to a misleading "GUI license acceptance" timeout error.
Now it checks the docker CLI's active context first (accurate regardless
of install location) and falls back to checking for OrbStack.app, so the
wizard launches and messages the app that's actually installed.

* fix(setup): don't let an installed OrbStack override an explicit Docker Desktop context

macDockerApp() fell through to the OrbStack.app existence check whenever
docker context show returned anything other than "orbstack" — including a
known, explicit context like "desktop-linux". With both apps installed but
Docker Desktop active and stopped, this launched OrbStack while daemonUp()
kept polling Docker Desktop's socket, timing out with OrbStack-flavored
guidance for a Docker Desktop problem.

The path fallback now only runs when the context command gives no answer
at all (null); any resolved context is trusted outright.

Flagged identically by Greptile and Cursor Bugbot on PR #6250.

* fix(setup): fall back to the installed app when the context isn't OrbStack

Context detection only fell back to the app bundle when `docker context
show` failed outright, so an OrbStack-only Mac sitting on the `default`
context still resolved to Docker Desktop — the same 90s hang this fix
exists to remove. Treat an explicit OrbStack selection as the only
positive context signal and otherwise pick whichever app is installed.

Read `DOCKER_HOST` first: it overrides the active context, so the
context name is not authoritative while it is set.

* fix(setup): require OrbStack to be installed before selecting it

A context or DOCKER_HOST left behind by an OrbStack uninstall selected an
app that can never launch, turning a working Docker Desktop start into a
guaranteed 90s timeout. Gate the OrbStack signal on the bundle being
present and fall through to whichever app is.

Look in ~/Applications as well as /Applications while here — Homebrew
casks honour --appdir, so a user-local install is not unusual and a
hardcoded /Applications check would misread it as "not installed".

* fix(setup): resolve the docker app through LaunchServices, not fixed paths

A Homebrew `--appdir` can put OrbStack anywhere, so enumerating install
directories will always have a tail that reads a present app as missing
and sends setup to the wrong one. Fall back to LaunchServices when the
well-known directories miss: that is the same lookup `open -a` performs,
so availability now agrees with what the launch will actually do.

* fix(setup): settle the docker app with open(1) instead of probing for it

`path to application` can raise a modal "Where is …?" picker when the name
does not resolve, which in a terminal wizard reads as a hang. Drop it: the
launch itself already answers the question, since `open` exits non-zero
when macOS knows no such app, instantly and without UI.

That inverts the design. Rather than predict which app is installed and
then launch it, pick a provider, try to start it, and let the exit code
correct a guess — so the directory probe no longer has to enumerate every
possible install location to be right.

An explicit OrbStack selection is now never redirected to Docker Desktop.
The CLI is addressing OrbStack's socket, so `docker info` keeps failing no
matter how well Docker Desktop starts; the earlier fallback only replaced
a 90s timeout with a differently worded one. Say the context is stale and
how to fix it instead.

* fix(setup): honour `required` when the docker app fails to launch

db.ts and redis.ts call ensureDocker(false) and branch on the boolean to
offer an external Postgres or Redis instead. Throwing past that aborts the
whole wizard when a working non-Docker path was on the table, so every
post-confirm failure now warns and returns false unless Docker is required.

That covers the 90s-timeout throw too, which ignored `required` before this
branch existed — leaving it as the one path that still aborts would make
the flag mean two different things in one function.

Also name DOCKER_CONTEXT in the stale-selection hint. It overrides the
config context, so `docker context use` alone leaves the CLI pointed at
OrbStack and the next run fails identically.

* improvement(setup): don't tell CLI-runtime users to install Docker Desktop

Having the docker CLI but neither GUI app is exactly what a colima or
Rancher Desktop user looks like, and the failure told them to install
Docker Desktop — advice for a problem they don't have. Name the situation
accurately and add starting an existing runtime as an option.

---------

Co-authored-by: Bohdan Vilishchuk <iamtheflex@gmail.com>

Author: waleedlatif1

scripts/setup/docker.ts

@@ -1,4 +1,7 @@
 import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
 import { SetupError } from './errors.ts'
 import { waitFor } from './probes.ts'
 import * as p from './prompter.ts'
@@ -9,19 +12,105 @@ const INSTALL_HINTS = [
   `or OrbStack (lighter on macOS): ${theme.command('brew install orbstack')}`,
 ]
 
+/**
+ * Reaching this means the docker CLI exists but neither GUI app does, which is
+ * also what a colima or Rancher Desktop user looks like — telling them to
+ * install Docker Desktop would be advice for a problem they don't have.
+ */
+const NO_APP_HINTS = [
+  ...INSTALL_HINTS,
+  `or start your existing runtime its own way, e.g. ${theme.command('colima start')}`,
+]
+
+/** macOS GUI docker providers we know how to launch via `open -a`. */
+const ORBSTACK_APP = { name: 'OrbStack', bundle: 'OrbStack.app' } as const
+const DOCKER_DESKTOP_APP = { name: 'Docker', bundle: 'Docker.app' } as const
+
+type DockerApp = typeof ORBSTACK_APP | typeof DOCKER_DESKTOP_APP
+
+/** Homebrew casks honour `--appdir`, so a user-local install is not unusual. */
+const APP_DIRS = ['/Applications', join(homedir(), 'Applications')]
+
 function daemonUp(): boolean {
   return spawnSync('docker', ['info'], { stdio: 'ignore' }).status === 0
 }
 
+/** Uses `Bun.which` rather than `which`, which is not a standard Windows command. */
 function installed(): boolean {
-  // Bun.which resolves PATH cross-platform (incl. PATHEXT on Windows); `which`
-  // is not a standard Windows command.
   return Bun.which('docker') !== null
 }
 
 /**
- * Returns whether the Docker daemon is available, offering to launch Docker
- * Desktop (macOS) when it's installed but stopped. Never installs anything.
+ * Whether the docker CLI is currently pointed at OrbStack. `DOCKER_HOST` wins
+ * over the active context when set, so it is the only signal worth reading in
+ * that case; otherwise the active context is authoritative, since OrbStack
+ * registers and selects a context named `orbstack`.
+ */
+function orbstackSelected(): boolean {
+  const host = process.env.DOCKER_HOST
+  if (host) return host.includes('.orbstack/')
+  const result = spawnSync('docker', ['context', 'show'], { encoding: 'utf8' })
+  return result.status === 0 && result.stdout.trim() === 'orbstack'
+}
+
+function appInstalled(app: DockerApp): boolean {
+  return APP_DIRS.some((dir) => existsSync(join(dir, app.bundle)))
+}
+
+interface DockerChoice {
+  app: DockerApp
+  /** The CLI names this provider, so no other app can bring its daemon up. */
+  explicit: boolean
+}
+
+/**
+ * Which app to offer to start. Both providers install a `docker` binary, so CLI
+ * presence alone doesn't say which one to launch. An OrbStack selection is
+ * explicit; anything else is a guess the launch is allowed to correct, which is
+ * why the install probe here doesn't have to be exhaustive.
+ */
+function macDockerApp(): DockerChoice {
+  if (orbstackSelected()) return { app: ORBSTACK_APP, explicit: true }
+  const orbstackOnly = appInstalled(ORBSTACK_APP) && !appInstalled(DOCKER_DESKTOP_APP)
+  return { app: orbstackOnly ? ORBSTACK_APP : DOCKER_DESKTOP_APP, explicit: false }
+}
+
+/**
+ * Starts a provider. `open` exits non-zero when macOS knows no such app, which
+ * settles installation authoritatively and without a dialog — it resolves the
+ * name the same way the launch does, so the two cannot disagree.
+ */
+function openApp(app: DockerApp): boolean {
+  return spawnSync('open', ['-a', app.name], { stdio: 'ignore' }).status === 0
+}
+
+/**
+ * Starts the chosen provider, retrying with the other one when the choice was
+ * only a guess. An explicit OrbStack selection is never redirected: `docker
+ * info` would still be addressing OrbStack's socket, so Docker Desktop cannot
+ * satisfy it however successfully it starts.
+ */
+function startDockerApp({ app, explicit }: DockerChoice): DockerApp | null {
+  if (openApp(app)) return app
+  if (explicit) return null
+  const other = app === ORBSTACK_APP ? DOCKER_DESKTOP_APP : ORBSTACK_APP
+  return openApp(other) ? other : null
+}
+
+/**
+ * A launch that failed after the user opted into it. Callers passing
+ * required=false have a non-Docker path to offer, so the reason is worth
+ * surfacing but must not abort the wizard.
+ */
+function launchFailed(required: boolean, message: string, hints: string[]): boolean {
+  if (required) throw new SetupError(message, hints)
+  p.log.warn([message, ...hints].join('\n'))
+  return false
+}
+
+/**
+ * Returns whether the Docker daemon is available, offering to launch the
+ * installed docker app (macOS) when it's stopped. Never installs anything.
  * With required=true, unavailability is a SetupError instead of false.
  */
 export async function ensureDocker(required: boolean): Promise<boolean> {
@@ -41,27 +130,40 @@ export async function ensureDocker(required: boolean): Promise<boolean> {
     return false
   }
 
+  const choice = macDockerApp()
+
   const launch = await p.confirm({
-    message: 'Docker is installed but not running — start Docker Desktop now?',
+    message: `Docker is installed but not running — start ${choice.app.name} now?`,
     initialValue: true,
   })
   if (!launch) {
     if (required) {
       throw new SetupError('Docker is required for this mode.', [
-        'start Docker Desktop, then re-run the wizard',
+        `start ${choice.app.name}, then re-run the wizard`,
       ])
     }
     return false
   }
 
-  spawnSync('open', ['-a', 'Docker'], { stdio: 'ignore' })
+  const app = startDockerApp(choice)
+  if (!app) {
+    return choice.explicit
+      ? launchFailed(required, 'The docker CLI is pointed at OrbStack, which is not installed.', [
+          `reinstall it: ${theme.command('brew install orbstack')}`,
+          `or point the CLI elsewhere: unset DOCKER_HOST and DOCKER_CONTEXT, then ${theme.command('docker context use <name>')}`,
+        ])
+      : launchFailed(required, 'Found the docker CLI, but no app to start.', NO_APP_HINTS)
+  }
+
   const spin = p.spinner()
-  spin.start('Waiting for the Docker daemon…')
+  spin.start(`Waiting for the Docker daemon (${app.name})…`)
   const up = await waitFor(async () => daemonUp(), 90_000, 2000)
   spin.stop(up ? 'Docker is running' : `${glyph.fail} daemon did not come up`)
   if (!up) {
-    throw new SetupError('Docker Desktop did not start within 90s.', [
-      'first-ever launch needs a GUI license acceptance — open Docker Desktop manually once, then re-run',
+    return launchFailed(required, `${app.name} did not start within 90s.`, [
+      app === ORBSTACK_APP
+        ? 'open OrbStack manually once to finish its first-run setup, then re-run'
+        : 'first-ever launch needs a GUI license acceptance — open Docker Desktop manually once, then re-run',
     ])
   }
   return true