refactor(deploy): unify core app and studio deploy on a shared runner

Both flows now drive a single runDeploy skeleton (fail-fast reporter + one
normalized error handler) and read as the same top-to-bottom sequence of
reported steps, with the ship/title/schema work pulled into named helpers.
Removes the drift between the two deploy paths and their error handling.

Author: gu-stav

packages/@sanity/cli/src/actions/deploy/deployApp.ts

@@ -2,7 +2,6 @@ import {basename, dirname} from 'node:path'
 import {styleText} from 'node:util'
 import {createGzip} from 'node:zlib'
 
-import {CLIError} from '@oclif/core/errors'
 import {exitCodes} from '@sanity/cli-core'
 import {spinner} from '@sanity/cli-core/ux'
 import {getWorkbench} from '@sanity/workbench-cli/deploy'
@@ -25,72 +24,42 @@ import {
   checkBuild,
   checkPackageVersion,
   type CheckReporter,
-  createFailFastReporter,
   verifyOutputDir,
 } from './deployChecks.js'
 import {deployDebug} from './deployDebug.js'
+import {runDeploy} from './deployRunner.js'
 import {findUserApplication} from './findUserApplication.js'
 import {type DeployAppOptions} from './types.js'
 
-type Workbench = ReturnType<typeof getWorkbench>
+export function deployApp(options: DeployAppOptions): Promise<void> {
+  return runDeploy(options, {run: runAppDeployment, type: 'coreApp'})
+}
 
-export async function deployApp(options: DeployAppOptions): Promise<void> {
-  const {cliConfig, output} = options
+/**
+ * Validates the deploy, syncs the title from the manifest, and ships the build.
+ * Every step reports through `reporter`, and the first failure exits — so
+ * reaching any later step means the earlier ones passed.
+ */
+async function runAppDeployment(options: DeployAppOptions, reporter: CheckReporter): Promise<void> {
+  const {cliConfig, flags, output, sourceDir} = options
+  const workDir = options.projectRoot.directory
+  const organizationId = cliConfig.app?.organizationId
   const workbench = getWorkbench(cliConfig)
 
   // A federated app with no entry, view or service would ship a remote with
-  // nothing to load — fail before any prompts or API calls.
+  // nothing to load — reported first so it fails before any prompt or API call.
   if (workbench) {
     try {
       workbench.assertDeployable()
     } catch (err) {
-      output.error(getErrorMessage(err), {exit: exitCodes.USAGE_ERROR})
-      return
-    }
-  }
-
-  try {
-    const reporter = createFailFastReporter(output)
-    await createAppDeployment(options, reporter, workbench)
-  } catch (error) {
-    // Don't throw a generic error when the user cancels a prompt
-    if (error.name === 'ExitPromptError') {
-      output.error('Deployment cancelled by user', {exit: 1})
-      return
-    }
-    if (error instanceof CLIError) {
-      const {message, ...errorOptions} = error
-      output.error(message, {...errorOptions, exit: 1})
-      return
+      reporter.report({
+        exitCode: exitCodes.USAGE_ERROR,
+        message: getErrorMessage(err),
+        name: 'deployable',
+        status: 'fail',
+      })
     }
-    deployDebug('Error deploying application', error)
-    output.error(`Error deploying application: ${error}`, {exit: 1})
   }
-}
-
-interface AppDeployment {
-  application: UserApplication | null
-  isAutoUpdating: boolean
-  manifest: CoreAppManifest | undefined
-  version: string | null
-}
-
-/**
- * Validates the deploy, syncs the title from the manifest, and ships the build.
- *
- * Every step reports through `reporter`. In a real deploy a failed check exits
- * immediately, so reaching any later step means the earlier ones passed. A dry
- * run collects the failures instead and returns before shipping (the guard
- * below), so the steps read as one straight sequence in both modes.
- */
-async function createAppDeployment(
-  options: DeployAppOptions,
-  reporter: CheckReporter,
-  workbench: Workbench,
-): Promise<AppDeployment> {
-  const {cliConfig, flags, output, projectRoot, sourceDir} = options
-  const workDir = projectRoot.directory
-  const organizationId = cliConfig.app?.organizationId
 
   const isAutoUpdating = checkAutoUpdates(reporter, {cliConfig, flags})
 
@@ -145,39 +114,84 @@ async function createAppDeployment(
     })
   }
 
