@sanity/cli 3.85.2-media-library.14 → 3.86.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/cli",
-  "version": "3.85.2-media-library.14+fedc36ab36",
+  "version": "3.86.0",
   "description": "Sanity CLI tool for managing Sanity installations, managing plugins, schemas and datasets",
   "keywords": [
     "sanity",
@@ -59,11 +59,11 @@
   "dependencies": {
     "@babel/traverse": "^7.23.5",
     "@sanity/client": "^6.29.0",
-    "@sanity/codegen": "3.85.2-media-library.14+fedc36ab36",
-    "@sanity/runtime-cli": "^2.5.0",
+    "@sanity/codegen": "3.86.0",
+    "@sanity/runtime-cli": "^3.0.0",
     "@sanity/telemetry": "^0.8.0",
     "@sanity/template-validator": "^2.4.3",
-    "@sanity/util": "3.85.2-media-library.14+fedc36ab36",
+    "@sanity/util": "3.86.0",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "decompress": "^4.2.0",
@@ -83,7 +83,7 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@sanity/eslint-config-studio": "^4.0.0",
     "@sanity/generate-help-url": "^3.0.0",
-    "@sanity/types": "3.85.2-media-library.14+fedc36ab36",
+    "@sanity/types": "3.86.0",
     "@types/babel__traverse": "^7.20.5",
     "@types/configstore": "^5.0.1",
     "@types/cpx": "^1.5.2",
@@ -135,5 +135,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "fedc36ab3627655fb7be4021ba6e22aaa2641b14"
+  "gitHead": "29b5941dceac3ece48124c4ad586aa7431f33043"
 }

package/src/commands/blueprints/addBlueprintsCommand.ts

@@ -0,0 +1,81 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Arguments
+  [type]  Type of Resource to add (currently only 'function' is supported)
+
+Examples
+  # Add a Function Resource
+  sanity blueprints add function
+`
+
+const addBlueprintsCommand: CliCommandDefinition = {
+  name: 'add',
+  group: 'blueprints',
+  helpText,
+  signature: '<type>',
+  description: 'Add a Resource to a Blueprint',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {output, prompt} = context
+    const {print} = output
+
+    const [resourceType] = args.argsWithoutOptions
+
+    if (!resourceType) {
+      print('Resource type is required. Available types: function')
+      return
+    }
+
+    const {blueprint: blueprintAction, resources: resourcesAction} = await import(
+      '@sanity/runtime-cli/actions/blueprints'
+    )
+
+    const existingBlueprint = blueprintAction.findBlueprintFile()
+    if (!existingBlueprint) {
+      print('No blueprint file found. Run `sanity blueprints init` first.')
+      return
+    }
+
+    if (resourceType === 'function') {
+      const functionName = await prompt.single({
+        type: 'input',
+        message: 'Enter function name:',
+        validate: (input: string) => input.length > 0 || 'Function name is required',
+      })
+
+      const functionType = await prompt.single({
+        type: 'list',
+        message: 'Choose function type:',
+        choices: [
+          {value: 'document-publish', name: 'Document Publish'},
+          {value: 'document-create', name: 'Document Create (Available soon)', disabled: true},
+          {value: 'document-delete', name: 'Document Delete (Available soon)', disabled: true},
+        ],
+      })
+
+      const {filePath, resourceAdded, resource} = resourcesAction.createFunctionResource({
+        name: functionName,
+        type: functionType,
+        displayName: functionName,
+      })
+
+      print(`\nCreated function: ${filePath}`)
+
+      if (resourceAdded) {
+        // added to blueprint.json
+        print('Function Resource added to Blueprint')
+      } else {
+        // print the resource JSON for manual addition
+        print('\nAdd this Function Resource to your Blueprint:')
+        print(JSON.stringify(resource, null, 2))
+      }
+
+      return
+    }
+
+    print(`Unsupported resource type: ${resourceType}. Available types: function`)
+  },
+}
+
+export default addBlueprintsCommand

package/src/commands/blueprints/blueprintsGroup.ts

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

package/src/commands/blueprints/configBlueprintsCommand.ts

@@ -0,0 +1,112 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Options
+  --edit  Edit the configuration
+
+Examples
+  # View current configuration
+  sanity blueprints config
+
+  # Edit configuration
+  sanity blueprints config --edit
+`
+
+const defaultFlags = {
+  edit: false,
+}
+
+const configBlueprintsCommand: CliCommandDefinition = {
+  name: 'config',
+  group: 'blueprints',
+  helpText,
+  signature: '[--edit]',
+  description: 'View or edit local Blueprints configuration',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {apiClient, output, prompt} = context
+    const {print} = output
+    const flags = {...defaultFlags, ...args.extOptions}
+
+    const client = apiClient({
+      requireUser: true,
+      requireProject: false,
+    })
+    const {token} = client.config()
+    const {
+      blueprint: blueprintAction,
+      projects: projectsAction,
+      stacks: stacksAction,
+    } = await import('@sanity/runtime-cli/actions/blueprints')
+
+    const config = blueprintAction.readConfigFile()
+    if (!config) {
+      print('No configuration found. Run `sanity blueprints init` first.')
+      return
+    }
+
+    print('\nCurrent configuration:')
+    print(JSON.stringify(config, null, 2))
+
+    if (!flags.edit) {
+      return
+    }
+
+    if (!token) {
+      print('No API token found. Please run `sanity login` first.')
+      return
+    }
+
+    const {ok, projects, error} = await projectsAction.listProjects({token})
+    if (!ok) {
+      print(error)
+      return
+    }
+
+    if (!projects || projects.length === 0) {
+      print('No Projects found. Please create a Project in Sanity.io first.')
+      return
+    }
+
+    const projectChoices = projects.map(({displayName, id}) => ({
+      value: id,
+      name: `${displayName} <${id}>`,
+    }))
+
+    const projectId = await prompt.single({
+      type: 'list',
+      message: 'Select your Sanity Project:',
+      choices: projectChoices,
+      default: config.projectId,
+    })
+
+    const auth = {token, projectId}
+
+    // get stacks for selected project
+    const {ok: stacksOk, stacks, error: stacksError} = await stacksAction.listStacks(auth)
+    if (!stacksOk) {
+      print(stacksError)
+      return
+    }
+
+    let stackId
+    if (stacks && stacks.length > 0) {
+      const stackChoices = stacks.map(({name, id}) => ({
+        value: id,
+        name: `${name} <${id}>`,
+      }))
+
+      stackId = await prompt.single({
+        type: 'list',
+        message: 'Select a Stack:',
+        choices: stackChoices,
+        default: config.stackId,
+      })
+    }
+
+    blueprintAction.writeConfigFile({projectId, stackId})
+    print('\nConfiguration updated successfully.')
+  },
+}
+
+export default configBlueprintsCommand

