@sanity/cli 3.93.0 → 3.93.1-bump-pkg-utils.34.5d0c0b3d22

package/src/cli.ts

@@ -1,350 +0,0 @@
-/* eslint-disable no-console, no-process-exit, no-sync */
-import {existsSync} from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-import chalk from 'chalk'
-import dotenv from 'dotenv'
-import resolveFrom from 'resolve-from'
-
-import {CliCommand} from './__telemetry__/cli.telemetry'
-import {getCliRunner} from './CommandRunner'
-import {baseCommands} from './commands'
-import {debug} from './debug'
-import {getInstallCommand} from './packageManager'
-import {type CommandRunnerOptions, type TelemetryUserProperties} from './types'
-import {createTelemetryStore} from './util/createTelemetryStore'
-import {detectRuntime} from './util/detectRuntime'
-import {type CliConfigResult, getCliConfig} from './util/getCliConfig'
-import {loadEnv} from './util/loadEnv'
-import {mergeCommands} from './util/mergeCommands'
-import {neatStack} from './util/neatStack'
-import {parseArguments} from './util/parseArguments'
-import {resolveRootDir} from './util/resolveRootDir'
-import {telemetryDisclosure} from './util/telemetryDisclosure'
-import {runUpdateCheck} from './util/updateNotifier'
-
-const sanityEnv = process.env.SANITY_INTERNAL_ENV || 'production' // eslint-disable-line no-process-env
-const knownEnvs = ['development', 'staging', 'production']
-
-function wait(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function installProcessExitHack(finalTask: () => Promise<unknown>) {
-  const originalProcessExit = process.exit
-
-  // @ts-expect-error ignore TS2534
-  process.exit = (exitCode?: number | undefined): never => {
-    finalTask().finally(() => originalProcessExit(exitCode))
-  }
-}
-
-export async function runCli(cliRoot: string, {cliVersion}: {cliVersion: string}): Promise<void> {
-  installUnhandledRejectionsHandler()
-
-  const pkg = {name: '@sanity/cli', version: cliVersion}
-
-  const args = parseArguments()
-  const isInit = args.groupOrCommand === 'init' && args.argsWithoutOptions[0] !== 'plugin'
-  const cwd = getCurrentWorkingDirectory()
-  let workDir: string | undefined
-  try {
-    workDir = isInit ? process.cwd() : resolveRootDir(cwd)
-  } catch (err) {
-    console.error(chalk.red(err.message))
-    process.exit(1)
-  }
-
-  // Check if there are updates available for the CLI, and notify if there is
-  await runUpdateCheck({pkg, cwd, workDir}).notify()
-
-  // If the telemetry disclosure message has not yet been shown, show it.
-  telemetryDisclosure()
-
-  // Try to figure out if we're in a v2 or v3 context by finding a config
-  debug(`Reading CLI config from "${workDir}"`)
-  let cliConfig = await getCliConfig(workDir, {forked: true})
-  if (!cliConfig) {
-    debug('No CLI config found')
-  }
-
-  // Figure out if the app is a studio or an app from the CLI config
-  const isApp = Boolean(cliConfig && 'app' in cliConfig)
-  // Load the environment variables from
-  loadAndSetEnvFromDotEnvFiles({workDir, cmd: args.groupOrCommand, isApp})
-  maybeFixMissingWindowsEnvVar()
-
-  // Reload the the cli config so env vars can work.
-  cliConfig = await getCliConfig(workDir, {forked: true})
-
-  const {logger: telemetry, flush: flushTelemetry} = createTelemetryStore<TelemetryUserProperties>({
-    projectId: cliConfig?.config?.api?.projectId,
-    env: process.env,
-  })
-
-  // UGLY HACK: process.exit(<code>) causes abrupt exit, we want to flush telemetry before exiting
-  installProcessExitHack(() =>
-    // When process.exit() is called, flush telemetry events first, but wait no more than x amount of ms before exiting process
-    Promise.race([wait(2000), flushTelemetry()]),
-  )
-
-  telemetry.updateUserProperties({
-    runtimeVersion: process.version,
-    runtime: detectRuntime(),
-    cliVersion: pkg.version,
-    machinePlatform: process.platform,
-    cpuArchitecture: process.arch,
-    projectId: cliConfig?.config?.api?.projectId,
-    dataset: cliConfig?.config?.api?.dataset,
-  })
-
-  const options: CommandRunnerOptions = {
-    cliRoot: cliRoot,
-    workDir: workDir,
-    corePath: await getCoreModulePath(workDir, cliConfig),
-    cliConfig,
-    telemetry,
-  }
-
-  warnOnNonProductionEnvironment()
-  warnOnInferredProjectDir(isInit, cwd, workDir)
-
-  const core = args.coreOptions
-  const commands = await mergeCommands(baseCommands, options.corePath, {cliVersion, cwd, workDir})
-
-  if (core.v || core.version) {
-    console.log(`${pkg.name} version ${pkg.version}`)
-    process.exit()
-  }
-
-  // Translate `sanity -h <command>` to `sanity help <command>`
-  if (core.h || core.help) {
-    if (args.groupOrCommand) {
-      args.argsWithoutOptions.unshift(args.groupOrCommand)
-    }
-
-    args.groupOrCommand = 'help'
-  }
-
-  if (args.groupOrCommand === 'logout') {
-    // flush telemetry events before logging out
-    await flushTelemetry()
-  }
-
-  const cliRunner = getCliRunner(commands)
-  const cliCommandTrace = telemetry.trace(CliCommand, {
-    groupOrCommand: args.groupOrCommand,
-    extraArguments: args.extraArguments,
-    commandArguments: args.argsWithoutOptions.slice(0, 10),
-    coreOptions: {
-      help: args.coreOptions.help || undefined,
-      version: args.coreOptions.help || undefined,
-      debug: args.coreOptions.help || undefined,
-    },
-    ...(!args.groupOrCommand && {emptyCommand: true}), // user did not entry a command
-  })
-
-  cliCommandTrace.start()
-  cliRunner
-    .runCommand(args.groupOrCommand, args, {
-      ...options,
-      telemetry: cliCommandTrace.newContext(args.groupOrCommand),
-    })
-    .then(() => cliCommandTrace.complete())
-    .catch(async (err) => {
-      await flushTelemetry()
-      const error = typeof err.details === 'string' ? err.details : err
-      // eslint-disable-next-line no-console
-      console.error(`\n${error.stack ? neatStack(err) : error}`)
-      if (err.cause) {
-        console.error(`\nCaused by:\n\n${err.cause.stack ? neatStack(err.cause) : err.cause}`)
-      }
-      // eslint-disable-next-line no-process-exit
-      cliCommandTrace.error(error)
-      process.exit(1)
-    })
-}
-
-async function getCoreModulePath(
-  workDir: string,
-  cliConfig: CliConfigResult | null,
-): Promise<string | undefined> {
-  const corePath = resolveFrom.silent(workDir, '@sanity/core')
-  const sanityPath = resolveFrom.silent(workDir, 'sanity/_internal')
-
-  if (corePath && sanityPath) {
-    const closest = corePath.startsWith(workDir) ? corePath : sanityPath
-    const assumedVersion = closest === corePath ? 'v2' : 'v3'
-
-    console.warn(
-      chalk.yellow(
-        `Both \`@sanity/core\` AND \`sanity\` installed - assuming Sanity ${assumedVersion} project.`,
-      ),
-    )
-
-    return closest
-  }
-
-  if (sanityPath) {
-    // On v3 and everything installed
-    return sanityPath
-  }
-
-  if (corePath && cliConfig && cliConfig?.version < 3) {
-    // On v2 and everything installed
-    return corePath
-  }
-
-  const isInstallCommand = process.argv.indexOf('install') === -1
-
-  if (cliConfig && cliConfig?.version < 3 && !corePath && !isInstallCommand) {
-    const installCmd = await getInstallCommand({workDir})
-    console.warn(
-      chalk.yellow(
-        [
-          'The `@sanity/core` module is not installed in current project',
-          `Project-specific commands not available until you run \`${installCmd}\``,
-        ].join('\n'),
-      ),
-    )
-  }
-
-  if (cliConfig && cliConfig.version >= 3 && !sanityPath) {
-    const installCmd = await getInstallCommand({workDir})
-    console.warn(
-      chalk.yellow(
-        [
-          'The `sanity` module is not installed in current project',
-          `Project-specific commands not available until you run \`${installCmd}\``,
-        ].join('\n'),
-      ),
-    )
-  }
-
-  return undefined
-}
-
-/**
- * Returns the current working directory, but also handles a weird edge case where
- * the folder the terminal is currently in has been removed
- */
-function getCurrentWorkingDirectory(): string {
-  let pwd
-  try {
-    pwd = process.cwd()
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      console.error('[ERR] Could not resolve working directory, does the current folder exist?')
-      process.exit(1)
-    } else {
-      throw err
-    }
-  }
-
-  return pwd
-}
-
-function installUnhandledRejectionsHandler() {
-  process.on('unhandledRejection', (reason) => {
-    if (rejectionHasStack(reason)) {
-      console.error('Unhandled rejection:', reason.stack)
-    } else {
-      console.error('Unhandled rejection\n', reason)
-    }
-  })
-}
-
-function rejectionHasStack(reason: unknown): reason is {stack: string} {
-  return Boolean(
-    reason && typeof reason === 'object' && 'stack' in reason && typeof reason.stack === 'string',
-  )
-}
-
-function warnOnInferredProjectDir(isInit: boolean, cwd: string, workDir: string): void {
-  if (isInit || cwd === workDir) {
-    return
-  }
-
-  console.log(`Not in project directory, assuming context of project at ${workDir}`)
-}
-
-function warnOnNonProductionEnvironment(): void {
-  if (sanityEnv === 'production') {
-    return
-  }
-
-  console.warn(
-    chalk.yellow(
-      knownEnvs.includes(sanityEnv)
-        ? `[WARN] Running in ${sanityEnv} environment mode\n`
-        : `[WARN] Running in ${chalk.red('UNKNOWN')} "${sanityEnv}" environment mode\n`,
-    ),
-  )
-}
-
-function loadAndSetEnvFromDotEnvFiles({
-  workDir,
-  cmd,
-  isApp,
-}: {
-  workDir: string
-  cmd: string
-  isApp: boolean
-}) {
-  /* eslint-disable no-process-env */
-
-  // Do a cheap lookup for a sanity.json file. If there is one, assume it is a v2 project,
-  // and apply the old behavior for environment variables. Otherwise, use the Vite-style
-  // behavior. We need to do this "cheap" lookup because when loading the v3 config, env vars
-  // may be used in the configuration file, meaning we'd have to load the config twice.
-  if (existsSync(path.join(workDir, 'sanity.json'))) {
-    // v2
-    debug('sanity.json exists, assuming v2 project and loading .env files using old behavior')
-    const env = process.env.SANITY_ACTIVE_ENV || process.env.NODE_ENV || 'development'
-    debug('Loading environment files using %s mode', env)
-    dotenv.config({path: path.join(workDir, `.env.${env}`)})
-    return
-  }
-
-  // v3+
-  debug('No sanity.json exists, assuming v3 project and loading .env files using new behavior')
-
-  // Use `production` for `sanity build` / `sanity deploy`,
-  // but default to `development` for everything else unless `SANITY_ACTIVE_ENV` is set
-  const isProdCmd = ['build', 'deploy'].includes(cmd)
-  let mode = process.env.SANITY_ACTIVE_ENV
-  if (!mode && (isProdCmd || process.env.NODE_ENV === 'production')) {
-    mode = 'production'
-  } else if (!mode) {
-    mode = 'development'
-  }
-
-  if (mode === 'production' && !isProdCmd) {
-    console.warn(chalk.yellow(`[WARN] Running in ${sanityEnv} environment mode\n`))
-  }
-
-  debug('Loading environment files using %s mode', mode)
-
-  const studioEnv = loadEnv(mode, workDir, [isApp ? 'SANITY_APP_' : 'SANITY_STUDIO_'])
-  process.env = {...process.env, ...studioEnv}
-  /* eslint-disable no-process-env */
-}
-
-/**
- * Apparently, Windows environment variables are supposed to be case-insensitive,
- * (https://nodejs.org/api/process.html#processenv). However, it seems they are not?
- * `process.env.SYSTEMROOT` is sometimes `undefined`, whereas `process.env.SystemRoot` is _NOT_.
- *
- * The `open` npm module uses the former to open a browser on Powershell, and Sindre seems
- * unwilling to fix it (https://github.com/sindresorhus/open/pull/299#issuecomment-1447587598),
- * so this is a (temporary?) workaround in order to make opening browsers on windows work,
- * which several commands does (`sanity login`, `sanity docs` etc)
- */
-function maybeFixMissingWindowsEnvVar() {
-  /* eslint-disable no-process-env */
-  if (os.platform() === 'win32' && !('SYSTEMROOT' in process.env) && 'SystemRoot' in process.env) {
-    process.env.SYSTEMROOT = process.env.SystemRoot
-  }
-  /* eslint-enable no-process-env */
-}