-  // Sync the application title from the manifest when it has changed
-  const titleUpdate = application ? resolveTitleUpdate(manifest, application) : null
-  if (application && titleUpdate) {
-    deployDebug('Updating application title from manifest', titleUpdate)
-    output.log(
-      titleUpdate.from
-        ? `Updating title from "${titleUpdate.from}" to "${titleUpdate.to}"`
-        : `Setting application title to "${titleUpdate.to}"`,
-    )
-    const spin = spinner('Updating application title').start()
-    try {
-      application = await updateUserApplication({
-        applicationId: application.id,
-        appType: 'coreApp',
-        body: {title: titleUpdate.to},
-      })
-      spin.succeed()
-    } catch (err) {
-      spin.fail()
-      const message = getErrorMessage(err)
-      deployDebug('Error updating application title', {message})
-      output.warn(`Error updating application title: ${message}`)
-    }
+  // A real deploy has already exited if anything failed; landing here without a
+  // resolved application or version means the deploy target was never resolved.
+  if (!application || !version) return
+
+  application = await syncApplicationTitle({application, manifest, output})
+  await shipAppDeployment({application, isAutoUpdating, manifest, sourceDir, version})
+
+  logAppDeployed({application, cliConfig, output})
+}
+
+/** Finds the application a deploy targets, creating one when none is configured. */
+async function resolveAppApplication(options: DeployAppOptions): Promise<UserApplication | null> {
+  const {cliConfig, output} = options
+  const organizationId = cliConfig.app?.organizationId ?? ''
+
+  let application = await findUserApplication({cliConfig, organizationId, output})
+  deployDebug('User application found', application)
+
+  if (!application) {
+    deployDebug('No user application found. Creating a new one')
+    application = await createUserApplication(organizationId)
+    deployDebug('User application created', application)
   }
 
-  // A real deploy has already exited if anything failed; landing here without a
-  // resolved application or version means a dry run collected problems — stop
-  // before shipping.
-  if (!application || !version) return {application, isAutoUpdating, manifest, version}
+  return application
+}
 