package/src/commands/blueprints/deployBlueprintsCommand.ts

@@ -0,0 +1,164 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Examples
+  # Deploy the current blueprint
+  sanity blueprints deploy
+`
+
+const deployBlueprintsCommand: CliCommandDefinition = {
+  name: 'deploy',
+  group: 'blueprints',
+  helpText,
+  signature: '',
+  description: 'Deploy a Blueprint to create or update a Stack',
+  hideFromHelp: true,
+  /* eslint-disable-next-line complexity, max-statements */
+  async action(args, context) {
+    const {apiClient, output, prompt} = context
+    const {print} = output
+
+    const client = apiClient({
+      requireUser: true,
+      requireProject: false,
+    })
+    const {token} = client.config()
+    const {
+      blueprint: blueprintAction,
+      stacks: stacksAction,
+      assets: assetsAction,
+    } = await import('@sanity/runtime-cli/actions/blueprints')
+    const {display} = await import('@sanity/runtime-cli/utils')
+
+    if (!token) {
+      print('No API token found. Please run `sanity login` first.')
+      return
+    }
+
+    let blueprint = null
+    try {
+      blueprint = await blueprintAction.readBlueprintOnDisk({getStack: true, token})
+    } catch (error) {
+      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
+      return
+    }
+
+    if (!blueprint) {
+      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
+      return
+    }
+
+    const {
+      errors,
+      projectId: configuredProjectId,
+      stackId,
+      parsedBlueprint,
+      deployedStack,
+    } = blueprint
+
+    if (errors && errors.length > 0) {
+      print(errors)
+      return
+    }
+
+    if (stackId && !deployedStack) {
+      print('Stack specified in config, but deployed Stack not found.')
+      return
+    }
+
+    const resources = parsedBlueprint.resources || []
+
+    let projectId = configuredProjectId
+    if (!projectId) {
+      print('No Sanity Project context found in Blueprint configuration.')
+
+      const maybeProjectId = await prompt.single({
+        type: 'input',
+        message: 'Enter Sanity Project ID:',
+      })
+
+      projectId = maybeProjectId
+    }
+
+    if (!projectId) {
+      print('Sanity Project context is required')
+      print('To configure this Blueprint, run `sanity blueprints config`')
+      return
+    }
+
+    const auth = {token, projectId}
+
+    let name = deployedStack?.name
+    if (!name) {
+      const stackName = await prompt.single({
+        type: 'input',
+        message: 'Enter stack name:',
+        validate: (input) => input.length > 0 || 'Stack name is required',
+      })
+
+      name = stackName
+    }
+
+    if (!name) {
+      print('Stack name is required')
+      return
+    }
+
+    const validResources = resources?.filter((r) => r.type)
+    const functionResources = validResources?.filter((r) => r.type.startsWith('sanity.function.'))
+
+    if (functionResources?.length) {
+      for (const resource of functionResources) {
+        print(`Processing ${resource.name}...`)
+        const result = await assetsAction.stashAsset({resource, auth})
+
+        if (result.success && result.assetId) {
+          const src = resource.src
+          resource.src = result.assetId // ! this will change! for now, the API expects the assetId
+          const {yellow} = display.colors
+          print(`${resource.name} <${yellow(result.assetId)}>`)
+          print(`   Source: ${src}`)
+        } else {
+          print(`   Error: ${result.error}`)
+          throw new Error(`Failed to process ${resource.name}`)
+        }
+      }
+    }
+
+    const stackPayload = {
+      name,
+      projectId,
+      document: {resources: validResources},
+    }
+
+    print('Deploying stack...')
+
+    const {
+      ok: deployOk,
+      stack,
+      error: deployError,
+    } = deployedStack
+      ? await stacksAction.updateStack({stackId: deployedStack.id, stackPayload, auth})
+      : await stacksAction.createStack({stackPayload, auth})
+
+    if (deployOk) {
+      const {green, bold, yellow} = display.colors
+      print(
+        `${green('Success!')} Stack "${bold(stack.name)}" ${deployedStack ? 'updated' : 'created'} <${yellow(stack.id)}>`,
+      )
+
+      blueprintAction.writeConfigFile({
+        projectId,
+        stackId: stack.id,
+      })
+
+      print('\nUse `sanity blueprints info` to check deployment status')
+    } else {
+      const {red} = display.colors
+      print(`${red('Failed')} to ${deployedStack ? 'update' : 'create'} stack`)
+      print(`Error: ${deployError || JSON.stringify(stack, null, 2) || 'Unknown error'}`)
+    }
+  },
+}
+
+export default deployBlueprintsCommand

package/src/commands/blueprints/infoBlueprintsCommand.ts

@@ -0,0 +1,84 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Options
+  --id, -i  Stack ID
+
+Examples
+  # Retrieve information about the current Stack
+  sanity blueprints info
+
+  # Retrieve information about a specific Stack
+  sanity blueprints info --id <stack-id>
+`
+
+const defaultFlags = {id: undefined}
+
+const infoBlueprintsCommand: CliCommandDefinition = {
+  name: 'info',
+  group: 'blueprints',
+  helpText,
+  signature: '',
+  description: 'Retrieve information about a Blueprint Stack',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {apiClient, output} = context
+    const {print} = output
+    const flags = {...defaultFlags, ...args.extOptions}
+
+    const client = apiClient({
+      requireUser: true,
+      requireProject: false,
+    })
+    const {token} = client.config()
+    const {blueprint: blueprintAction, stacks: stacksAction} = await import(
+      '@sanity/runtime-cli/actions/blueprints'
+    )
+    const {display} = await import('@sanity/runtime-cli/utils')
+
+    let blueprint = null
+    try {
+      blueprint = await blueprintAction.readBlueprintOnDisk({token})
+    } catch (error) {
+      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
+      return
+    }
+
+    if (!blueprint) {
+      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
+      return
+    }
+
+    const {errors, deployedStack, projectId} = blueprint
+
+    if (errors && errors.length > 0) {
+      print(errors)
+      return
+    }
+
+    if (token && projectId) {
+      const auth = {token, projectId}
+      let result
+      if (flags.id) {
+        const {stack, error, ok} = await stacksAction.getStack({stackId: flags.id, auth})
+        if (ok) {
+          result = stack
+        } else {
+          print(error)
+        }
+      } else {
+        result = deployedStack
+      }
+
+      if (result) {
+        print(display.blueprintsFormatting.formatStackInfo(result))
+      } else {
+        print('No Stack found')
+      }
+    } else {
+      print('Cannot retrieve information for Blueprint: missing API token or Project ID')
+    }
+  },
+}
+
+export default infoBlueprintsCommand

