@sanity/cli 3.65.2-upgrade-vite-v5.31 → 3.66.1

package/src/actions/init-project/bootstrapRemoteTemplate.ts

@@ -0,0 +1,77 @@
+import {mkdir} from 'node:fs/promises'
+import {join} from 'node:path'
+
+import {debug} from '../../debug'
+import {type CliCommandContext} from '../../types'
+import {
+  applyEnvVariables,
+  checkNeedsReadToken,
+  downloadAndExtractRepo,
+  generateSanityApiReadToken,
+  getMonoRepo,
+  isNextJsTemplate,
+  type RepoInfo,
+  tryApplyPackageName,
+  validateRemoteTemplate,
+} from '../../util/remoteTemplate'
+import {type GenerateConfigOptions} from './createStudioConfig'
+import {tryGitInit} from './git'
+import {updateInitialTemplateMetadata} from './updateInitialTemplateMetadata'
+
+export interface BootstrapRemoteOptions {
+  outputPath: string
+  repoInfo: RepoInfo
+  bearerToken?: string
+  packageName: string
+  variables: GenerateConfigOptions['variables']
+}
+
+const INITIAL_COMMIT_MESSAGE = 'Initial commit from Sanity CLI'
+
+export async function bootstrapRemoteTemplate(
+  opts: BootstrapRemoteOptions,
+  context: CliCommandContext,
+): Promise<void> {
+  const {outputPath, repoInfo, bearerToken, variables, packageName} = opts
+  const {output, apiClient} = context
+  const name = [repoInfo.username, repoInfo.name, repoInfo.filePath].filter(Boolean).join('/')
+  const spinner = output.spinner(`Bootstrapping files from template "${name}"`).start()
+
+  debug('Validating remote template')
+  const packages = await getMonoRepo(repoInfo, bearerToken)
+  await validateRemoteTemplate(repoInfo, packages, bearerToken)
+
+  debug('Create new directory "%s"', outputPath)
+  await mkdir(outputPath, {recursive: true})
+
+  debug('Downloading and extracting repo to %s', outputPath)
+  await downloadAndExtractRepo(outputPath, repoInfo, bearerToken)
+
+  debug('Checking if template needs read token')
+  const needsReadToken = await Promise.all(
+    (packages ?? ['']).map((pkg) => checkNeedsReadToken(join(outputPath, pkg))),
+  ).then((results) => results.some(Boolean))
+
+  debug('Applying environment variables')
+  const readToken = needsReadToken
+    ? await generateSanityApiReadToken('API Read Token', variables.projectId, apiClient)
+    : undefined
+  const isNext = await isNextJsTemplate(outputPath)
+  const envName = isNext ? '.env.local' : '.env'
+
+  for (const folder of packages ?? ['']) {
+    const path = join(outputPath, folder)
+    await applyEnvVariables(path, {...variables, readToken}, envName)
+  }
+
+  debug('Setting package name to %s', packageName)
+  await tryApplyPackageName(outputPath, packageName)
+
+  debug('Initializing git repository')
+  tryGitInit(outputPath, INITIAL_COMMIT_MESSAGE)
+
+  debug('Updating initial template metadata')
+  await updateInitialTemplateMetadata(apiClient, variables.projectId, `external-${name}`)
+
+  spinner.succeed()
+}

package/src/actions/init-project/initProject.ts

@@ -35,17 +35,21 @@ import {
   type CliCommandDefinition,
   type SanityCore,
   type SanityModuleInternal,
+  type SanityUser,
 } from '../../types'
 import {getClientWrapper} from '../../util/clientWrapper'
 import {dynamicRequire} from '../../util/dynamicRequire'
 import {getProjectDefaults, type ProjectDefaults} from '../../util/getProjectDefaults'
+import {getProviderName} from '../../util/getProviderName'
 import {getUserConfig} from '../../util/getUserConfig'
 import {isCommandGroup} from '../../util/isCommandGroup'
 import {isInteractive} from '../../util/isInteractive'
 import {fetchJourneyConfig} from '../../util/journeyConfig'
