@sanity/cli 3.77.3-server-side-schemas.26 → 3.78.1-mcp.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/cli",
-  "version": "3.77.3-server-side-schemas.26+dacb6058a1",
+  "version": "3.78.1-mcp.17+40192fd3e0",
   "description": "Sanity CLI tool for managing Sanity installations, managing plugins, schemas and datasets",
   "keywords": [
     "sanity",
@@ -58,10 +58,11 @@
   "dependencies": {
     "@babel/traverse": "^7.23.5",
     "@sanity/client": "^6.28.2",
-    "@sanity/codegen": "3.77.3-server-side-schemas.26+dacb6058a1",
+    "@sanity/codegen": "3.78.1-mcp.17+40192fd3e0",
+    "@sanity/runtime-cli": "^1.1.1",
     "@sanity/telemetry": "^0.7.7",
     "@sanity/template-validator": "^2.4.0",
-    "@sanity/util": "3.77.3-server-side-schemas.26+dacb6058a1",
+    "@sanity/util": "3.78.1-mcp.17+40192fd3e0",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "decompress": "^4.2.0",
@@ -75,13 +76,13 @@
     "validate-npm-package-name": "^3.0.0"
   },
   "devDependencies": {
-    "@repo/package.config": "3.77.2",
-    "@repo/test-config": "3.77.2",
+    "@repo/package.config": "3.78.0",
+    "@repo/test-config": "3.78.0",
     "@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.77.3-server-side-schemas.26+dacb6058a1",
+    "@sanity/types": "3.78.1-mcp.17+40192fd3e0",
     "@types/babel__traverse": "^7.20.5",
     "@types/configstore": "^5.0.1",
     "@types/cpx": "^1.5.2",
@@ -115,7 +116,7 @@
     "minimist": "^1.2.5",
     "open": "^8.4.0",
     "ora": "^8.0.1",
-    "p-filter": "^2.1.0",
+    "p-map": "^4.0.0",
     "p-timeout": "^4.0.0",
     "preferred-pm": "^3.0.3",
     "promise-props-recursive": "^2.0.2",
@@ -133,5 +134,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "dacb6058a12b9aed696a488f16b72c16768fe4d2"
+  "gitHead": "40192fd3e0e097005847f83caca774d9b0af9145"
 }

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

@@ -8,7 +8,7 @@ import {type detectFrameworkRecord} from '@vercel/fs-detectors'
 import dotenv from 'dotenv'
 import execa, {type CommonOptions} from 'execa'
 import {deburr, noop} from 'lodash'
-import pFilter from 'p-filter'
+import pMap from 'p-map'
 import resolveFrom from 'resolve-from'
 import semver from 'semver'
 
@@ -108,6 +108,16 @@ export interface ProjectOrganization {
   slug: string
 }
 
+interface OrganizationCreateResponse {
+  id: string
+  name: string
+  createdByUserId: string
+  slug: string | null
+  defaultRoleName: string | null
+  members: unknown[]
+  features: unknown[]
+}
+
 // eslint-disable-next-line max-statements, complexity
 export default async function initSanity(
   args: CliCommandArguments<InitFlags>,
@@ -257,13 +267,14 @@ export default async function initSanity(
   const hasToken = userConfig.get('authToken')
 
   debug(hasToken ? 'User already has a token' : 'User has no token')
+  let user: SanityUser | undefined
   if (hasToken) {
     trace.log({step: 'login', alreadyLoggedIn: true})
-    const user = await getUserData(apiClient)
+    user = await getUserData(apiClient)
     success('You are logged in as %s using %s', user.email, getProviderName(user.provider))
   } else if (!unattended) {
     trace.log({step: 'login'})
-    await getOrCreateUser()
+    user = await getOrCreateUser()
   }
 
   // skip project / dataset prompting
@@ -712,6 +723,7 @@ export default async function initSanity(
     const {extOptions, ...otherArgs} = args
     const loginArgs: CliCommandArguments<LoginFlags> = {...otherArgs, extOptions: {}}
     await login(loginArgs, {...context, telemetry: trace.newContext('login')})
+    return getUserData(apiClient)
   }
 
   async function getProjectDetails(): Promise<{
@@ -858,7 +870,22 @@ export default async function initSanity(
           ? 'No projects found for user, prompting for name'
           : 'Using a coupon - skipping project selection',
       )
-      const projectName = await prompt.single({type: 'input', message: 'Project name:'})
+      const projectName = await prompt.single({
+        type: 'input',
+        message: 'Project name:',
+        default: 'My Sanity Project',
+        validate(input) {
+          if (!input || input.trim() === '') {
+            return 'Project name cannot be empty'
+          }
+
+          if (input.length > 80) {
+            return 'Project name cannot be longer than 80 characters'
+          }
+
+          return true
+        },
+      })
 
       return createProject(apiClient, {
         displayName: projectName,
@@ -1242,47 +1269,90 @@ export default async function initSanity(
     return cliFlags
   }
 
+  async function createOrganization(
+    props: {name?: string} = {},
+  ): Promise<OrganizationCreateResponse> {
+    const name =
+      props.name ||
+      (await prompt.single({
+        type: 'input',
+        message: 'Organization name:',
+        default: user ? user.name : undefined,
+        validate(input) {
+          if (input.length === 0) {
+            return 'Organization name cannot be empty'
+          } else if (input.length > 100) {
+            return 'Organization name cannot be longer than 100 characters'
+          }
+          return true
+        },
+      }))
+
+    const spinner = context.output.spinner('Creating organization').start()
+    const client = apiClient({requireProject: false, requireUser: true})
+    const organization = await client.request({
+      uri: '/organizations',
+      method: 'POST',
+      body: {name},
+    })
+    spinner.succeed()
+
+    return organization
+  }
+
   async function getOrganizationId(organizations: ProjectOrganization[]) {
-    let orgId = flags.organization
-    if (unattended) {
-      return orgId || undefined
+    // In unattended mode, if the user hasn't specified an organization, sending null as
+    // organization ID to the API will create a new organization for the user with their
+    // user name. If they _have_ specified an organization, we'll use that.
+    if (unattended || flags.organization) {
+      return flags.organization || undefined
     }
 
-    const shouldPrompt = organizations.length > 0 && !orgId
-    if (shouldPrompt) {
-      debug(`User has ${organizations.length} organization(s), checking attach access`)
-      const withGrant = await getOrganizationsWithAttachGrant(organizations)
-      if (withGrant.length === 0) {
-        debug('User lacks project attach grant in all organizations, not prompting')
-        return undefined
-      }
+    // If the user has no organizations, prompt them to create one with the same name as
+    // their user, but allow them to customize it if they want
+    if (organizations.length === 0) {
+      return createOrganization().then((org) => org.id)
+    }
 
-      debug('User has attach access to %d organizations, prompting.', withGrant.length)
-      const organizationChoices = [
-        {value: 'none', name: 'None'},
-        new prompt.Separator(),
-        ...withGrant.map((organization) => ({
-          value: organization.id,
-          name: `${organization.name} [${organization.id}]`,
-        })),
-      ]
-
-      const chosenOrg = await prompt.single({
-        message: `Select organization to attach ${isCoreAppTemplate ? 'application' : 'project'} to`,
-        type: 'list',
-        choices: organizationChoices,
-      })
+    // If the user has organizations, let them choose from them, but also allow them to
+    // create a new one in case they do not have access to any of them, or they want to
+    // create a personal/other organization.
+    debug(`User has ${organizations.length} organization(s), checking attach access`)
+    const withGrantInfo = await getOrganizationsWithAttachGrantInfo(organizations)
+    const withAttach = withGrantInfo.filter(({hasAttachGrant}) => hasAttachGrant)
+
+    debug('User has attach access to %d organizations.', withAttach.length)
+    const organizationChoices = [
+      ...withGrantInfo.map(({organization, hasAttachGrant}) => ({
+        value: organization.id,
+        name: `${organization.name} [${organization.id}]`,
+        disabled: hasAttachGrant ? false : 'Insufficient permissions',
+      })),
+      new prompt.Separator(),
+      {value: '-new-', name: 'Create new organization'},
+      new prompt.Separator(),
+    ]
+
+    // If the user only has a single organization (and they have attach access to it),
+    // we'll default to that one. Otherwise, we'll default to the organization with the
+    // same name as the user if it exists.
+    const defaultOrganizationId =
+      withAttach.length === 1
+        ? withAttach[0].organization.id
+        : organizations.find((org) => org.name === user?.name)?.id
+
+    const chosenOrg = await prompt.single({
+      message: 'Select organization:',
+      type: 'list',
+      default: defaultOrganizationId || undefined,
+      choices: organizationChoices,
+    })
 
-      if (chosenOrg && chosenOrg !== 'none') {
-        orgId = chosenOrg
-      }
-    } else if (orgId) {
-      debug(`User has defined organization flag explicitly (%s)`, orgId)
-    } else if (organizations.length === 0) {
-      debug('User has no organizations, skipping selection prompt')
+    if (chosenOrg === '-new-') {
+      return createOrganization().then((org) => org.id)
     }
 
-    return orgId || undefined
+    return chosenOrg || undefined
   }
 
   async function hasProjectAttachGrant(orgId: string) {
@@ -1301,8 +1371,15 @@ export default async function initSanity(
     )
   }
 
-  function getOrganizationsWithAttachGrant(organizations: ProjectOrganization[]) {
-    return pFilter(organizations, (org) => hasProjectAttachGrant(org.id), {concurrency: 3})
+  function getOrganizationsWithAttachGrantInfo(organizations: ProjectOrganization[]) {
+    return pMap(
+      organizations,
+      async (organization) => ({
+        hasAttachGrant: await hasProjectAttachGrant(organization.id),
+        organization,
+      }),
+      {concurrency: 3},
+    )
   }
 
   async function createOrAppendEnvVars(

package/src/commands/functions/devFunctionsCommand.ts

@@ -0,0 +1,42 @@
+import open from 'open'
+
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Options
+  --port <port> Port to start emulator on
+
+Examples
+  # Start dev server on default port
+  sanity functions dev
+
+  # Start dev server on specific port
+  sanity functions dev --port 3333
+`
+
+const defaultFlags = {
+  port: 8080,
+}
+
+const devFunctionsCommand: CliCommandDefinition = {
+  name: 'dev',
+  group: 'functions',
+  helpText,
+  signature: '',
+  description: 'Start the Sanity Function emulator',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {output} = context
+    const {print} = output
+    const flags = {...defaultFlags, ...args.extOptions}
+
+    const {devAction} = await import('@sanity/runtime-cli')
+
+    devAction(flags.port)
+
+    print(`Server is running on port ${flags.port}\n`)
+    open(`http://localhost:${flags.port}`)
+  },
+}
+
+export default devFunctionsCommand

package/src/commands/functions/functionsGroup.ts

@@ -0,0 +1,11 @@
+import {type CliCommandGroupDefinition} from '../../types'
+
+const functionsGroup: CliCommandGroupDefinition = {
+  name: 'functions',
+  signature: '[COMMAND]',
+  isGroupRoot: true,
+  description: 'Test Sanity Functions locally and retrieve logs',
+  hideFromHelp: true,
+}
+
+export default functionsGroup

package/src/commands/functions/logsFunctionsCommand.ts

@@ -0,0 +1,46 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Options
+  --id <id> The ID of the function to retrieve logs for
+
+Examples
+  # Retrieve logs for Sanity Function abcd1234
+  sanity functions logs --id abcd1234
+`
+
+const defaultFlags = {
+  id: undefined,
+}
+
+const logsFunctionsCommand: CliCommandDefinition = {
+  name: 'logs',
+  group: 'functions',
+  helpText,
+  signature: '',
+  description: 'Retrieve logs for a Sanity Function',
+  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,
+    })
+
+    if (flags.id) {
+      const token = client.config().token
+      if (token) {
+        const {logsAction} = await import('@sanity/runtime-cli')
+        const result = await logsAction(flags.id, token)
+        print(JSON.stringify(result, null, 2))
+      }
+    } else {
+      print('You must provide a function ID')
+    }
+  },
+}
+
+export default logsFunctionsCommand

package/src/commands/functions/testFunctionsCommand.ts

@@ -0,0 +1,62 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Options
+  --data <data> Data to send to the function
+  --file <file> Read data from file and send to the function
+  --path <path> Path to your Sanity Function code
+  --timeout <timeout> Execution timeout value in seconds
+
+Examples
+  # Test function passing event data on command line
+  sanity functions test --path ./test.ts --data '{ "id": 1 }'
+
+  # Test function passing event data via a file
+  sanity functions test -path ./test.js --file 'payload.json'
+
+  # Test function passing event data on command line and cap execution time to 60 seconds
+  sanity functions test -path ./test.ts --data '{ "id": 1 }' --timeout 60
+`
+
+const defaultFlags = {
+  data: undefined,
+  file: undefined,
+  path: undefined,
+  timeout: 5, // seconds
+}
+
+const testFunctionsCommand: CliCommandDefinition = {
+  name: 'test',
+  group: 'functions',
+  helpText,
+  signature: '',
+  description: 'Invoke a local Sanity Function',
+  hideFromHelp: true,
+  async action(args, context) {
+    const {output} = context
+    const {print} = output
+    const flags = {...defaultFlags, ...args.extOptions}
+
+    if (flags.path) {
+      const {testAction} = await import('@sanity/runtime-cli')
+      const {json, logs, error} = await testAction(flags.path, {
+        data: flags.data,
+        file: flags.file,
+        timeout: flags.timeout,
+      })
+
+      if (error) {
+        print(error.toString())
+      } else {
+        print('Logs:')
+        print(logs)
+        print('Response:')
+        print(JSON.stringify(json, null, 2))
+      }
+    } else {
+      print('You must provide a path to the Sanity Function code')
+    }
+  },
+}
+
+export default testFunctionsCommand

package/src/commands/index.ts

@@ -2,6 +2,10 @@ import {type CliCommandDefinition, type CliCommandGroupDefinition} from '../type
 import codemodCommand from './codemod/codemodCommand'
 import debugCommand from './debug/debugCommand'
 import docsCommand from './docs/docsCommand'
+import devfunctionsCommand from './functions/devFunctionsCommand'
+import functionsGroup from './functions/functionsGroup'
+import logsfunctionsCommand from './functions/logsFunctionsCommand'
+import testfunctionsCommand from './functions/testFunctionsCommand'
 import helpCommand from './help/helpCommand'
 import initCommand from './init/initCommand'
 import installCommand from './install/installCommand'
@@ -39,4 +43,8 @@ export const baseCommands: (CliCommandDefinition | CliCommandGroupDefinition)[]
   telemetryStatusCommand,
   generateTypegenCommand,
   typegenGroup,
+  functionsGroup,
+  devfunctionsCommand,
+  logsfunctionsCommand,
+  testfunctionsCommand,
 ]

package/src/commands/init/initCommand.ts

@@ -101,7 +101,6 @@ export const initCommand: CliCommandDefinition<InitFlags> = {
   description: 'Initializes a new Sanity Studio and/or project',
   helpText,
   action: async (args, context) => {
-    const {output, chalk} = context
     const [type] = args.argsWithoutOptions
 
     // `sanity init whatever`