package/src/cliClient.ts

@@ -1,62 +0,0 @@
-import {createClient, type SanityClient} from '@sanity/client'
-
-import {getCliConfigSync} from './util/getCliConfig'
-import {resolveRootDir} from './util/resolveRootDir'
-
-export interface CliClientOptions {
-  cwd?: string
-
-  projectId?: string
-  dataset?: string
-  useCdn?: boolean
-  token?: string
-  apiVersion?: string
-}
-
-export function getCliClient(options: CliClientOptions = {}): SanityClient {
-  if (typeof process !== 'object') {
-    throw new Error('getCliClient() should only be called from node.js scripts')
-  }
-
-  const {
-    // eslint-disable-next-line no-process-env
-    cwd = process.env.SANITY_BASE_PATH || process.cwd(),
-    useCdn = false,
-    apiVersion = '2022-06-06',
-    projectId,
-    dataset,
-    token = getCliClient.__internal__getToken(),
-  } = options
-
-  if (projectId && dataset) {
-    return createClient({projectId, dataset, apiVersion, useCdn, token})
-  }
-
-  const rootDir = resolveRootDir(cwd)
-  const {config} = getCliConfigSync(rootDir) || {}
-  if (!config) {
-    throw new Error('Unable to resolve CLI configuration')
-  }
-
-  const apiConfig = config?.api || {}
-  if (!apiConfig.projectId || !apiConfig.dataset) {
-    throw new Error('Unable to resolve project ID/dataset from CLI configuration')
-  }
-
-  return createClient({
-    projectId: apiConfig.projectId,
-    dataset: apiConfig.dataset,
-    apiVersion,
-    useCdn,
-    token,
-  })
-}
-
-/* eslint-disable camelcase */
-/**
- * @internal
- * @deprecated This is only for INTERNAL use, and should not be relied upon outside of official Sanity modules
- * @returns A token to use when constructing a client without a `token` explicitly defined, or undefined
- */
-getCliClient.__internal__getToken = (): string | undefined => undefined
-/* eslint-enable camelcase */

