@sanity/cli 3.65.1-export-comments.7 → 3.65.2-cops.39

package/lib/index.d.mts

@@ -445,6 +445,15 @@ export declare interface SanityModuleInternal {
   }
 }
 
+export declare type SanityUser = {
+  id: string
+  name: string
+  email: string
+  profileImage?: string
+  tosAcceptedAt?: string
+  provider: 'google' | 'github' | 'sanity' | `saml-${string}`
+}
+
 export declare type SinglePrompt =
   | (Omit<DistinctQuestion, 'name'> & {
       type: 'list'

package/lib/index.d.ts

@@ -445,6 +445,15 @@ export declare interface SanityModuleInternal {
   }
 }
 
+export declare type SanityUser = {
+  id: string
+  name: string
+  email: string
+  profileImage?: string
+  tosAcceptedAt?: string
+  provider: 'google' | 'github' | 'sanity' | `saml-${string}`
+}
+
 export declare type SinglePrompt =
   | (Omit<DistinctQuestion, 'name'> & {
       type: 'list'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/cli",
-  "version": "3.65.1-export-comments.7+877e015f43",
+  "version": "3.65.2-cops.39+eadc82ba20",
   "description": "Sanity CLI tool for managing Sanity installations, managing plugins, schemas and datasets",
   "keywords": [
     "sanity",
@@ -57,31 +57,32 @@
   },
   "dependencies": {
     "@babel/traverse": "^7.23.5",
-    "@sanity/client": "^6.22.5",
-    "@sanity/codegen": "3.65.1-export-comments.7+877e015f43",
+    "@sanity/client": "^6.24.0",
+    "@sanity/codegen": "3.65.2-cops.39+eadc82ba20",
     "@sanity/telemetry": "^0.7.7",
-    "@sanity/util": "3.65.1-export-comments.7+877e015f43",
+    "@sanity/util": "3.65.2-cops.39+eadc82ba20",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "decompress": "^4.2.0",
     "esbuild": "0.21.5",
     "esbuild-register": "^3.5.0",
     "get-it": "^8.6.5",
-    "groq-js": "^1.14.0",
+    "groq-js": "^1.14.1",
     "pkg-dir": "^5.0.0",
     "prettier": "^3.3.0",
     "semver": "^7.3.5",
     "silver-fleece": "1.1.0",
-    "validate-npm-package-name": "^3.0.0"
+    "validate-npm-package-name": "^3.0.0",
+    "yaml": "^2.6.1"
   },
   "devDependencies": {
-    "@repo/package.config": "3.65.0",
-    "@repo/test-config": "3.65.0",
+    "@repo/package.config": "3.65.1",
+    "@repo/test-config": "3.65.1",
     "@rexxars/gitconfiglocal": "^3.0.1",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@sanity/eslint-config-studio": "^4.0.0",
     "@sanity/generate-help-url": "^3.0.0",
-    "@sanity/types": "3.65.1-export-comments.7+877e015f43",
+    "@sanity/types": "3.65.2-cops.39+eadc82ba20",
     "@types/babel__traverse": "^7.20.5",
     "@types/configstore": "^5.0.1",
     "@types/cpx": "^1.5.2",
@@ -135,5 +136,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "877e015f43761dbd811ebb9fdeb1640ce9c83144"
+  "gitHead": "eadc82ba200ce70835c6575afc5ab908826695f0"
 }

package/src/actions/init-project/{bootstrapTemplate.ts → bootstrapLocalTemplate.ts}

@@ -14,8 +14,9 @@ import {createPackageManifest} from './createPackageManifest'
 import {createStudioConfig, type GenerateConfigOptions} from './createStudioConfig'
 import {type ProjectTemplate} from './initProject'
 import templates from './templates'
+import {updateInitialTemplateMetadata} from './updateInitialTemplateMetadata'
 
-export interface BootstrapOptions {
+export interface BootstrapLocalOptions {
   packageName: string
   templateName: string
   /**
@@ -28,8 +29,8 @@ export interface BootstrapOptions {
   variables: GenerateConfigOptions['variables']
 }
 
-export async function bootstrapTemplate(
-  opts: BootstrapOptions,
+export async function bootstrapLocalTemplate(
+  opts: BootstrapLocalOptions,
   context: CliCommandContext,
 ): Promise<ProjectTemplate> {
   const {apiClient, cliRoot, output} = context
@@ -142,22 +143,8 @@ export async function bootstrapTemplate(
     ),
   ])
 
-  // Store template name metadata on project
-  try {
-    await apiClient({api: {projectId}}).request({
-      method: 'PATCH',
-      uri: `/projects/${projectId}`,
-      body: {metadata: {initialTemplate: `cli-${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)
-  }
+  debug('Updating initial template metadata')
+  await updateInitialTemplateMetadata(apiClient, variables.projectId, `cli-${templateName}`)
 
   // Finish up by providing init process with template-specific info
   spinner.succeed()

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

@@ -0,0 +1,69 @@
+import {mkdir} from 'node:fs/promises'
+import {join} from 'node:path'
+
+import {debug} from '../../debug'
+import {type CliCommandContext} from '../../types'
+import {
+  applyEnvVariables,
+  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('Applying environment variables')
+  const readToken = await generateSanityApiReadToken(variables.projectId, apiClient)
+  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'
@@ -75,12 +79,6 @@ const isCI = process.env.CI
  */
 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
@@ -144,6 +142,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
 
@@ -167,6 +170,12 @@ export default async function initSanity(
     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
   if (intendedCoupon && intendedPlan) {
     throw new Error(
@@ -253,25 +262,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 +272,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 +590,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 +612,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 +802,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 +822,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 +1093,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 +1507,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/init/initCommand.ts

@@ -58,6 +58,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,11 +102,8 @@ 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') {
@@ -116,68 +118,15 @@ export const initCommand: CliCommandDefinition<InitFlags> = {
       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

@@ -349,3 +349,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/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
+}