Auto-upgrade

Co-Authored-By: Alfonso Noriega <alfonso.noriega.meneses@gmail.com>

Author: gonzaloriestra

packages/app/src/cli/services/init/init.ts

@@ -124,6 +124,7 @@ async function init(options: InitOptions) {
               await appendFile(joinPath(templateScaffoldDir, '.npmrc'), `auto-install-peers=true\n`)
               break
             }
+            case 'homebrew':
             case 'unknown':
               throw new UnknownPackageManagerError()
           }

packages/cli-kit/src/private/node/constants.ts

@@ -46,6 +46,7 @@ export const environmentVariables = {
   neverUsePartnersApi: 'SHOPIFY_CLI_NEVER_USE_PARTNERS_API',
   skipNetworkLevelRetry: 'SHOPIFY_CLI_SKIP_NETWORK_LEVEL_RETRY',
   maxRequestTimeForNetworkCalls: 'SHOPIFY_CLI_MAX_REQUEST_TIME_FOR_NETWORK_CALLS',
+  noAutoUpgrade: 'SHOPIFY_CLI_NO_AUTO_UPGRADE',
 }
 
 export const defaultThemeKitAccessDomain = 'theme-kit-access.shopifyapps.com'

packages/cli-kit/src/public/node/context/local.ts

@@ -292,4 +292,14 @@ export function opentelemetryDomain(env = process.env): string {
   return isSet(domain) ? domain : 'https://otlp-http-production-cli.shopifysvc.com'
 }
 
+/**
+ * Returns true if the CLIshould not automatically upgrade.
+ *
+ * @param env - The environment variables from the environment of the current process.
+ * @returns True if the CLI should not automatically upgrade.
+ */
+export function noAutoUpgrade(env = process.env): boolean {
+  return isTruthy(env[environmentVariables.noAutoUpgrade])
+}
+
 export type CIMetadata = Metadata

packages/cli-kit/src/public/node/fs.ts