package/src/commands/blueprints/addBlueprintsCommand.ts

@@ -1,155 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-
-const helpText = `
-Arguments
-  <type>  Type of Resource to add (currently only 'function' is supported)
-
-Options
-  --name, -n <name>              Name of the Resource
-  --fn-type <type>               Type of Function to add (e.g. document-publish)
-  --fn-language, --lang <ts|js>  Language of the Function. Default: "ts"
-  --js, --javascript             Shortcut for --fn-language=js
-  --fn-helpers, --helpers        Add helpers to the Function
-  --no-fn-helpers                Do not add helpers to the Function
-  --fn-installer,                Package manager to use for Function helpers
-    --installer <npm|pnpm|yarn>    sets --fn-helpers to true
-  --install, -i                  Shortcut for --fn-installer=npm
-
-Examples:
-  # Add a Function (TypeScript by default)
-  sanity blueprints add function
-
-  # Add a Function with a specific name and install helpers with npm
-  sanity blueprints add function --name my-function -i
-
-  # Add a Function with a specific type
-  sanity blueprints add function --fn-type document-publish
-
-  # Add a Function using an example
-  sanity blueprints add function --example example-name
-
-  # Add a JavaScript Function
-  sanity blueprints add function --js
-
-  # Add a Function without helpers
-  sanity blueprints add function --no-fn-helpers
-
-  # Add a document-publish .js Function with helpers and install with npm
-  sanity blueprints add function -n roboto --fn-type document-publish --js -i
-`
-
-export interface BlueprintsAddFlags {
-  'example'?: string
-
-  'name'?: string
-  'n'?: string
-
-  'fn-type'?: string
-
-  'fn-language'?: string
-  'lang'?: string
-
-  'javascript'?: boolean
-  'js'?: boolean
-
-  'fn-helpers'?: boolean
-  'helpers'?: boolean
-  'no-fn-helpers'?: boolean
-
-  'fn-installer'?: string
-  'installer'?: string
-
-  'install'?: boolean
-  'i'?: boolean
-}
-
-const defaultFlags: BlueprintsAddFlags = {
-  'fn-language': 'ts',
-  // 'fn-helpers': true, // ask, for now
-}
-
-const addBlueprintsCommand: CliCommandDefinition<BlueprintsAddFlags> = {
-  name: 'add',
-  group: 'blueprints',
-  helpText,
-  signature:
-    '<type> [--name <name>] [--fn-type <document-publish>] [--fn-lang <ts|js>] [--javascript]',
-  description: 'Add a Resource to a Blueprint',
-
-  async action(args, context) {
-    const {output, apiClient} = context
-    const {extOptions} = args
-
-    if (extOptions.example) {
-      // example is exclusive to 'name', 'fn-type', 'fn-language', 'javascript', 'fn-helpers', 'fn-installer'
-      // check before merging default flags
-      const conflictingFlags: (keyof BlueprintsAddFlags)[] = [
-        'name',
-        'n',
-        'fn-type',
-        'fn-language',
-        'lang',
-        'javascript',
-        'js',
-        'fn-helpers',
-        'helpers',
-        'fn-installer',
-        'installer',
-      ]
-      const foundConflict = conflictingFlags.find((key) => extOptions[key])
-      if (foundConflict) {
-        throw new Error(`--example can't be used with --${foundConflict}`)
-      }
-    }
-
-    const flags = {...defaultFlags, ...extOptions}
-
-    const client = apiClient({
-      requireUser: true,
-      requireProject: false,
-    })
-    const {token} = client.config()
-
-    if (!token) throw new Error('No API token found. Please run `sanity login`.')
-
-    const [resourceType] = args.argsWithoutOptions
-
-    if (!resourceType) {
-      output.error('Resource type is required. Available types: function')
-      return
-    }
-
-    const {initBlueprintConfig} = await import('@sanity/runtime-cli/cores')
-    const {blueprintAddCore} = await import('@sanity/runtime-cli/cores/blueprints')
-
-    const cmdConfig = await initBlueprintConfig({
-      bin: 'sanity',
-      log: (message) => output.print(message),
-      token,
-    })
-
-    if (!cmdConfig.ok) throw new Error(cmdConfig.error)
-
-    let userWantsFnHelpers = flags.helpers || flags['fn-helpers']
-    if (flags['no-fn-helpers'] === true) userWantsFnHelpers = false // override
-
-    const {success, error} = await blueprintAddCore({
-      ...cmdConfig.value,
-      args: {type: resourceType},
-      flags: {
-        'example': flags.example,
-        'name': flags.n ?? flags.name,
-        'fn-type': flags['fn-type'],
-        'language': flags.lang ?? flags['fn-language'],
-        'javascript': flags.js || flags.javascript,
-        'fn-helpers': userWantsFnHelpers,
-        'fn-installer': flags.installer ?? flags['fn-installer'],
-        'install': flags.i || flags.install,
-      },
-    })
-
-    if (!success) throw new Error(error)
-  },
-}
-
-export default addBlueprintsCommand