-  const parentDir = dirname(sourceDir)
-  const base = basename(sourceDir)
-  const tarball = pack(parentDir, {entries: [base]}).pipe(createGzip())
+/** Syncs the application title from the manifest when it has changed. */
+async function syncApplicationTitle({
+  application,
+  manifest,
+  output,
+}: {
+  application: UserApplication
+  manifest: CoreAppManifest | undefined
+  output: DeployAppOptions['output']
+}): Promise<UserApplication> {
+  const titleUpdate = resolveTitleUpdate(manifest, application)
+  if (!titleUpdate) return application
+
+  deployDebug('Updating application title from manifest', titleUpdate)
+  output.log(
+    titleUpdate.from
+      ? `Updating title from "${titleUpdate.from}" to "${titleUpdate.to}"`
+      : `Setting application title to "${titleUpdate.to}"`,
+  )
+  const spin = spinner('Updating application title').start()
+  try {
+    const updated = await updateUserApplication({
+      applicationId: application.id,
+      appType: 'coreApp',
+      body: {title: titleUpdate.to},
+    })
+    spin.succeed()
+    return updated
+  } catch (err) {
+    spin.fail()
+    const message = getErrorMessage(err)
+    deployDebug('Error updating application title', {message})
+    output.warn(`Error updating application title: ${message}`)
+    return application
+  }
+}
+
+async function shipAppDeployment({
+  application,
+  isAutoUpdating,
+  manifest,
+  sourceDir,
+  version,
+}: {
+  application: UserApplication
+  isAutoUpdating: boolean
+  manifest: CoreAppManifest | undefined
+  sourceDir: string
+  version: string
+}): Promise<void> {
+  const tarball = pack(dirname(sourceDir), {entries: [basename(sourceDir)]}).pipe(createGzip())
 
   const spin = spinner('Deploying...').start()
   try {
@@ -194,15 +208,26 @@ async function createAppDeployment(
     throw error
   }
   spin.succeed()
+}
 
+function logAppDeployed({
+  application,
+  cliConfig,
+  output,
+}: {
+  application: UserApplication
+  cliConfig: DeployAppOptions['cliConfig']
+  output: DeployAppOptions['output']
+}): void {
   output.log(`\n🚀 ${styleText('bold', 'Success!')} Application deployed`)
 
-  if (!getAppId(cliConfig)) {
-    output.log(`\n════ ${styleText('bold', 'Next step:')} ════`)
-    output.log(
-      styleText('bold', '\nAdd the deployment.appId to your sanity.cli.js or sanity.cli.ts file:'),
-    )
-    output.log(`
+  if (getAppId(cliConfig)) return
+
+  output.log(`\n════ ${styleText('bold', 'Next step:')} ════`)
+  output.log(
+    styleText('bold', '\nAdd the deployment.appId to your sanity.cli.js or sanity.cli.ts file:'),
+  )
+  output.log(`
 ${styleText(
   'dim',
   `app: {
@@ -215,22 +240,4 @@ ${styleText(
   appId: '${application.id}',
 }\n`,
 )}`)
-  }
-
-  return {application, isAutoUpdating, manifest, version}
-}
-
-async function resolveAppApplication(options: DeployAppOptions): Promise<UserApplication | null> {
-  const {cliConfig, output} = options
-  const organizationId = cliConfig.app?.organizationId ?? ''
-  let application = await findUserApplication({cliConfig, organizationId, output})
-  deployDebug('User application found', application)
-
-  if (!application) {
-    deployDebug('No user application found. Creating a new one')
-    application = await createUserApplication(organizationId)
-    deployDebug('User application created', application)
-  }
-
-  return application
 }

packages/@sanity/cli/src/actions/deploy/deployRunner.ts

@@ -0,0 +1,49 @@
+import {CLIError} from '@oclif/core/errors'
+import {type Output} from '@sanity/cli-core'
+
+import {type CheckReporter, createFailFastReporter} from './deployChecks.js'
+import {deployDebug} from './deployDebug.js'
+import {type DeployAppOptions} from './types.js'
+
+/**
+ * A deploy flow, split into the parts that differ between core apps and studios.
+ * Everything the two share — reporter setup and error handling — lives in
+ * `runDeploy`, so both types read as the same sequence.
+ */
+export interface DeploySpec {
+  /** The step sequence; every step reports through `reporter`. */
+  run: (options: DeployAppOptions, reporter: CheckReporter) => Promise<void>
+  type: 'coreApp' | 'studio'
+}
+
+/**
+ * Runs a deploy flow: the steps report through a fail-fast reporter — the first
+ * failure prints and exits — and any escaping error is normalized to an exit
+ * code.
+ */
+export async function runDeploy(options: DeployAppOptions, spec: DeploySpec): Promise<void> {
+  const {output} = options
+
+  try {
+    await spec.run(options, createFailFastReporter(output))
+  } catch (error) {
+    normalizeDeployError(error, output, spec.type)
+  }
+}
+
+function normalizeDeployError(error: unknown, output: Output, type: 'coreApp' | 'studio'): void {
+  const noun = type === 'coreApp' ? 'application' : 'studio'
+
+  // Ctrl+C on an interactive prompt isn't a real failure
+  if (error instanceof Error && error.name === 'ExitPromptError') {
+    output.error('Deployment cancelled by user', {exit: 1})
+    return
+  }
+  // A failed check already carries its own exit code; keep it
+  if (error instanceof CLIError) {
+    output.error(error.message, {exit: error.oclif?.exit ?? 1})
+    return
+  }
+  deployDebug(`Error deploying ${noun}`, error)
+  output.error(`Error deploying ${noun}: ${error}`, {exit: 1})
+}