@sanity/cli 3.93.1-next.9.198ab74452 → 3.94.0

package/src/util/noSuchCommandText.ts

@@ -1,91 +0,0 @@
-import chalk from 'chalk'
-import leven from 'leven'
-
-import {type CliCommandDefinition, type CliCommandGroupDefinition} from '../types'
-
-const commonMistakes: Record<string, string | undefined> = {get: 'list'}
-const levenThreshold = 3
-const coreCommands = [
-  'build',
-  'check',
-  'configcheck',
-  'cors',
-  'dataset',
-  'deploy',
-  'dev',
-  'documents',
-  'exec',
-  'graphql',
-  'hook',
-  'migration',
-  'manifest',
-  'preview',
-  'schema',
-  'start',
-  'undeploy',
-  'uninstall',
-  'users',
-]
-
-// These are disabled in v3, but still present because of v2.
-// We don't want to suggest them anymore, though.
-const discouragedCommands = ['upgrade', 'check', 'configcheck', 'uninstall']
-
-const helpText = `
-Run the command again within a Sanity project directory, where "sanity"
-is installed as a dependency.`
-
-export function getNoSuchCommandText(
-  cmdName: string,
-  parentGroupName?: string | null,
-  groups?: Record<string, (CliCommandDefinition | CliCommandGroupDefinition)[]>,
-): string {
-  if (parentGroupName && groups && groups[parentGroupName]) {
-    return suggestCommand(cmdName, groups[parentGroupName], parentGroupName)
-  }
-
-  const isCoreCommand = coreCommands.includes(cmdName)
-  if (isCoreCommand) {
-    return `Command "${cmdName}" is not available outside of a Sanity project context.${helpText}`
-  }
-
-  return suggestCommand(cmdName, groups ? groups.default : [])
-}
-
-function suggestCommand(
-  cmdName: string,
-  group: (CliCommandDefinition | CliCommandGroupDefinition)[],
-  parentGroupName: string | null = null,
-) {
-  // Try to find something similar
-  const closest = group
-    .filter((command) => !discouragedCommands.includes(command.name))
-    .map((command) => leven(command.name, cmdName))
-    .reduce(
-      (current: {index: number; distance: number}, distance: number, index: number) =>
-        distance < current.distance ? {index, distance} : current,
-      {index: 0, distance: +Infinity},
-    )
-
-  // Given we are within our target threshold, suggest the command
-  let suggestCmd = ''
-  if (closest.distance <= levenThreshold) {
-    const cmdCandidate = group[closest.index]
-    suggestCmd = cmdCandidate.name
-  }
-
-  // Is this a common mistake that we can suggest an alias for?
-  const alternative = commonMistakes[cmdName]
-  if (!suggestCmd && alternative) {
-    suggestCmd = alternative
-  }
-
-  const input = chalk.cyan(`"${cmdName}"`)
-  const suggest = chalk.green(`"${suggestCmd}"`)
-  const help = chalk.cyan('"sanity --help"')
-
-  const didYouMean = suggestCmd ? `Did you mean ${suggest}? ` : ' '
-  return parentGroupName
-    ? `${input} is not a subcommand of "sanity ${parentGroupName}". ${didYouMean}See ${help}`
-    : `${input} is not a sanity command. ${didYouMean}See ${help}`
-}

package/src/util/parseArguments.ts

@@ -1,76 +0,0 @@
-import minimist from 'minimist'
-
-export interface ParsedArguments<F = Record<string, string>> {
-  /**
-   * Group or command name, eg `dataset` (`sanity dataset`) or `import` (`sanity dataset import`)
-   */
-  groupOrCommand: string
-
-  // Raw, forwarded arguments, for commands that want to be more explicit about parsing
-  argv: string[]
-
-  /**
-   * Command flags, without the core options (help, debug, version etc)
-   */
-  extOptions: F
-
-  /**
-   * Command arguments, eg any arguments after `sanity <command>` (no flags)
-   */
-  argsWithoutOptions: string[]
-
-  /**
-   * Arguments after the ended argument list (--)
-   */
-  extraArguments: string[]
-
-  /**
-   * Options mostly relevant for the core CLI runner
-   */
-  coreOptions: {
-    h: boolean
-    help: boolean
-
-    d: boolean
-    debug: boolean
-
-    v: boolean
-    version: boolean
-  }
-}
-
-export function parseArguments(argv = process.argv): ParsedArguments {
-  /* eslint-disable id-length */
-  // prettier-ignore
-  const {
-    _,
-    h, help,
-    d, debug,
-    v, version,
-    '--': extraArguments,
-    ...extOptions
-  } = minimist(argv.slice(2), {
-    '--': true,
-    boolean: ['h', 'help', 'd', 'debug', 'v', 'version'],
-    string: ['_']
-  })
-
-  const [groupOrCommand, ...argsWithoutOptions] = _
-
-  return {
-    groupOrCommand,
-
-    argv,
-    extOptions,
-    argsWithoutOptions,
-    extraArguments: extraArguments || [],
-
-    // prettier-ignore
-    coreOptions: {
-      h, help,
-      d, debug,
-      v, version,
-    },
-  }
-  /* eslint-enable id-length */
-}