+import {checkIsRemoteTemplate, getGitHubRepoInfo, type RepoInfo} from '../../util/remoteTemplate'
 import {login, type LoginFlags} from '../login/login'
 import {createProject} from '../project/createProject'
-import {type BootstrapOptions, bootstrapTemplate} from './bootstrapTemplate'
+import {bootstrapLocalTemplate} from './bootstrapLocalTemplate'
+import {bootstrapRemoteTemplate} from './bootstrapRemoteTemplate'
 import {type GenerateConfigOptions} from './createStudioConfig'
 import {absolutify, validateEmptyPath} from './fsUtils'
 import {tryGitInit} from './git'
@@ -58,7 +62,6 @@ import {
   promptForStudioPath,
 } from './prompts/nextjs'
 import {readPackageJson} from './readPackageJson'
-import {reconfigureV2Project} from './reconfigureV2Project'
 import templates from './templates'
 import {
   sanityCliTemplate,
@@ -68,19 +71,13 @@ import {
 } from './templates/nextjs'
 
 // eslint-disable-next-line no-process-env
-const isCI = process.env.CI
+const isCI = Boolean(process.env.CI)
 
 /**
  * @deprecated - No longer used
  */
 export interface InitOptions {
   template: string
-  // /**
-  //  * Used for initializing a project from a server schema that is saved in the Journey API
-  //  * This will override the `template` option.
-  //  * @beta
-  //  */
-  // journeyProjectId?: string
   outputDir: string
   name: string
   displayName: string
@@ -117,16 +114,7 @@ export default async function initSanity(
     detectedFramework: Awaited<ReturnType<typeof detectFrameworkRecord>>
   },
 ): Promise<void> {
-  const {
-    output,
-    prompt,
-    workDir,
-    apiClient,
-    chalk,
-    sanityMajorVersion,
-    telemetry,
-    detectedFramework,
-  } = context
+  const {output, prompt, workDir, apiClient, chalk, telemetry, detectedFramework} = context
 
   const trace = telemetry.trace(CLIInitStepCompleted)
 
@@ -144,6 +132,11 @@ export default async function initSanity(
   const env = cliFlags.env
   const packageManager = cliFlags['package-manager']
 
+  let remoteTemplateInfo: RepoInfo | undefined
+  if (cliFlags.template && checkIsRemoteTemplate(cliFlags.template)) {
+    remoteTemplateInfo = await getGitHubRepoInfo(cliFlags.template, cliFlags['template-token'])
+  }
+
   let defaultConfig = cliFlags['dataset-default']
   let showDefaultConfigPrompt = !defaultConfig
 
@@ -162,9 +155,10 @@ export default async function initSanity(
     },
   })
 
-  if (sanityMajorVersion === 2) {
-    await reconfigureV2Project(args, context)
-    return
+  if (detectedFramework && detectedFramework.slug !== 'sanity' && remoteTemplateInfo) {
+    throw new Error(
+      `A remote template cannot be used with a detected framework. Detected: ${detectedFramework.name}`,
+    )
   }
 
   // Only allow either --project-plan or --coupon
@@ -253,25 +247,9 @@ export default async function initSanity(
   }
   const envFilename = typeof env === 'string' ? env : envFilenameDefault
   if (!envFilename.startsWith('.env')) {
-    throw new Error(`Env filename must start with .env`)
+    throw new Error('Env filename must start with .env')
   }
 
-  const usingBareOrEnv = cliFlags.bare || cliFlags.env
-  print(
-    cliFlags.quickstart
-      ? "You're ejecting a remote Sanity project!"
-      : `You're setting up a new project!`,
-  )
-  print(`We'll make sure you have an account with Sanity.io. ${usingBareOrEnv ? '' : `Then we'll`}`)
-  if (!usingBareOrEnv) {
-    print('install an open-source JS content editor that connects to')
-    print('the real-time hosted API on Sanity.io. Hang on.\n')
-  }
-  print('Press ctrl + C at any time to quit.\n')
-  print('Prefer web interfaces to terminals?')
-  print('You can also set up best practice Sanity projects with')
-  print('your favorite frontends on https://www.sanity.io/templates\n')
-
   // If the user isn't already authenticated, make it so
   const userConfig = getUserConfig()
   const hasToken = userConfig.get('authToken')
@@ -279,12 +257,28 @@ export default async function initSanity(
   debug(hasToken ? 'User already has a token' : 'User has no token')
   if (hasToken) {
     trace.log({step: 'login', alreadyLoggedIn: true})
-    print('Looks like you already have a Sanity-account. Sweet!\n')
+    const user = await getUserData(apiClient)
+    print('')
+    print(
+      `${chalk.gray("  👤 You're logged in as %s using %s")}`,
+      user.name,
+      getProviderName(user.provider),
+    )
+    print('')
   } else if (!unattended) {
     trace.log({step: 'login'})
     await getOrCreateUser()
   }
 
+  let introMessage = "Let's get you started with a new project"
+  if (cliFlags.quickstart) {
+    introMessage = "Let's get you started with remote Sanity project"
+  } else if (remoteTemplateInfo) {
+    introMessage = "Let's get you started with a remote Sanity template"
+  }
+  print(`  ➡️ ${chalk.gray(introMessage)}`)
+  print('')
+
   const flags = await prepareFlags()
   // We're authenticated, now lets select or create a project
   const {projectId, displayName, isFirstProject, datasetName, schemaUrl} = await getProjectDetails()
@@ -581,18 +575,20 @@ export default async function initSanity(
   const templateName = await selectProjectTemplate()
   trace.log({step: 'selectProjectTemplate', selectedOption: templateName})
   const template = templates[templateName]
-  if (!template) {
+  if (!remoteTemplateInfo && !template) {
     throw new Error(`Template "${templateName}" not found`)
   }
 
   // Use typescript?
-  const typescriptOnly = template.typescriptOnly === true
   let useTypeScript = true
-  if (!typescriptOnly && typeof cliFlags.typescript === 'boolean') {
-    useTypeScript = cliFlags.typescript
-  } else if (!typescriptOnly && !unattended) {
-    useTypeScript = await promptForTypeScript(prompt)
-    trace.log({step: 'useTypeScript', selectedOption: useTypeScript ? 'yes' : 'no'})
+  if (!remoteTemplateInfo && template) {
+    const typescriptOnly = template.typescriptOnly === true
+    if (!typescriptOnly && typeof cliFlags.typescript === 'boolean') {
+      useTypeScript = cliFlags.typescript
+    } else if (!typescriptOnly && !unattended) {
+      useTypeScript = await promptForTypeScript(prompt)
+      trace.log({step: 'useTypeScript', selectedOption: useTypeScript ? 'yes' : 'no'})
+    }
   }
 
   // we enable auto-updates by default, but allow users to specify otherwise
@@ -601,47 +597,15 @@ export default async function initSanity(
     autoUpdates = cliFlags['auto-updates']
   }
 
-  // Build a full set of resolved options
-  const templateOptions: BootstrapOptions = {
-    outputPath,
-    packageName: sluggedName,
-    templateName,
-    schemaUrl,
-    useTypeScript,
-    variables: {
-      autoUpdates,
-      dataset: datasetName,
-      projectId,
-      projectName: displayName || answers.projectName,
-    },
-  }
-
   // If the template has a sample dataset, prompt the user whether or not we should import it
   const shouldImport =
-    !unattended && template.datasetUrl && (await promptForDatasetImport(template.importPrompt))
+    !unattended && template?.datasetUrl && (await promptForDatasetImport(template.importPrompt))
 
   trace.log({step: 'importTemplateDataset', selectedOption: shouldImport ? 'yes' : 'no'})
 
   const [_, bootstrapPromise] = await Promise.allSettled([
-    // record template files attempted to be created locally
-    apiClient({api: {projectId: projectId}})
-      .request<SanityProject>({uri: `/projects/${projectId}`})
-      .then((project: SanityProject) => {
-        if (!project?.metadata?.cliInitializedAt) {
-          return apiClient({api: {projectId}}).request({
-            method: 'PATCH',
-            uri: `/projects/${projectId}`,
-            body: {metadata: {cliInitializedAt: new Date().toISOString()}},
-          })
-        }
-        return Promise.resolve()
-      })
-      .catch(() => {
-        // Non-critical update
-        debug('Failed to update cliInitializedAt metadata')
-      }),
-    // Bootstrap Sanity, creating required project files, manifests etc
-    bootstrapTemplate(templateOptions, context),
+    updateProjectCliInitializedMetadata(),
+    bootstrapTemplate(),
   ])
 
   if (bootstrapPromise.status === 'rejected' && bootstrapPromise.reason instanceof Error) {
@@ -823,21 +787,19 @@ export default async function initSanity(
     isFirstProject: boolean
     userAction: 'create' | 'select'
   }> {
-    const spinner = context.output.spinner('Fetching existing projects').start()
+    const client = apiClient({requireUser: true, requireProject: false})
     let projects
     let organizations: ProjectOrganization[]
+
     try {
-      const client = apiClient({requireUser: true, requireProject: false})
       const [allProjects, allOrgs] = await Promise.all([
         client.projects.list({includeMembers: false}),
         client.request({uri: '/organizations'}),
       ])
       projects = allProjects.sort((a, b) => b.createdAt.localeCompare(a.createdAt))
       organizations = allOrgs
-      spinner.succeed()
     } catch (err) {
       if (unattended && flags.project) {
-        spinner.succeed()
         return {
           projectId: flags.project,
           displayName: 'Unknown project',
@@ -845,7 +807,6 @@ export default async function initSanity(
           userAction: 'select',
         }
       }
-      spinner.fail()
       throw new Error(`Failed to communicate with the Sanity API:\n${err.message}`)
     }
 
@@ -1117,6 +1078,58 @@ export default async function initSanity(
     })
   }
 
+  async function updateProjectCliInitializedMetadata() {
+    try {
+      const client = apiClient({api: {projectId}})
+      const project = await client.request<SanityProject>({uri: `/projects/${projectId}`})
+
+      if (!project?.metadata?.cliInitializedAt) {
+        await client.request({
+          method: 'PATCH',
+          uri: `/projects/${projectId}`,
+          body: {metadata: {cliInitializedAt: new Date().toISOString()}},
+        })
+      }
+    } catch (err) {
+      // Non-critical update
+      debug('Failed to update cliInitializedAt metadata')
+    }
+  }
+
+  async function bootstrapTemplate() {
+    const bootstrapVariables: GenerateConfigOptions['variables'] = {
+      autoUpdates,
+      dataset: datasetName,
+      projectId,
+      projectName: displayName || answers.projectName,
+    }
+
+    if (remoteTemplateInfo) {
+      return bootstrapRemoteTemplate(
+        {
+          outputPath,
+          packageName: sluggedName,
+          repoInfo: remoteTemplateInfo,
+          bearerToken: cliFlags['template-token'],
+          variables: bootstrapVariables,
+        },
+        context,
+      )
+    }
+
+    return bootstrapLocalTemplate(
+      {
+        outputPath,
+        packageName: sluggedName,
+        templateName,
+        schemaUrl,
+        useTypeScript,
+        variables: bootstrapVariables,
+      },
+      context,
+    )
+  }
+
   async function getProjectInfo(): Promise<ProjectDefaults & {outputPath: string}> {
     const specifiedPath = flags['output-path'] && path.resolve(flags['output-path'])
 
@@ -1479,6 +1492,16 @@ async function getPlanFromCoupon(apiClient: CliApiClient, couponCode: string): P
   return planId
 }
 
+async function getUserData(apiClient: CliApiClient): Promise<SanityUser> {
+  return await apiClient({
+    requireUser: true,
+    requireProject: false,
+  }).request({
+    method: 'GET',
+    uri: 'users/me',
+  })
+}
+
 async function getPlanFromId(apiClient: CliApiClient, planId: string): Promise<string> {
   const response = await apiClient({
     requireUser: false,

package/src/actions/init-project/updateInitialTemplateMetadata.ts

@@ -0,0 +1,24 @@
+import {debug} from '../../debug'
+import {type CliApiClient} from '../../types'
+
+export async function updateInitialTemplateMetadata(
+  apiClient: CliApiClient,
+  projectId: string,
+  templateName: string,
+): Promise<void> {
+  try {
+    await apiClient({api: {projectId}}).request({
+      method: 'PATCH',
+      uri: `/projects/${projectId}`,
+      body: {metadata: {initialTemplate: templateName}},
+    })
+  } catch (err: unknown) {
+    // Non-critical that we update this metadata, and user does not need to be aware
+    let message = typeof err === 'string' ? err : '<unknown error>'
+    if (err instanceof Error) {
+      message = err.message
+    }
+
+    debug('Failed to update initial template metadata for project: %s', message)
+  }
+}

package/src/commands/index.ts

@@ -17,7 +17,6 @@ import telemetryGroup from './telemetry/telemetryGroup'
 import telemetryStatusCommand from './telemetry/telemetryStatusCommand'
 import generateTypegenCommand from './typegen/generateTypesCommand'
 import typegenGroup from './typegen/typegenGroup'
-import upgradeCommand from './upgrade/upgradeCommand'
 import versionsCommand from './versions/versionsCommand'
 
 export const baseCommands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
@@ -25,7 +24,6 @@ export const baseCommands: (CliCommandDefinition | CliCommandGroupDefinition)[]
   loginCommand,
   logoutCommand,
   installCommand,
-  upgradeCommand,
   versionsCommand,
   docsCommand,
   manageCommand,

package/src/commands/init/initCommand.ts

@@ -1,7 +1,6 @@
 import {type Framework, frameworks} from '@vercel/frameworks'
 import {detectFrameworkRecord, LocalFileSystemDetector} from '@vercel/fs-detectors'
 
-import initPlugin from '../../actions/init-plugin/initPlugin'
 import initProject from '../../actions/init-project/initProject'
 import {
   allowedPackageManagersString,
@@ -58,6 +57,11 @@ export interface InitFlags {
   'project'?: string
   'dataset'?: string
   'template'?: string
+  /**
+   * Used for accessing private GitHub repo templates
+   * @beta
+   */
+  'template-token'?: string
 
   'visibility'?: string
   'typescript'?: boolean
@@ -97,87 +101,23 @@ export const initCommand: CliCommandDefinition<InitFlags> = {
   description: 'Initializes a new Sanity Studio and/or project',
   helpText,
   action: async (args, context) => {
-    const {output, chalk, prompt} = context
+    const {output, chalk} = context
     const [type] = args.argsWithoutOptions
-    const unattended = args.extOptions.y || args.extOptions.yes
-
-    const warn = (msg: string) => output.warn(chalk.yellow.bgBlack(msg))
-
-    // `sanity init plugin`
-    if (type === 'plugin') {
-      return context.sanityMajorVersion === 2
-        ? // don't bother with telemetry here, as it's not supported in v3
-          initPlugin(args, context)
-        : Promise.reject(new Error(`'sanity init plugin' is not available in modern studios`))
-    }
 
     // `sanity init whatever`
     if (type) {
       return Promise.reject(new Error(`Unknown init type "${type}"`))
     }
 
-    // `npm create sanity` (regular v3 init)
-
     const detectedFramework: Framework | null = await detectFrameworkRecord({
       fs: new LocalFileSystemDetector(process.cwd()),
       frameworkList: frameworks as readonly Framework[],
     })
 
-    if (
-      args.argv.includes('--from-create') ||
-      args.argv.includes('--env') ||
-      args.argv.includes('--bare') ||
-      detectedFramework?.slug === 'nextjs'
-    ) {
-      return initProject(args, {
-        ...context,
-        detectedFramework,
-      })
-    }
-
-    // `sanity init` (v2 style)
-    warn('╭────────────────────────────────────────────────────────────╮')
-    warn('│                                                            │')
-    warn("│  Welcome to Sanity! It looks like you're following         │")
-    warn('│  instructions for Sanity Studio v2, but the version you    │')
-    warn('│  have installed is the latest - Sanity Studio v3.          │')
-    warn('│                                                            │')
-    warn('│  In Sanity Studio v3, new projects are created by running  │')
-    warn('│  [npm create sanity@latest]. For more information, see     │')
-    warn('│   https://www.sanity.io/help/studio-v2-vs-v3               │')
-    warn('│                                                            │')
-    warn('╰────────────────────────────────────────────────────────────╯')
-    warn('') // Newline to separate from other output
-    const continueV3Init = unattended
-      ? true
-      : await prompt.single({
-          message: 'Continue creating a Sanity Studio v3 project?',
-          type: 'confirm',
-        })
-
-    // Fall back
-    if (!continueV3Init) {
-      // Indicate that the operation did not succeed as expected
-      // eslint-disable-next-line no-process-exit
-      process.exit(1)
-    }
-
-    const returnVal = await initProject(args, {
+    return initProject(args, {
       ...context,
       detectedFramework,
-    }).catch((err) => {
-      return Promise.reject(err)
     })
-
-    warn('╭────────────────────────────────────────────────────────────╮')
-    warn('│                                                            │')
-    warn('│  To learn how commands have changed from Studio v2 to v3,  │')
-    warn('│  see https://www.sanity.io/help/studio-v2-vs-v3            │')
-    warn('│                                                            │')
-    warn('╰────────────────────────────────────────────────────────────╯')
-    warn('') // Newline to separate from other output
-
-    return returnVal
   },
 }
 

package/src/types.ts

@@ -82,7 +82,6 @@ export interface CliBaseCommandContext {
   output: CliOutputter
   prompt: CliPrompter
   apiClient: CliApiClient
-  yarn: CliStubbedYarn
   sanityMajorVersion: 2 | 3
   cliConfigPath?: string
   cliRoot: string
@@ -349,3 +348,12 @@ export interface CliConfig {
 export type UserViteConfig =
   | InlineConfig
   | ((config: InlineConfig, env: ConfigEnv) => InlineConfig | Promise<InlineConfig>)
+
+export type SanityUser = {
+  id: string
+  name: string
+  email: string
+  profileImage?: string
+  tosAcceptedAt?: string
+  provider: 'google' | 'github' | 'sanity' | `saml-${string}`
+}

package/src/util/getCliConfig.ts

@@ -42,7 +42,7 @@ export async function getCliConfig(
 
   const {unregister} = __DEV__
     ? {unregister: () => undefined}
-    : require('esbuild-register/dist/node').register({supported: {'dynamic-import': true}})
+    : require('esbuild-register/dist/node').register()
 
   try {
     const v3Config = getSanityCliConfig(cwd)

package/src/util/getProviderName.ts

@@ -0,0 +1,9 @@
+import {type SanityUser} from '../types'
+
+export function getProviderName(provider: SanityUser['provider']) {
+  if (provider === 'google') return 'Google'
+  if (provider === 'github') return 'GitHub'
+  if (provider === 'sanity') return 'Email'
+  if (provider.startsWith('saml-')) return 'SAML'
+  return provider
+}