refactor(deploy): create deployment in one step and consolidate modules

The studio and app deploy commands had grown into long, interleaved
functions. Each deploy now runs through a single createStudioDeployment /
createAppDeployment that validates, prepares and ships the deployment,
reporting through a checks seam, so the commands read as one clear call.

Consolidate the deploy modules into logical homes:

- deployChecks owns the checks seam, the shared step helpers and the
  verdict→target mapping (checkStudioTarget/checkAppTarget). resolveDeployTarget
  owns the verdicts — it already held the --url/studioHost/appId precedence and
  external-URL validation, so it supersedes the inline resolveAppHost.
- findUserApplication merges the two interactive adapters; createUserApplication
  merges the two interactive creators.
- Auto-update rules get one home in resolveAutoUpdates/getAutoUpdateIssueMessage.

Move workbench-specific validation out of the CLI: viewDeployment goes into
@sanity/workbench-cli, exposed through the workbench object.

No behavior change for real deploys — the integration deploy tests pass
unchanged.

Author: gu-stav

packages/@sanity/cli/src/actions/build/__tests__/shouldAutoUpdate.test.ts

@@ -1,7 +1,7 @@
 import {type Output} from '@sanity/cli-core'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {shouldAutoUpdate} from '../shouldAutoUpdate'
+import {resolveAutoUpdates, shouldAutoUpdate} from '../shouldAutoUpdate'
 import {type BuildFlags} from '../types'
 
 describe('shouldAutoUpdate', () => {
@@ -236,3 +236,55 @@ describe('shouldAutoUpdate', () => {
     })
   })
 })
+
+describe('resolveAutoUpdates', () => {
+  it('returns disabled with no issue when nothing is configured', () => {
+    expect(resolveAutoUpdates({cliConfig: {}, flags: {} as BuildFlags})).toEqual({
+      enabled: false,
+      issue: null,
+    })
+  })
+
+  it('reads deployment.autoUpdates without an issue', () => {
+    expect(
+      resolveAutoUpdates({cliConfig: {deployment: {autoUpdates: true}}, flags: {} as BuildFlags}),
+    ).toEqual({enabled: true, issue: null})
+    expect(
+      resolveAutoUpdates({cliConfig: {deployment: {autoUpdates: false}}, flags: {} as BuildFlags}),
+    ).toEqual({enabled: false, issue: null})
+  })
+
+  it('reports the deprecated top-level config', () => {
+    expect(resolveAutoUpdates({cliConfig: {autoUpdates: true}, flags: {} as BuildFlags})).toEqual({
+      enabled: true,
+      issue: {type: 'deprecated-config'},
+    })
+  })
+
+  it('reports a conflict when both configs are present, preferring the new value', () => {
+    expect(
+      resolveAutoUpdates({
+        cliConfig: {autoUpdates: true, deployment: {autoUpdates: false}},
+        flags: {} as BuildFlags,
+      }),
+    ).toEqual({enabled: false, issue: {type: 'conflicting-config'}})
+  })
+
+  it('reports the deprecated flag and takes its value', () => {
+    expect(
+      resolveAutoUpdates({cliConfig: {}, flags: {'auto-updates': true} as BuildFlags}),
+    ).toEqual({enabled: true, issue: {flag: '--auto-updates', type: 'deprecated-flag'}})
+    expect(
+      resolveAutoUpdates({cliConfig: {}, flags: {'auto-updates': false} as BuildFlags}),
+    ).toEqual({enabled: false, issue: {flag: '--no-auto-updates', type: 'deprecated-flag'}})
+  })
+
+  it('lets the flag take precedence over config, masking config issues', () => {
+    expect(
+      resolveAutoUpdates({
+        cliConfig: {autoUpdates: true, deployment: {autoUpdates: true}},
+        flags: {'auto-updates': false} as BuildFlags,
+      }),
+    ).toEqual({enabled: false, issue: {flag: '--no-auto-updates', type: 'deprecated-flag'}})
+  })
+})

packages/@sanity/cli/src/actions/build/shouldAutoUpdate.ts

@@ -9,23 +9,39 @@ import {type BuildFlags} from './types.js'
 interface AutoUpdateSources {
   cliConfig: CliConfig
   flags: BuildFlags | DeployFlags | DevFlags
-  output: Output
 }
 
 /**
- * Compares parameters from various sources to determine whether or not to auto-update.
- * @remarks Throws an error if both the old and new auto update config are used; throws a warning if the old config is used, or if the auto updates flags are used.
+ * The single auto-update configuration problem to surface, if any.
+ * Flag usage takes precedence over config problems: when the deprecated flag
+ * is passed, config is not consulted, so config issues are not reported.
+ */
+type AutoUpdateIssue =
+  | {flag: '--auto-updates' | '--no-auto-updates'; type: 'deprecated-flag'}
+  | {type: 'conflicting-config'}
+  | {type: 'deprecated-config'}
+
+export interface AutoUpdateSettings {
+  enabled: boolean
+  issue: AutoUpdateIssue | null
+}
+
+/**
+ * Owns the auto-update rules: flag-over-config precedence, the deprecated
+ * top-level `autoUpdates` config, and the old/new config conflict.
+ * Returns plain facts so each surface (deploy warnings, dry-run checks)
+ * decides its own presentation.
+ *
  * @internal
  */