package/src/util/pathExists.ts

@@ -1,14 +0,0 @@
-import fs from 'node:fs/promises'
-
-export async function pathExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return false
-    }
-
-    throw err
-  }
-}

package/src/util/readJson.ts

@@ -1,6 +0,0 @@
-import {readFile} from 'node:fs/promises'
-
-export async function readJson<T>(filePath: string): Promise<T> {
-  const content = await readFile(filePath, 'utf8')
-  return JSON.parse(content)
-}

package/src/util/readdirRecursive.ts

@@ -1,26 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-export interface ReaddirItem {
-  path: string
-  isDir: boolean
-}
-
-export async function readdirRecursive(dir: string): Promise<ReaddirItem[]> {
-  let content: ReaddirItem[] = []
-
-  const currentPath = path.resolve(dir)
-  const dirContent = (await fs.readdir(currentPath)).map((item) => path.join(currentPath, item))
-
-  for (const subPath of dirContent) {
-    const stat = await fs.stat(subPath)
-    const isDir = stat.isDirectory()
-    content.push({path: subPath, isDir})
-
-    if (isDir) {
-      content = content.concat(await readdirRecursive(subPath))
-    }
-  }
-
-  return content
-}

package/src/util/remoteTemplate.ts

@@ -1,320 +0,0 @@
-import {access, readFile, writeFile} from 'node:fs/promises'
-import {join, posix, sep} from 'node:path'
-import {Readable} from 'node:stream'
-import {pipeline} from 'node:stream/promises'
-import {type ReadableStream} from 'node:stream/web'
-
-import {ENV_TEMPLATE_FILES, REQUIRED_ENV_VAR} from '@sanity/template-validator'
-import {x} from 'tar'
-
-import {debug} from '../debug'
-import {type CliApiClient, type PackageJson} from '../types'
-
-const DISALLOWED_PATHS = [
-  // Prevent security risks from unknown GitHub Actions
-  '/.github/',
-]
-
-const ENV_VAR = {
-  ...REQUIRED_ENV_VAR,
-  READ_TOKEN: 'SANITY_API_READ_TOKEN',
-  WRITE_TOKEN: 'SANITY_API_WRITE_TOKEN',
-} as const
-
-const API_READ_TOKEN_ROLE = 'viewer'
-const API_WRITE_TOKEN_ROLE = 'editor'
-
-type EnvData = {
-  projectId: string
-  dataset: string
-  readToken?: string
-  writeToken?: string
-}
-
-type GithubUrlString =
-  | `https://github.com/${string}/${string}`
-  | `https://www.github.com/${string}/${string}`
-
-export type RepoInfo = {
-  username: string
-  name: string
-  branch: string
-  filePath: string
-}
-
-export function getGitHubRawContentUrl(repoInfo: RepoInfo): string {
-  const {username, name, branch, filePath} = repoInfo
-  return `https://raw.githubusercontent.com/${username}/${name}/${branch}/${filePath}`
-}
-
-function isGithubRepoShorthand(value: string): boolean {
-  if (URL.canParse(value)) {
-    return false
-  }
-  // This supports :owner/:repo and :owner/:repo/nested/path, e.g.
-  // sanity-io/sanity
-  // sanity-io/sanity/templates/next-js
-  // sanity-io/templates/live-content-api
-  // sanity-io/sanity/packages/@sanity/cli/test/test-template
-  return /^[\w-]+\/[\w-.]+(\/[@\w-.]+)*$/.test(value)
-}
-
-function isGithubRepoUrl(value: string | URL): value is URL | GithubUrlString {
-  if (URL.canParse(value) === false) {
-    return false
-  }
-  const url = new URL(value)
-  const pathSegments = url.pathname.slice(1).split('/')
-
-  return (
-    url.protocol === 'https:' &&
-    url.hostname === 'github.com' &&
-    // The pathname must have at least 2 segments. If it has more than 2, the
-    // third must be "tree" and it must have at least 4 segments.
-    // https://github.com/:owner/:repo
-    // https://github.com/:owner/:repo/tree/:ref
-    pathSegments.length >= 2 &&
-    (pathSegments.length > 2 ? pathSegments[2] === 'tree' && pathSegments.length >= 4 : true)
-  )
-}
-
-async function downloadTarStream(url: string, bearerToken?: string): Promise<Readable> {
-  const headers: Record<string, string> = {}
-  if (bearerToken) {
-    headers.Authorization = `Bearer ${bearerToken}`
-  }
-
-  const res = await fetch(url, {headers})
-
-  if (!res.body) {
-    throw new Error(`Failed to download: ${url}`)
-  }
-
-  return Readable.fromWeb(res.body as ReadableStream)
-}
-
-export function checkIsRemoteTemplate(templateName?: string): boolean {
-  return templateName?.includes('/') ?? false
-}
-
-export async function getGitHubRepoInfo(value: string, bearerToken?: string): Promise<RepoInfo> {
-  let username = ''
-  let name = ''
-  let branch = ''
-  let filePath = ''
-
-  if (isGithubRepoShorthand(value)) {
-    const parts = value.split('/')
-    username = parts[0]
-    name = parts[1]
-    // If there are more segments after owner/repo, they form the file path
-    if (parts.length > 2) {
-      filePath = parts.slice(2).join('/')
-    }
-  }
-
-  if (isGithubRepoUrl(value)) {
-    const url = new URL(value)
-    const pathSegments = url.pathname.slice(1).split('/')
-    username = pathSegments[0]
-    name = pathSegments[1]
-
-    // If we have a "tree" segment, everything after branch is the file path
-    if (pathSegments[2] === 'tree') {
-      branch = pathSegments[3]
-      if (pathSegments.length > 4) {
-        filePath = pathSegments.slice(4).join('/')
-      }
-    }
-  }
-
-  if (!username || !name) {
-    throw new Error('Invalid GitHub repository format')
-  }
-
-  const tokenMessage =
-    'GitHub repository not found. For private repositories, use --template-token to provide an access token.\n\n' +
-    'You can generate a new token at https://github.com/settings/personal-access-tokens/new\n' +
-    'Set the token to "read-only" with repository access and a short expiry (e.g. 7 days) for security.'
-
-  try {
-    const headers: Record<string, string> = {}
-    if (bearerToken) {
-      headers.Authorization = `Bearer ${bearerToken}`
-    }
-
-    const infoResponse = await fetch(`https://api.github.com/repos/${username}/${name}`, {
-      headers,
-    })
-
-    if (infoResponse.status !== 200) {
-      if (infoResponse.status === 404) {
-        throw new Error(tokenMessage)
-      }
-      throw new Error('GitHub repository not found')
-    }
-
-    const info = await infoResponse.json()
-
-    return {
-      username,
-      name,
-      branch: branch || info.default_branch,
-      filePath,
-    }
-  } catch {
-    throw new Error(tokenMessage)
-  }
-}
-
-export async function downloadAndExtractRepo(
-  root: string,
-  {username, name, branch, filePath}: RepoInfo,
-  bearerToken?: string,
-): Promise<void> {
-  let rootPath: string | null = null
-  await pipeline(
-    await downloadTarStream(
-      `https://codeload.github.com/${username}/${name}/tar.gz/${branch}`,
-      bearerToken,
-    ),
-    x({
-      cwd: root,
-      strip: filePath ? filePath.split('/').length + 1 : 1,
-      filter: (p: string) => {
-        const posixPath = p.split(sep).join(posix.sep)
-        if (rootPath === null) {
-          const pathSegments = posixPath.split(posix.sep)
-          rootPath = pathSegments.length ? pathSegments[0] : null
-        }
-        for (const disallowedPath of DISALLOWED_PATHS) {
-          if (posixPath.includes(disallowedPath)) return false
-        }
-        return posixPath.startsWith(`${rootPath}${filePath ? `/${filePath}/` : '/'}`)
-      },
-    }),
-  )
-}
-
-export async function checkIfNeedsApiToken(root: string, type: 'read' | 'write'): Promise<boolean> {
-  try {
-    const templatePath = await Promise.any(
-      ENV_TEMPLATE_FILES.map(async (file) => {
-        await access(join(root, file))
-        return file
-      }),
-    )
-    const templateContent = await readFile(join(root, templatePath), 'utf8')
-    return templateContent.includes(type === 'read' ? ENV_VAR.READ_TOKEN : ENV_VAR.WRITE_TOKEN)
-  } catch {
-    return false
-  }
-}
-
-export async function applyEnvVariables(
-  root: string,
-  envData: EnvData,
-  targetName = '.env',
-): Promise<void> {
-  const templatePath = await Promise.any(
-    ENV_TEMPLATE_FILES.map(async (file) => {
-      await access(join(root, file))
-      return file
-    }),
-  ).catch(() => undefined)
-
-  if (!templatePath) {
-    return // No template .env file found, skip
-  }
-
-  try {
-    const templateContent = await readFile(join(root, templatePath), 'utf8')
-    const {projectId, dataset, readToken = '', writeToken = ''} = envData
-
-    const findAndReplaceVariable = (
-      content: string,
-      varRegex: RegExp | string,
-      value: string,
-      useQuotes: boolean,
-    ) => {
-      const varPattern = typeof varRegex === 'string' ? varRegex : varRegex.source
-      const pattern = new RegExp(`.*${varPattern}=.*$`, 'gm')
-      const matches = content.matchAll(pattern)
-      return Array.from(matches).reduce((updatedContent, match) => {
-        if (!match[0]) return updatedContent
-        const varName = match[0].split('=')[0].trim()
-        return updatedContent.replace(
-          new RegExp(`${varName}=.*$`, 'gm'),
-          `${varName}=${useQuotes ? `"${value}"` : value}`,
-        )
-      }, content)
-    }
-
-    let envContent = templateContent
-    const vars = [
-      {pattern: ENV_VAR.PROJECT_ID, value: projectId},
-      {pattern: ENV_VAR.DATASET, value: dataset},
-      {pattern: ENV_VAR.READ_TOKEN, value: readToken},
-      {pattern: ENV_VAR.WRITE_TOKEN, value: writeToken},
-    ]
-    const useQuotes = templateContent.includes('="')
-
-    for (const {pattern, value} of vars) {
-      envContent = findAndReplaceVariable(envContent, pattern, value, useQuotes)
-    }
-
-    await writeFile(join(root, targetName), envContent)
-  } catch {
-    throw new Error(
-      'Failed to set environment variables. This could be due to file permissions or the .env file format. See https://www.sanity.io/docs/environment-variables for details on environment variable setup.',
-    )
-  }
-}
-
-export async function tryApplyPackageName(root: string, name: string): Promise<void> {
-  try {
-    const packageJson = await readFile(join(root, 'package.json'), 'utf8')
-    const pkg: PackageJson = JSON.parse(packageJson)
-    pkg.name = name
-
-    await writeFile(join(root, 'package.json'), JSON.stringify(pkg, null, 2))
-  } catch {
-    // noop
-  }
-}
-
-export async function generateSanityApiToken(
-  label: string,
-  type: 'read' | 'write',
-  projectId: string,
-  apiClient: CliApiClient,
-): Promise<string> {
-  const response = await apiClient({requireProject: false, requireUser: true})
-    .config({apiVersion: 'v2021-06-07'})
-    .request<{key: string}>({
-      uri: `/projects/${projectId}/tokens`,
-      method: 'POST',
-      body: {
-        label: `${label} (${Date.now()})`,
-        roleName: type === 'read' ? API_READ_TOKEN_ROLE : API_WRITE_TOKEN_ROLE,
-      },
-    })
-  return response.key
-}
-
-export async function setCorsOrigin(
-  origin: string,
-  projectId: string,
-  apiClient: CliApiClient,
-): Promise<void> {
-  try {
-    await apiClient({api: {projectId}}).request({
-      method: 'POST',
-      url: '/cors',
-      body: {origin: origin, allowCredentials: true}, // allowCredentials is true to allow for embedded studios if needed
-    })
-  } catch (error) {
-    // Silent fail, it most likely means that the origin is already set
-    debug('Failed to set CORS origin', error)
-  }
-}