package/src/commands/blueprints/blueprintsGroup.ts

@@ -1,10 +0,0 @@
-import {type CliCommandGroupDefinition} from '../../types'
-
-const blueprintsGroup: CliCommandGroupDefinition = {
-  name: 'blueprints',
-  signature: '[COMMAND]',
-  isGroupRoot: true,
-  description: 'Deploy and manage Sanity Blueprints and Stacks (IaC)',
-}
-
-export default blueprintsGroup

package/src/commands/blueprints/configBlueprintsCommand.ts

@@ -1,86 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-
-const helpText = `
-Options
-  --edit, -e           Edit the configuration
-  --test, -t           Test the configuration
-  --project-id <id>    Project ID to use
-
-Examples:
-  # View current configuration
-  sanity blueprints config
-
-  # Edit configuration
-  sanity blueprints config --edit
-
-  # Test configuration
-  sanity blueprints config --test
-
-  # Edit and test configuration
-  sanity blueprints config -et
-`
-
-export interface BlueprintsConfigFlags {
-  'test-config'?: boolean
-  'test'?: boolean
-  't'?: boolean
-  'edit'?: boolean
-  'e'?: boolean
-  'project-id'?: string
-  'projectId'?: string
-  'project'?: string
-  'stack-id'?: string
-  'stackId'?: string
-  'stack'?: string
-}
-
-const defaultFlags: BlueprintsConfigFlags = {
-  //
-}
-
-const configBlueprintsCommand: CliCommandDefinition<BlueprintsConfigFlags> = {
-  name: 'config',
-  group: 'blueprints',
-  helpText,
-  signature: '[--edit] [-e] [--test] [-t] [--project-id <id>]',
-  description: 'View or edit local Blueprints configuration',
-
-  async action(args, context) {
-    const {apiClient, output} = context
-    const flags = {...defaultFlags, ...args.extOptions}
-
-    const client = apiClient({
-      requireUser: true,
-      requireProject: false,
-    })
-    const {token} = client.config()
-
-    if (!token) throw new Error('No API token found. Please run `sanity login`.')
-
-    const {initBlueprintConfig} = await import('@sanity/runtime-cli/cores')
-    const {blueprintConfigCore} = await import('@sanity/runtime-cli/cores/blueprints')
-
-    const cmdConfig = await initBlueprintConfig({
-      bin: 'sanity',
-      log: (message) => output.print(message),
-      token,
-    })
-
-    if (!cmdConfig.ok) throw new Error(cmdConfig.error)
-
-    const {success, error} = await blueprintConfigCore({
-      ...cmdConfig.value,
-      token,
-      flags: {
-        'project-id': flags['project-id'] ?? flags.projectId ?? flags.project,
-        'stack-id': flags['stack-id'] ?? flags.stackId ?? flags.stack,
-        'test-config': flags['test-config'] ?? flags.test ?? flags.t,
-        'edit': flags.edit ?? flags.e,
-      },
-    })
-
-    if (!success) throw new Error(error)
-  },
-}
-
-export default configBlueprintsCommand