@@ -15,7 +15,7 @@ import {
 
 import {temporaryDirectory, temporaryDirectoryTask} from 'tempy'
 import {sep, join} from 'pathe'
-import {findUp as internalFindUp} from 'find-up'
+import {findUp as internalFindUp, findUpSync as internalFindUpSync} from 'find-up'
 import {minimatch} from 'minimatch'
 import fastGlobLib from 'fast-glob'
 import {
@@ -650,6 +650,23 @@ export async function findPathUp(
   return got ? normalizePath(got) : undefined
 }
 
+/**
+ * Find a file by walking parent directories.
+ *
+ * @param matcher - A pattern or an array of patterns to match a file name.
+ * @param options - Options for the search.
+ * @returns The first path found that matches or `undefined` if none could be found.
+ */
+export function findPathUpSync(
+  matcher: OverloadParameters<typeof internalFindUp>[0],
+  options: OverloadParameters<typeof internalFindUp>[1],
+): ReturnType<typeof internalFindUpSync> {
+  // findUp has odd typing
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const got = internalFindUpSync(matcher as any, options)
+  return got ? normalizePath(got) : undefined
+}
+
 export interface MatchGlobOptions {
   matchBase: boolean
   noglobstar: boolean

packages/cli-kit/src/public/node/hooks/prerun.test.ts

@@ -1,10 +1,19 @@
 import {parseCommandContent, warnOnAvailableUpgrade} from './prerun.js'
-import {checkForCachedNewVersion, packageManagerFromUserAgent} from '../node-package-manager.js'
+import {checkForCachedNewVersion} from '../node-package-manager.js'
 import {cacheClear} from '../../../private/node/conf-store.js'
 import {mockAndCaptureOutput} from '../testing/output.js'
+import {getOutputUpdateCLIReminder, runCLIUpgrade} from '../upgrade.js'
 import {describe, expect, test, vi, afterEach, beforeEach} from 'vitest'
 
 vi.mock('../node-package-manager')
+vi.mock('../upgrade.js', async (importOriginal) => {
+  const actual: any = await importOriginal()
+  return {
+    ...actual,
+    runCLIUpgrade: vi.fn(),
+    getOutputUpdateCLIReminder: vi.fn(),
+  }
+})
 
 beforeEach(() => {
   cacheClear()
@@ -16,12 +25,25 @@ afterEach(() => {
 })
 
 describe('warnOnAvailableUpgrade', () => {
-  test('displays latest version and an install command when a newer exists', async () => {
+  test('runs the upgrade when a newer version exists', async () => {
+    // Given
+    vi.mocked(checkForCachedNewVersion).mockReturnValue('3.0.10')
+    vi.mocked(runCLIUpgrade).mockResolvedValue()
+
+    // When
+    await warnOnAvailableUpgrade()
+
+    // Then
+    expect(runCLIUpgrade).toHaveBeenCalled()
+  })
+
+  test('falls back to warning when the upgrade fails', async () => {
     // Given
     const outputMock = mockAndCaptureOutput()
     vi.mocked(checkForCachedNewVersion).mockReturnValue('3.0.10')
-    vi.mocked(packageManagerFromUserAgent).mockReturnValue('npm')
+    vi.mocked(runCLIUpgrade).mockRejectedValue(new Error('upgrade failed'))
     const installReminder = '💡 Version 3.0.10 available! Run `npm install @shopify/cli@latest`'
+    vi.mocked(getOutputUpdateCLIReminder).mockReturnValue(installReminder)
 
     // When
     await warnOnAvailableUpgrade()
@@ -30,16 +52,15 @@ describe('warnOnAvailableUpgrade', () => {
     expect(outputMock.warn()).toMatch(installReminder)
   })
 
-  test('displays nothing when no newer version exists', async () => {
+  test('does nothing when no newer version exists', async () => {
     // Given
-    const outputMock = mockAndCaptureOutput()
     vi.mocked(checkForCachedNewVersion).mockReturnValue(undefined)
 
     // When
     await warnOnAvailableUpgrade()
 
     // Then
-    expect(outputMock.warn()).toEqual('')
+    expect(runCLIUpgrade).not.toHaveBeenCalled()
   })
 })
 

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

@@ -2,7 +2,7 @@ import {CLI_KIT_VERSION} from '../../common/version.js'
 import {checkForNewVersion, checkForCachedNewVersion} from '../node-package-manager.js'
 import {startAnalytics} from '../../../private/node/analytics.js'
 import {outputDebug, outputWarn} from '../../../public/node/output.js'
-import {getOutputUpdateCLIReminder} from '../../../public/node/upgrade.js'
+import {getOutputUpdateCLIReminder, runCLIUpgrade} from '../../../public/node/upgrade.js'
 import Command from '../../../public/node/base-command.js'
 import {runAtMinimumInterval} from '../../../private/node/conf-store.js'
 import {fetchNotificationsInBackground} from '../notifications-system.js'
@@ -103,11 +103,17 @@ export async function warnOnAvailableUpgrade(): Promise<void> {
   // eslint-disable-next-line no-void
   void checkForNewVersion(cliDependency, currentVersion, {cacheExpiryInHours: 24})
 
-  // Warn if we previously found a new version
+  // Auto-upgrade if we previously found a new version
   await runAtMinimumInterval('warn-on-available-upgrade', {days: 1}, async () => {
     const newerVersion = checkForCachedNewVersion(cliDependency, currentVersion)
     if (newerVersion) {
-      outputWarn(getOutputUpdateCLIReminder(newerVersion))
+      try {
+        await runCLIUpgrade()
+        // eslint-disable-next-line no-catch-all/no-catch-all
+      } catch (error) {
+        outputDebug(`Auto-upgrade failed: ${error}`)
+        outputWarn(getOutputUpdateCLIReminder(newerVersion))
+      }
     }
   })
 }

packages/cli-kit/src/public/node/is-global.test.ts

@@ -4,16 +4,29 @@ import {renderSelectPrompt} from './ui.js'
 import {globalCLIVersion} from './version.js'
 import * as execa from 'execa'
 import {beforeEach, describe, expect, test, vi} from 'vitest'
+import {realpathSync} from 'fs'
 
 vi.mock('./system.js')
 vi.mock('./ui.js')
 vi.mock('execa')
 vi.mock('which')
 vi.mock('./version.js')
 
+// Mock fs.realpathSync at the module level
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs')>()
+  return {
+    ...actual,
+    realpathSync: vi.fn((path: string) => path),
+  }
+})
+
 const globalNPMPath = '/path/to/global/npm'
 const globalYarnPath = '/path/to/global/yarn'
 const globalPNPMPath = '/path/to/global/pnpm'
+const globalHomebrewIntel = '/usr/local/Cellar/shopify-cli/3.89.0/bin/shopify'
+const globalHomebrewAppleSilicon = '/opt/homebrew/Cellar/shopify-cli/3.89.0/bin/shopify'
+const globalHomebrewLinux = '/home/linuxbrew/.linuxbrew/Cellar/shopify-cli/3.89.0/bin/shopify'
 const unknownGlobalPath = '/path/to/global/unknown'
 const localProjectPath = '/path/local'
 
@@ -46,6 +59,12 @@ describe('currentProcessIsGlobal', () => {
 })
 
 describe('inferPackageManagerForGlobalCLI', () => {
+  beforeEach(() => {
+    // Reset mock to return the input path by default (no symlink resolution)
+    vi.mocked(realpathSync).mockClear()
+    vi.mocked(realpathSync).mockImplementation((path) => String(path))
+  })
+
   test('returns yarn if yarn is in path', async () => {
     // Given
     const argv = ['node', globalYarnPath, 'shopify']
@@ -89,6 +108,115 @@ describe('inferPackageManagerForGlobalCLI', () => {
     // Then
     expect(got).toBe('unknown')
   })
+
+  test('returns homebrew if SHOPIFY_HOMEBREW_FORMULA is set', async () => {
+    // Given
+    const argv = ['node', globalHomebrewAppleSilicon, 'shopify']
+    const env = {SHOPIFY_HOMEBREW_FORMULA: 'shopify-cli'}
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv, env)
+
+    // Then
+    expect(got).toBe('homebrew')
+  })
+
+  test('returns homebrew for Intel Mac Cellar path', async () => {
+    // Given
+    const argv = ['node', globalHomebrewIntel, 'shopify']
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv)
+
+    // Then
+    expect(got).toBe('homebrew')
+  })
+
+  test('returns homebrew for Apple Silicon Cellar path', async () => {
+    // Given
+    const argv = ['node', globalHomebrewAppleSilicon, 'shopify']
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv)
+
+    // Then
+    expect(got).toBe('homebrew')
+  })
+
+  test('returns homebrew for Linux Homebrew path', async () => {
+    // Given
+    const argv = ['node', globalHomebrewLinux, 'shopify']
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv)
+
+    // Then
+    expect(got).toBe('homebrew')
+  })
+
+  test('returns homebrew when HOMEBREW_PREFIX matches path', async () => {
+    // Given
+    const argv = ['node', '/opt/homebrew/bin/shopify', 'shopify']
+    const env = {HOMEBREW_PREFIX: '/opt/homebrew'}
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv, env)
+
+    // Then
+    expect(got).toBe('homebrew')
+  })
+
+  test('resolves symlinks to detect actual package manager (yarn)', async () => {
+    // Given: A symlink in /opt/homebrew/bin pointing to yarn global
+    const symlinkPath = '/opt/homebrew/bin/shopify'
+    const realYarnPath = '/Users/user/.config/yarn/global/node_modules/.bin/shopify'
+    const argv = ['node', symlinkPath, 'shopify']
+    const env = {HOMEBREW_PREFIX: '/opt/homebrew'}
+
+    // Mock realpathSync to resolve the symlink
+    vi.mocked(realpathSync).mockReturnValueOnce(realYarnPath)
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv, env)
+
+    // Then: Should detect yarn (from real path), not homebrew (from symlink)
+    expect(got).toBe('yarn')
+    expect(vi.mocked(realpathSync)).toHaveBeenCalledWith(symlinkPath)
+  })
+
+  test('resolves symlinks to detect real homebrew installation', async () => {
+    // Given: A symlink in /opt/homebrew/bin pointing to a Cellar path (real Homebrew)
+    const symlinkPath = '/opt/homebrew/bin/shopify'
+    const realHomebrewPath = '/opt/homebrew/Cellar/shopify-cli/3.89.0/bin/shopify'
+    const argv = ['node', symlinkPath, 'shopify']
+
+    // Mock realpathSync to resolve the symlink
+    vi.mocked(realpathSync).mockReturnValueOnce(realHomebrewPath)
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv)
+
+    // Then: Should still detect homebrew from the real Cellar path
+    expect(got).toBe('homebrew')
+  })
+
+  test('falls back to original path if realpath fails', async () => {
+    // Given: A path that realpathSync cannot resolve
+    const nonExistentPath = '/opt/homebrew/bin/shopify'
+    const argv = ['node', nonExistentPath, 'shopify']
+    const env = {HOMEBREW_PREFIX: '/opt/homebrew'}
+
+    // Mock realpathSync to throw an error
+    vi.mocked(realpathSync).mockImplementationOnce(() => {
+      throw new Error('ENOENT: no such file or directory')
+    })
+
+    // When
+    const got = inferPackageManagerForGlobalCLI(argv, env)
+
+    // Then: Should fall back to checking the original path
+    expect(got).toBe('homebrew')
+  })
 })
 
 describe('installGlobalCLIPrompt', () => {