package/src/util/resolveLatestVersions.ts

@@ -1,24 +0,0 @@
-import latestVersion from 'get-latest-version'
-import promiseProps from 'promise-props-recursive'
-
-/**
- * Resolve the latest versions of given packages within their defined ranges
- *
- * @param pkgs - `{packageName: rangeOrTag}`
- * @returns Object of resolved version numbers
- */
-export function resolveLatestVersions(
-  pkgs: Record<string, string>,
-): Promise<Record<string, string>> {
-  const lookups: Record<string, Promise<string> | string> = {}
-  for (const [packageName, range] of Object.entries(pkgs)) {
-    lookups[packageName] =
-      range === 'latest' ? latestVersion(packageName, {range}).then(caretify) : range
-  }
-
-  return promiseProps(lookups)
-}
-
-function caretify(version: string | undefined) {
-  return version ? `^${version}` : 'latest'
-}

package/src/util/resolveRootDir.ts

@@ -1,59 +0,0 @@
-/* eslint-disable no-sync */
-import fs from 'node:fs'
-import path from 'node:path'
-
-import {debug} from '../debug'
-
-/**
- * Resolve project root directory, falling back to cwd if it cannot be found
- */
-export function resolveRootDir(cwd: string): string {
-  try {
-    return resolveProjectRoot(cwd) || cwd
-  } catch (err) {
-    throw new Error(`Error occurred trying to resolve project root:\n${err.message}`)
-  }
-}
-
-function hasSanityConfig(basePath: string, configName: string): boolean {
-  const buildConfigs = [
-    fileExists(path.join(basePath, `${configName}.js`)),
-    fileExists(path.join(basePath, `${configName}.ts`)),
-    isSanityV2StudioRoot(basePath),
-  ]
-
-  return buildConfigs.some(Boolean)
-}
-
-function resolveProjectRoot(basePath: string, iterations = 0): string | false {
-  const configName = 'sanity.config'
-  if (hasSanityConfig(basePath, configName)) {
-    return basePath
-  }
-
-  const parentDir = path.resolve(basePath, '..')
-  if (parentDir === basePath || iterations > 30) {
-    // Reached root (or max depth), give up
-    return false
-  }
-
-  return resolveProjectRoot(parentDir, iterations + 1)
-}
-
-function isSanityV2StudioRoot(basePath: string): boolean {
-  try {
-    const content = fs.readFileSync(path.join(basePath, 'sanity.json'), 'utf8')
-    const sanityJson = JSON.parse(content)
-    const isRoot = Boolean(sanityJson?.root)
-    if (isRoot) {
-      debug('Found Sanity v2 studio root at %s', basePath)
-    }
-    return isRoot
-  } catch (err) {
-    return false
-  }
-}
-
-function fileExists(filePath: string): boolean {
-  return fs.existsSync(filePath)
-}

