feat(main): fix and extend container engine check with rancher desktop dockerd (#634)

* feat(main): fix and extend container engine check

* feat(ui): include Rancher Desktop in connection error message

- Update error text to mention Docker, Podman, or Rancher Desktop
- Add Rancher Desktop download link
- Align UI messaging with backend detection capabilities
- Improve user guidance for container engine options

* feat: put link in a single row

* feat: adjust and refactor for rancher dockerd

* refactor: add dockerd on error message

* refactor: remove timeout

* refactor: remove rancher check that is not needed

Author: samuv

main/src/container-engine.ts

@@ -1,5 +1,6 @@
 import { exec } from 'node:child_process'
 import { promisify } from 'node:util'
+import { platform } from 'node:os'
 import log from './logger'
 
 const execAsync = promisify(exec)
@@ -10,69 +11,96 @@ interface ContainerEngineStatus {
   available: boolean
 }
 
-interface EngineCheckResult {
-  name: string
-  available: boolean
+// Common installation paths by platform
+const getCommonPaths = (): string[] => {
+  const currentPlatform = platform()
+
+  switch (currentPlatform) {
+    case 'darwin':
+      return [
+        '/Applications/Docker.app/Contents/Resources/bin',
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+        '~/.rd/bin',
+      ]
+    case 'linux':
+      return ['/usr/local/bin', '/opt/homebrew/bin', '/snap/bin', '~/.rd/bin']
+    case 'win32':
+      return [
+        'C:\\Program Files\\Docker\\Docker\\resources\\bin',
+        'C:\\Program Files\\RedHat\\Podman',
+      ]
+    default:
+      return []
+  }
 }
 
-const createEngineResult = (
-  name: string,
-  available: boolean
-): EngineCheckResult => ({
-  name,
-  available,
-})
+const expandPath = (path: string): string =>
+  path.startsWith('~')
+    ? path.replace('~', process.env.HOME || process.env.USERPROFILE || '')
+    : path
 
-const checkCommand = async (
-  command: string,
-  timeout = 5000
-): Promise<boolean> => {
+const createEnhancedPath = (): string => {
+  const commonPaths = getCommonPaths().map(expandPath)
+  const currentPath = process.env.PATH || ''
+  const separator = platform() === 'win32' ? ';' : ':'
+
+  return [...commonPaths, ...currentPath.split(separator)]
+    .filter(Boolean)
+    .join(separator)
+}
+
+const tryCommand = async (command: string): Promise<boolean> => {
   try {
-    await execAsync(command, { timeout })
+    await execAsync(command)
     return true
-  } catch (error) {
-    log.error(`container engine command failed: ${command}`, error)
-    return false
+  } catch {
+    try {
+      await execAsync(command, {
+        env: { ...process.env, PATH: createEnhancedPath() },
+      })
+      return true
+    } catch {
+      return false
+    }
   }
 }
 
-// Individual engine checkers
-const checkDocker = async (): Promise<EngineCheckResult> => {
-  // docker ps requires daemon to be running and accessible
-  const available = await checkCommand('docker ps')
-  return createEngineResult('docker', available)
-}
-
-const checkPodman = async (): Promise<EngineCheckResult> => {
-  // podman ps checks if podman can actually manage containers
-  const available = await checkCommand('podman ps')
-  return createEngineResult('podman', available)
-}
+const getCommandName = (base: string): string =>
+  platform() === 'win32' ? `${base}.exe` : base
 
-const combineEngineResults = (
-  results: EngineCheckResult[]
-): ContainerEngineStatus => {
-  const dockerResult = results.find((r) => r.name === 'docker')
-  const podmanResult = results.find((r) => r.name === 'podman')
+const checkDocker = (): Promise<boolean> =>
+  tryCommand(`${getCommandName('docker')} ps`)
 
-  const docker = dockerResult?.available ?? false
-  const podman = podmanResult?.available ?? false
+const checkPodman = (): Promise<boolean> =>
+  tryCommand(`${getCommandName('podman')} ps`)
 
-  return {
-    docker,
-    podman,
-    available: docker || podman,
-  }
-}
+const createStatus = (
+  docker: boolean,
+  podman: boolean
+): ContainerEngineStatus => ({
+  docker,
+  podman,
+  available: docker || podman,
+})
 
-// Main function - orchestrates the checks
 export const checkContainerEngine =
   async (): Promise<ContainerEngineStatus> => {
-    const engineCheckers = [checkDocker, checkPodman]
-
-    const results = await Promise.all(
-      engineCheckers.map((checker) => checker())
+    const [docker, podman] = await Promise.allSettled([
+      checkDocker(),
+      checkPodman(),
+    ]).then((results) =>
+      results.map((result) => {
+        if (result.status === 'rejected') return false
+        return result.value
+      })
     )
 
-    return combineEngineResults(results)
+    const status = createStatus(!!docker, !!podman)
+
+    if (!status.available) {
+      log.warn('No container engines detected')
+    }
+
+    return status
   }

preload/src/preload.ts

@@ -118,6 +118,7 @@ export interface ElectronAPI {
   checkContainerEngine: () => Promise<{
     docker: boolean
     podman: boolean
+    rancherDesktop: boolean
     available: boolean
   }>
   restartToolhive: () => Promise<{

renderer/src/common/components/error/connection-refused-error.tsx

@@ -125,27 +125,35 @@ export function ConnectionRefusedError() {
       icon={<IllustrationPackage className="size-20" />}
     >
       <p>
-        ToolHive requires either <strong>Docker</strong> or{' '}
-        <strong>Podman</strong> to be installed and running to manage
-        containerized tools and services.
+        ToolHive requires a container engine to be installed and running to
+        manage containerized tools and services. We support{' '}
+        <strong>Docker</strong>, <strong>Podman</strong> or{' '}
+        <strong>Rancher Desktop</strong> (with dockerd - moby).
       </p>
 
       <div className="bg-muted rounded-md p-3 text-sm">
         <p className="mb-2 font-medium">To get started:</p>
         <ol className="list-inside list-decimal space-y-1">
-          <li>Install Docker Desktop or Podman Desktop</li>
+          <li>
+            Install Docker Desktop, Podman Desktop or Rancher Desktop (with
+            dockerd - moby)
+          </li>
           <li>Start the container engine</li>
           <li>Click "Try Again" to continue</li>
         </ol>
       </div>
 
-      <div className="space-y-2 pb-4">
+      <div className="grid grid-cols-1 gap-2 pb-4 md:grid-cols-3">
         <ExternalLinkButton href="https://docs.docker.com/get-docker/">
-          Install Docker Desktop
+          Docker
         </ExternalLinkButton>
 
         <ExternalLinkButton href="https://podman-desktop.io/downloads">
-          Install Podman Desktop
+          Podman
+        </ExternalLinkButton>
+
+        <ExternalLinkButton href="https://rancherdesktop.io/">
+          Rancher
         </ExternalLinkButton>
       </div>
     </BaseErrorScreen>