package/src/commands/blueprints/initBlueprintsCommand.ts

@@ -0,0 +1,96 @@
+import {join} from 'node:path'
+import {cwd} from 'node:process'
+
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Examples
+  # Create a new Blueprint manifest file
+  sanity blueprints init
+`
+
+const initBlueprintsCommand: CliCommandDefinition = {
+  name: 'init',
+  group: 'blueprints',
+  helpText,
+  signature: '',
+  description: 'Initialize a new Blueprint manifest file',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {apiClient, output, prompt} = context
+    const {print} = output
+
+    const client = apiClient({
+      requireUser: true,
+      requireProject: false,
+    })
+    const {token} = client.config()
+
+    if (!token) {
+      print('No API token found. Please run `sanity login` first.')
+      return
+    }
+
+    const {blueprint: blueprintAction, projects: projectsAction} = await import(
+      '@sanity/runtime-cli/actions/blueprints'
+    )
+
+    const existingBlueprint = blueprintAction.findBlueprintFile()
+
+    if (existingBlueprint) {
+      print(`A blueprint file already exists: ${existingBlueprint.fileName}`)
+      return
+    }
+
+    const blueprintExtension = await prompt.single({
+      type: 'list',
+      message: 'Choose a Blueprint manifest file type:',
+      choices: [
+        {value: 'json', name: 'JSON (Recommended)'},
+        {value: 'js', name: 'JavaScript (Available soon)', disabled: true},
+        {value: 'ts', name: 'TypeScript (Available soon)', disabled: true},
+      ],
+    })
+
+    const {ok, projects, error} = await projectsAction.listProjects({token})
+
+    if (!ok) {
+      print(error)
+      return
+    }
+
+    if (!projects || projects.length === 0) {
+      print('No Projects found. Please create a Project in Sanity.io first.')
+      return
+    }
+
+    const projectChoices = projects.map(({displayName, id}) => ({
+      value: id,
+      name: `${displayName} <${id}>`,
+    }))
+
+    const projectId = await prompt.single({
+      type: 'list',
+      message: 'Select your Sanity Project:',
+      choices: projectChoices,
+    })
+
+    const fileName = `blueprint.${blueprintExtension}`
+    const filePath = join(cwd(), fileName)
+
+    blueprintAction.writeBlueprintToDisk({
+      path: filePath,
+      fileType: blueprintExtension as 'json' | 'js' | 'ts',
+    })
+
+    blueprintAction.writeConfigFile({projectId})
+
+    print(`Created new blueprint: ./${fileName}`)
+
+    if (blueprintExtension === 'ts') {
+      print('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx')
+    }
+  },
+}
+
+export default initBlueprintsCommand

package/src/commands/blueprints/logsBlueprintsCommand.ts

@@ -0,0 +1,111 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+${
+  /*Options
+  --watch, -w  Watch for new logs (streaming mode)
+*/ ''
+}
+Examples
+  # Show logs for the current Stack
+  sanity blueprints logs
+${
+  /*
+  # Watch for new logs
+  sanity blueprints logs --watch
+*/ ''
+}
+`
+
+// const defaultFlags = {watch: false}
+
+const logsBlueprintsCommand: CliCommandDefinition = {
+  name: 'logs',
+  group: 'blueprints',
+  helpText,
+  signature: '[--watch]',
+  description: 'Display logs for the current Blueprint Stack',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {apiClient, output} = context
+    const {print} = output
+    // const flags = {...defaultFlags, ...args.extOptions}
+    // const watchMode = Boolean(flags.watch)
+
+    const client = apiClient({requireUser: true, requireProject: false})
+    const {token} = client.config()
+
+    if (!token) {
+      print('No API token found. Please run `sanity login` first.')
+      return
+    }
+
+    const {blueprint: blueprintAction, logs: logsAction} = await import(
+      '@sanity/runtime-cli/actions/blueprints'
+    )
+    const {display} = await import('@sanity/runtime-cli/utils')
+
+    let blueprint = null
+    try {
+      blueprint = await blueprintAction.readBlueprintOnDisk({token})
+    } catch (error) {
+      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
+      return
+    }
+
+    if (!blueprint) {
+      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
+      return
+    }
+
+    const {errors, deployedStack} = blueprint
+
+    if (errors && errors.length > 0) {
+      print(errors)
+      return
+    }
+
+    if (!deployedStack) {
+      print('Stack not found')
+      return
+    }
+
+    const {id: stackId, projectId, name} = deployedStack
+    const auth = {token, projectId}
+
+    print(`Fetching logs for stack ${display.colors.yellow(`<${stackId}>`)}`)
+
+    // enable watch mode here
+
+    try {
+      const {ok, logs, error} = await logsAction.getLogs(stackId, auth)
+
+      if (!ok) {
+        print(`${display.colors.red('Failed')} to retrieve logs`)
+        print(`Error: ${error || 'Unknown error'}`)
+        return
+      }
+
+      if (logs.length === 0) {
+        print(`No logs found for Stack ${stackId}`)
+        return
+      }
+
+      print(`${display.blueprintsFormatting.formatTitle('Blueprint', name)} Logs`)
+      print(
+        `Found ${display.colors.bold(logs.length.toString())} log entries for stack ${display.colors.yellow(stackId)}\n`,
+      )
+
+      // Organize and format logs by day
+      const logsByDay = display.logsFormatting.organizeLogsByDay(logs)
+      print(display.logsFormatting.formatLogsByDay(logsByDay))
+    } catch (err) {
+      print('Failed to retrieve logs')
+      if (err instanceof Error) {
+        print(`Error: ${err.message}`)
+      }
+    }
+  },
+}
+
+export default logsBlueprintsCommand