package/src/util/telemetryDisclosure.ts

@@ -1,45 +0,0 @@
-import boxen from 'boxen'
-import chalk from 'chalk'
-
-import {telemetryLearnMoreMessage} from '../commands/telemetry/telemetryStatusCommand'
-import {debug} from '../debug'
-import {getUserConfig} from './getUserConfig'
-import {isCi} from './isCi'
-
-const TELEMETRY_DISCLOSED_CONFIG_KEY = 'telemetryDisclosed'
-
-export function telemetryDisclosure(): void {
-  const userConfig = getUserConfig()
-
-  if (isCi) {
-    debug('CI environment detected, skipping telemetry disclosure')
-    return
-  }
-
-  if (userConfig.get(TELEMETRY_DISCLOSED_CONFIG_KEY)) {
-    debug('Telemetry disclosure has already been shown')
-    return
-  }
-
-  // Print to stderr to prevent garbling command output
-  console.error(
-    boxen(
-      `The Sanity CLI now collects telemetry data on general usage and errors.
-This helps us improve Sanity and prioritize features.
-
-To opt in/out, run ${chalk.cyan('npx sanity telemetry enable/disable')}.
-
-${telemetryLearnMoreMessage('unset')}`,
-      {
-        padding: 1,
-        margin: 1,
-        borderColor: 'yellow',
-
-        // Typescript issues forcing these to any
-        borderStyle: 'round' as any,
-      },
-    ),
-  )
-
-  userConfig.set(TELEMETRY_DISCLOSED_CONFIG_KEY, Date.now())
-}