-export function shouldAutoUpdate({cliConfig, flags, output}: AutoUpdateSources): boolean {
-  // Auto updates in flags is deprecated; throw a warning if used
+export function resolveAutoUpdates({cliConfig, flags}: AutoUpdateSources): AutoUpdateSettings {
+  // Flags always take precedence over config
   if ('auto-updates' in flags) {
-    const flagUsed = flags['auto-updates'] ? '--auto-updates' : '--no-auto-updates'
-    output.warn(
-      `The ${flagUsed} flag is deprecated for deploy and build commands. Set the autoUpdates option in the deployment section of sanity.cli.ts or sanity.cli.js instead.`,
-    )
-    // Flags always take precedence over config
-    return Boolean(flags['auto-updates'])
+    const enabled = Boolean(flags['auto-updates'])
+    return {
+      enabled,
+      issue: {flag: enabled ? '--auto-updates' : '--no-auto-updates', type: 'deprecated-flag'},
+    }
   }
 
   const hasOldConfig = cliConfig && 'autoUpdates' in cliConfig
@@ -36,30 +52,74 @@ export function shouldAutoUpdate({cliConfig, flags, output}: AutoUpdateSources):
     cliConfig.deployment &&
     'autoUpdates' in cliConfig.deployment
 
-  if (hasOldConfig && hasNewConfig) {
-    output.error(
-      'Found both `autoUpdates` (deprecated) and `deployment.autoUpdates` in sanity.cli.js/.ts. Please remove the deprecated top level `autoUpdates` config.',
-      {
-        exit: 1,
-      },
-    )
+  if (hasNewConfig) {
+    return {
+      enabled: Boolean(cliConfig?.deployment?.autoUpdates),
+      issue: hasOldConfig ? {type: 'conflicting-config'} : null,
+    }
   }
 
   if (hasOldConfig) {
-    output.warn('The autoUpdates config has moved to deployment.autoUpdates.')
-    output.warn(`Please update sanity.cli.ts or sanity.cli.js and make the following change:
-  ${styleText('red', `-  autoUpdates: ${cliConfig.autoUpdates},`)}
-  ${styleText('green', `+  deployment: {autoUpdates: ${cliConfig.autoUpdates}}`)}
-`)
+    return {enabled: Boolean(cliConfig?.autoUpdates), issue: {type: 'deprecated-config'}}
   }
 
-  if (hasNewConfig) {
-    return Boolean(cliConfig?.deployment?.autoUpdates)
+  return {enabled: false, issue: null}
+}
+
+/**
+ * The user-facing message for an auto-update configuration problem.
+ * Shared by every surface that reports the issue (deploy warnings, dry-run
+ * checks) so the wording has one home.
+ *
+ * @internal
+ */
+export function getAutoUpdateIssueMessage(issue: AutoUpdateIssue): string {
+  switch (issue.type) {
+    case 'conflicting-config': {
+      return 'Found both `autoUpdates` (deprecated) and `deployment.autoUpdates` in sanity.cli.js/.ts. Please remove the deprecated top level `autoUpdates` config.'
+    }
+    case 'deprecated-config': {
+      return 'The autoUpdates config has moved to deployment.autoUpdates.'
+    }
+    case 'deprecated-flag': {
+      return `The ${issue.flag} flag is deprecated for deploy and build commands. Set the autoUpdates option in the deployment section of sanity.cli.ts or sanity.cli.js instead.`
+    }
   }
+}
 
-  if (hasOldConfig) {
-    return Boolean(cliConfig?.autoUpdates)
+/**
+ * Resolves the auto-update setting and prints any configuration problem.
+ * @remarks Throws an error if both the old and new auto update config are used; throws a warning if the old config is used, or if the auto updates flags are used.
+ * @internal
+ */
+export function shouldAutoUpdate({
+  cliConfig,
+  flags,
+  output,
+}: AutoUpdateSources & {output: Output}): boolean {
+  const {enabled, issue} = resolveAutoUpdates({cliConfig, flags})
+
+  switch (issue?.type) {
+    case 'conflicting-config': {
+      output.error(getAutoUpdateIssueMessage(issue), {exit: 1})
+      break
+    }
+    case 'deprecated-config': {
+      output.warn(getAutoUpdateIssueMessage(issue))
+      output.warn(`Please update sanity.cli.ts or sanity.cli.js and make the following change:
+  ${styleText('red', `-  autoUpdates: ${cliConfig.autoUpdates},`)}
+  ${styleText('green', `+  deployment: {autoUpdates: ${cliConfig.autoUpdates}}`)}
+`)
+      break
+    }
+    case 'deprecated-flag': {
+      output.warn(getAutoUpdateIssueMessage(issue))
+      break
+    }
+    default: {
+      break
+    }
   }
 
-  return false
+  return enabled
 }