@sanity/runtime-cli 17.2.0 → 17.3.0

package/dist/cores/blueprints/deploy.js

@@ -1,5 +1,5 @@
 import { dirname } from 'node:path';
-import { stashAsset } from '../../actions/blueprints/assets.js';
+import { preDeploy } from '../../actions/blueprints/pre-deploy.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { waitForOperation } from '../../actions/blueprints/wait-for-operation.js';
 import { checkUserPermission } from '../../actions/sanity/access.js';
@@ -7,12 +7,7 @@ import { createHintCollector } from '../../utils/blueprints/hints.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
 import { styleText } from '../../utils/style-text.js';
-import { isAssetResource } from '../../utils/types.js';
 import { getWarnings } from '../../utils/warnings.js';
-const DEFAULT_ASSET_TIMEOUT = 60;
-const assetTimeoutS = Number(process.env.SANITY_ASSET_TIMEOUT) || DEFAULT_ASSET_TIMEOUT;
-const assetTimeoutMs = assetTimeoutS * 1000;
-const warnTimeoutMs = assetTimeoutMs / 2;
 export async function blueprintDeployCore(options) {
     const { bin = 'sanity', log, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
     const { verbose } = flags;
@@ -39,17 +34,21 @@ export async function blueprintDeployCore(options) {
             };
         }
         const resources = [...blueprint.resources];
-        const assetResources = resources.filter(isAssetResource);
-        if (assetResources.length > 0) {
-            log('Processing assets...');
-            for (const resource of assetResources) {
-                const preDeployResult = await preDeploy(resource, { auth, blueprintFileDir, installer, log });
-                if (!preDeployResult.success)
-                    return preDeployResult;
-                const idx = resources.indexOf(resource);
-                if (idx !== -1)
-                    resources[idx] = preDeployResult.resource;
-            }
+        const preDeployResult = await preDeploy({
+            scopeType,
+            scopeId,
+            resources,
+            stackId,
+            stackName,
+            auth,
+            blueprintFileDir,
+            installer,
+            log,
+            bin,
+            verbose,
+        });
+        if (!preDeployResult?.success) {
+            return preDeployResult;
         }
         const spinner = log.ora('Deploying...').start();
         const { ok: deployOk, stack, error: deployError, } = await updateStack({
@@ -152,53 +151,6 @@ export async function blueprintDeployCore(options) {
         return { success: false, error: errorMessage };
     }
 }
-async function preDeploy(resource, options) {
-    const { auth, blueprintFileDir, installer, log } = options;
-    const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
-    const warnTimer = setTimeout(() => {
-        fnSpinner.text = `Still processing ${resource.name}, this can take a moment...`;
-    }, warnTimeoutMs);
-    let assetTimeoutTimer;
-    let result;
-    try {
-        result = await Promise.race([
-            stashAsset({ resource, blueprintFileDir, auth, logger: log, installer }),
-            new Promise((_, reject) => {
-                assetTimeoutTimer = setTimeout(() => {
-                    reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
-                }, assetTimeoutMs);
-            }),
-        ]);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        fnSpinner.fail(msg);
-        return { success: false, error: msg };
-    }
-    finally {
-        clearTimeout(warnTimer);
-        clearTimeout(assetTimeoutTimer);
-    }
-    if (result.success && result.assetId) {
-        const updatedResource = { ...resource, src: result.assetId };
-        fnSpinner.succeed(`${updatedResource.name} ${niceId(result.assetId)}`);
-        log(`   Source: ${updatedResource.src}`);
-        if (result.hash) {
-            if (result.hash.length > 24) {
-                log.verbose(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
-            }
-            else {
-                log.verbose(`   Hash: ${result.hash}`);
-            }
-        }
-        if (result.exists)
-            log.verbose('   Asset unchanged');
-        return { success: true, resource: updatedResource };
-    }
-    const errorMsg = `Failed uploading ${resource.name} asset, deploy has stopped`;
-    fnSpinner.fail(errorMsg);
-    return { success: false, error: result.error || 'Failed to process asset' };
-}
 const CHECK_LEGACY_DEPLOY_PERMISSION = false;
 const BLUEPRINTS_PERMISSION_ENFORCEMENT_DATE = 'July 1, 2026';
 async function checkLegacyDeployPermission({ auth, scopeType, scopeId, log, }) {

package/dist/utils/functions/child-process-wrapper.js

@@ -1,9 +1,13 @@
-import {table as renderTable} from 'node:console'
 import {existsSync, statSync} from 'node:fs'
 import {isAbsolute, join} from 'node:path'
 import process from 'node:process'
 import {pathToFileURL} from 'node:url'
-import {inspect} from 'node:util'
+import {installConsole} from './child-runtime/console.js'
+import {createInvoker} from './child-runtime/invoke.js'
+import {createResourcesApi} from './child-runtime/resources.js'
+
+installConsole()
+const invoker = createInvoker()
 
 export function getFunctionSource(src) {
   const pathToCheck = isAbsolute(src) ? src : join(process.cwd(), src)
@@ -18,91 +22,6 @@ export function getFunctionSource(src) {
   return pathToFileURL(pathToCheck).href
 }
 
-// Monkey patch console menthods to have logs match server log format
-function logPrefix(level, ...args) {
-  const date = new Date()
-  const shouldUseColors = process.env.FORCE_COLOR === '1'
-  const message = args
-    .map((arg) =>
-      typeof arg === 'string' ? arg : inspect(arg, {depth: null, colors: shouldUseColors}),
-    )
-    .join(' ')
-  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()} ${level.toUpperCase()} ${message}`
-}
-
-console.log = (...args) => {
-  process.stdout.write(`${logPrefix('info', ...args)}\n`)
-}
-
-console.info = (...args) => {
-  process.stdout.write(`${logPrefix('info', ...args)}\n`)
-}
-
-console.dir = (obj, options) => {
-  const shouldUseColors = process.env.FORCE_COLOR === '1'
-  const inspectOptions = {...options, colors: shouldUseColors}
-  process.stdout.write(`${logPrefix('info', inspect(obj, inspectOptions))}\n`)
-}
-
-console.table = (data, columns) => {
-  const prefix = logPrefix('info')
-
-  // Capture table output
-  const originalWrite = process.stdout.write.bind(process.stdout)
-  let buffer = ''
-
-  process.stdout.write = (chunk, _encoding, callback) => {
-    buffer += chunk
-    if (typeof callback === 'function') callback()
-  }
-
-  renderTable(data, columns)
-
-  // Restore and print
-  process.stdout.write = originalWrite
-  for (const line of buffer.split('\n')) {
-    if (line.trim()) {
-      const message = `${!line.startsWith(prefix) ? `${prefix} ${line}` : line}`.trim()
-      process.stdout.write(`${message}\n`)
-    }
-  }
-}
-
-console.warn = (...args) => {
-  process.stdout.write(`${logPrefix('warn', ...args)}\n`)
-}
-
-console.error = (...args) => {
-  process.stdout.write(`${logPrefix('error', ...args)}\n`)
-}
-
-/**
- * Pending nested `context.invoke` calls, keyed by correlation id. Each entry
- * holds the resolve/reject of the Promise returned to the user's handler; it is
- * settled when the matching `invoke-response` arrives from the parent.
- * @type {Map<string, {resolve: (value: unknown) => void, reject: (reason: Error) => void}>}
- */
-const pendingInvokes = new Map()
-let invokeSeq = 0
-
-/**
- * `context.invoke(name, payload)` — ask the parent to execute another blueprint
- * function and resolve with its return value. Sent over IPC and correlated by id.
- * @param {string} name
- * @param {Record<string, unknown>} [payload]
- * @returns {Promise<unknown>}
- */
-function invokeFunction(name, payload = {}) {
-  if (typeof name !== 'string' || name.length === 0) {
-    return Promise.reject(new Error('context.invoke requires a function name'))
-  }
-  const id = String(++invokeSeq)
-  return new Promise((resolve, reject) => {
-    pendingInvokes.set(id, {resolve, reject})
-    process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
-  })
-}
-
 // Listen for IPC messages from the parent process.
 process.on('message', async (data) => {
   let jsonData = null
@@ -115,18 +34,7 @@ process.on('message', async (data) => {
 
   // Response to a nested context.invoke() — route to the awaiting Promise and stop.
   if (jsonData?.type === 'invoke-response') {
-    const pending = pendingInvokes.get(jsonData.id)
-    if (!pending) return
-    pendingInvokes.delete(jsonData.id)
-    if (jsonData.ok) {
-      pending.resolve(jsonData.result?.json)
-    } else {
-      const {message, stack, name} = jsonData.error ?? {}
-      const error = new Error(message ?? 'Nested invoke failed')
-      if (stack) error.stack = stack
-      if (name) error.name = name
-      pending.reject(error)
-    }
+    invoker.handleResponse(jsonData)
     return
   }
 
@@ -160,25 +68,20 @@ process.on('message', async (data) => {
   try {
     // Import the function code
     const entry = await import(getFunctionSource(srcPath))
-    const eventHandler = entry.handler || entry.default
-
-    if (typeof eventHandler !== 'function') {
-      throw new Error(
-        'No valid handler found. Please provide a default export or a named export, "handler"',
-      )
+    const handler = entry.handler || entry.default
+    if (typeof handler !== 'function') {
+      throw new Error('No valid handler found. Provide a default export or a named "handler".')
     }
 
     // Replace resources JSON with Resources API
     context.resources = createResourcesApi(context.resources)
 
     // Allow the handler to invoke other blueprint functions by name.
-    context.invoke = invokeFunction
-
-    json = await eventHandler({
+    context.invoke = invoker.invoke
+    json = await handler({
       context,
       event,
-      // mock sync-tag-invalidate done callback
-      done: async (_tags) => new Response(null, {status: 204}),
+      done: async () => new Response(null, {status: 204}),
     })
 
     // Restore streams
@@ -191,7 +94,6 @@ process.on('message', async (data) => {
     // Restore streams on error
     process.stdout.write = originalStdoutWrite
     process.stderr.write = originalStderrWrite
-
     const errorInfo = {
       type: 'result',
       json: null,
@@ -207,63 +109,3 @@ process.on('message', async (data) => {
     process.exit(1)
   }
 })
-
-/**
- * The returned proxy wraps a function so the API itself is callable.
- * @param {Record<string, ResourceEntry[]>} resources
- * @returns {ResourcesApi}
- */
-export function createResourcesApi(resources) {
-  const findByName = (name) => {
-    for (const group of Object.values(resources)) {
-      const found = group.find((r) => r.name === name)
-      if (found) return found
-    }
-    return undefined
-  }
-  let allCache
-  const all = () => (allCache ??= Object.values(resources).flat())
-
-  return /** @type {ResourcesApi} */ (
-    /** @type {unknown} */ (
-      /*
-       * The Proxy target is `findByName`, so invoking the API as a function —
-       * `context.resources('my-proj')` — bypasses the `get` trap entirely and
-       * calls `findByName` directly for a cross-type lookup by name.
-       */
-      new Proxy(findByName, {
-        get: (_target, prop) => {
-          // context.resources.all() — flat array of every resource across types
-          if (prop === 'all') return all
-          // [...context.resources] / for (const r of context.resources) — iterate all
-          if (prop === Symbol.iterator) {
-            return function* () {
-              yield* all()
-            }
-          }
-
-          /**
-           * Symbol property access (other than iterator above) and `then`
-           * lookups return undefined. The `then` guard prevents the API from
-           * looking like a thenable, so `await context.resources` resolves to
-           * the proxy itself rather than hanging or unwrapping unexpectedly.
-           */
-          if (typeof prop !== 'string' || prop === 'then') {
-            return undefined
-          }
-
-          /**
-           * context.resources.<type>(name) — per-type lookup,
-           * e.g. context.resources.project('my-proj').
-           * Returns a function so the caller supplies the name;
-           * unknown types yield a function that always returns undefined.
-           */
-          return (/** @type {string} */ name) =>
-            Object.hasOwn(resources, prop)
-              ? resources[prop].find((r) => r.name === name)
-              : undefined
-        },
-      })
-    )
-  )
-}

package/dist/utils/functions/child-runtime/console.d.ts

@@ -0,0 +1 @@
+export function installConsole(): void

package/dist/utils/functions/child-runtime/console.js

@@ -0,0 +1,50 @@
+import {table as renderTable} from 'node:console'
+import process from 'node:process'
+import {inspect} from 'node:util'
+
+// Monkey patch console methods to have logs match server log format
+function logPrefix(level, ...args) {
+  const date = new Date()
+  const shouldUseColors = process.env.FORCE_COLOR === '1'
+  const message = args
+    .map((arg) =>
+      typeof arg === 'string' ? arg : inspect(arg, {depth: null, colors: shouldUseColors}),
+    )
+    .join(' ')
+  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()} ${level.toUpperCase()} ${message}`
+}
+
+export function installConsole() {
+  console.log = (...args) => process.stdout.write(`${logPrefix('info', ...args)}\n`)
+  console.info = (...args) => process.stdout.write(`${logPrefix('info', ...args)}\n`)
+  console.warn = (...args) => process.stdout.write(`${logPrefix('warn', ...args)}\n`)
+  console.error = (...args) => process.stdout.write(`${logPrefix('error', ...args)}\n`)
+  console.dir = (obj, options) => {
+    const shouldUseColors = process.env.FORCE_COLOR === '1'
+    const inspectOptions = {...options, colors: shouldUseColors}
+    process.stdout.write(`${logPrefix('info', inspect(obj, inspectOptions))}\n`)
+  }
+  console.table = (data, columns) => {
+    const prefix = logPrefix('info')
+
+    // Capture table output
+    const originalWrite = process.stdout.write.bind(process.stdout)
+    let buffer = ''
+
+    process.stdout.write = (chunk, _encoding, callback) => {
+      buffer += chunk
+      if (typeof callback === 'function') callback()
+    }
+
+    renderTable(data, columns)
+
+    // Restore and print
+    process.stdout.write = originalWrite
+    for (const line of buffer.split('\n')) {
+      if (line.trim()) {
+        const message = `${!line.startsWith(prefix) ? `${prefix} ${line}` : line}`.trim()
+        process.stdout.write(`${message}\n`)
+      }
+    }
+  }
+}

package/dist/utils/functions/child-runtime/invoke.d.ts

@@ -0,0 +1,4 @@
+export function createInvoker(): {
+  invoke: (name: string, payload?: Record<string, unknown>) => Promise<unknown>
+  handleResponse: (msg: unknown) => void
+}

package/dist/utils/functions/child-runtime/invoke.js

@@ -0,0 +1,47 @@
+import process from 'node:process'
+
+export function createInvoker() {
+  /**
+   * Pending nested `context.invoke` calls, keyed by correlation id. Each entry
+   * holds the resolve/reject of the Promise returned to the user's handler; it is
+   * settled when the matching `invoke-response` arrives from the parent.
+   * @type {Map<string, {resolve: (value: unknown) => void, reject: (reason: Error) => void}>}
+   */
+  const pending = new Map()
+  let invokeSeq = 0
+
+  /**
+   * `context.invoke(name, payload)` — ask the parent to execute another blueprint
+   * function and resolve with its return value. Sent over IPC and correlated by id.
+   * @param {string} name
+   * @param {Record<string, unknown>} [payload]
+   * @returns {Promise<unknown>}
+   */
+  function invoke(name, payload = {}) {
+    if (typeof name !== 'string' || name.length === 0) {
+      return Promise.reject(new Error('context.invoke requires a function name'))
+    }
+    const id = String(++invokeSeq)
+    return new Promise((resolve, reject) => {
+      pending.set(id, {resolve, reject})
+      process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
+    })
+  }
+
+  function handleResponse(msg) {
+    const pendingEntry = pending.get(msg.id)
+    if (!pendingEntry) return
+    pending.delete(msg.id)
+    if (msg.ok) {
+      pendingEntry.resolve(msg.result?.json)
+    } else {
+      const {message, stack, name} = msg.error ?? {}
+      const err = new Error(message ?? 'Nested invoke failed')
+      if (stack) err.stack = stack
+      if (name) err.name = name
+      pendingEntry.reject(err)
+    }
+  }
+
+  return {invoke, handleResponse}
+}

package/dist/utils/functions/child-runtime/resources.d.ts

@@ -0,0 +1,4 @@
+import type {ResourcesApi} from '@sanity/functions'
+import type {GroupedBlueprintResources} from '../../blueprints/group-resources.js'
+
+export function createResourcesApi(resources: GroupedBlueprintResources): ResourcesApi

package/dist/utils/functions/child-runtime/resources.js

@@ -0,0 +1,59 @@
+/**
+ * The returned proxy wraps a function so the API itself is callable.
+ * @param {Record<string, ResourceEntry[]>} resources
+ * @returns {ResourcesApi}
+ */
+export function createResourcesApi(resources) {
+  const findByName = (name) => {
+    for (const group of Object.values(resources)) {
+      const found = group.find((r) => r.name === name)
+      if (found) return found
+    }
+    return undefined
+  }
+  let allCache
+  const all = () => (allCache ??= Object.values(resources).flat())
+
+  return /** @type {ResourcesApi} */ (
+    /** @type {unknown} */ (
+      /*
+       * The Proxy target is `findByName`, so invoking the API as a function —
+       * `context.resources('my-proj')` — bypasses the `get` trap entirely and
+       * calls `findByName` directly for a cross-type lookup by name.
+       */
+      new Proxy(findByName, {
+        get: (_target, prop) => {
+          // context.resources.all() — flat array of every resource across types
+          if (prop === 'all') return all
+          // [...context.resources] / for (const r of context.resources) — iterate all
+          if (prop === Symbol.iterator) {
+            return function* () {
+              yield* all()
+            }
+          }
+
+          /**
+           * Symbol property access (other than iterator above) and `then`
+           * lookups return undefined. The `then` guard prevents the API from
+           * looking like a thenable, so `await context.resources` resolves to
+           * the proxy itself rather than hanging or unwrapping unexpectedly.
+           */
+          if (typeof prop !== 'string' || prop === 'then') {
+            return undefined
+          }
+
+          /**
+           * context.resources.<type>(name) — per-type lookup,
+           * e.g. context.resources.project('my-proj').
+           * Returns a function so the caller supplies the name;
+           * unknown types yield a function that always returns undefined.
+           */
+          return (/** @type {string} */ name) =>
+            Object.hasOwn(resources, prop)
+              ? resources[prop].find((r) => r.name === name)
+              : undefined
+        },
+      })
+    )
+  )
+}

package/dist/utils/studios/prepare-asset.d.ts

@@ -0,0 +1,6 @@
+import type { BlueprintStudioResource } from '@sanity/blueprints';
+import type { AssetPrepResult } from '../types.js';
+export declare function prepareStudioAsset({ blueprintFileDir, resource, }: {
+    blueprintFileDir: string;
+    resource: BlueprintStudioResource;
+}): Promise<AssetPrepResult>;

package/dist/utils/studios/prepare-asset.js

@@ -0,0 +1,139 @@
+import { createWriteStream } from 'node:fs';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path, { basename, dirname, join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip } from 'node:zlib';
+import { buildStudio, compareDependencyVersions } from '@sanity/cli-build/_internal/build';
+import { pack } from 'tar-fs';
+export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
+    // validate resource has an externalId
+    if (!('externalId' in resource) ||
+        typeof resource.externalId !== 'string' ||
+        !resource.externalId) {
+        return {
+            success: false,
+            async cleanup() {
+                // no op
+            },
+            error: `Unable to determine appId for sanity.studio resource '${resource.name}'`,
+        };
+    }
+    let cleanup = async () => {
+        // no op
+    };
+    const studioPath = path.resolve(blueprintFileDir, resource.src);
+    try {
+        const studioPathStat = await stat(studioPath);
+        if (!studioPathStat.isDirectory()) {
+            return {
+                success: false,
+                cleanup,
+                error: `Property 'src' on resource with type '${resource.type}' must be a directory`,
+            };
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            cleanup,
+            error: `Unable to read given 'src' on resource with type '${resource.type}': ${msg}`,
+        };
+    }
+    try {
+        const outDir = await mkdtemp(join(tmpdir(), `studio-build-`));
+        const outFile = `${outDir}.tar.gz`;
+        cleanup = async () => {
+            await rm(outDir, { force: true, recursive: true });
+            await rm(outFile, { force: true });
+        };
+        const appId = resource.externalId;
+        try {
+            await buildStudio({
+                appId,
+                autoUpdatesEnabled: resource.autoUpdates.enabled,
+                checkAppId() { },
+                async compareDependencyVersions(packages) {
+                    return compareDependencyVersions(packages, studioPath, { appId });
+                },
+                determineBasePath() {
+                    return resource.basePath ?? '/';
+                },
+                isApp: false,
+                isWorkbenchApp: false,
+                minify: resource.minify ?? true,
+                outDir,
+                output: createSilentOutput(),
+                reactCompiler: resource.reactCompiler || false,
+                schemaExtraction: undefined,
+                sourceMap: resource.sourceMap ?? false,
+                stats: false,
+                unattendedMode: true,
+                // TODO pass in vite config from the studio resource
+                vite: undefined,
+                workDir: studioPath,
+                eventListener: {
+                    onBuildFail({ message }) {
+                        throw new Error(message);
+                    },
+                    onInvalidStyledComponentsVersionRange({ message }) {
+                        throw new Error(message);
+                    },
+                    onNoDeclaredStyledComponentsVersion({ message }) {
+                        throw new Error(message);
+                    },
+                    onNoInstalledSanityVersion({ message }) {
+                        throw new Error(message);
+                    },
+                    onNoInstalledStyledComponentsVersion({ message }) {
+                        throw new Error(message);
+                    },
+                    onPreReleaseInNonInteractiveAutoUpdate({ message }) {
+                        throw new Error(message);
+                    },
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                cleanup,
+                error: message,
+            };
+        }
+        // tar/gzip/write the built output
+        await pipeline(pack(dirname(outDir), { entries: [basename(outDir)] }), createGzip(), createWriteStream(outFile));
+        return {
+            success: true,
+            cleanup,
+            // studio must be pre built (e.g. with `npm run build`) and tarred/gzipped
+            outputPath: outFile,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            cleanup,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function createSilentOutput() {
+    return {
+        error(input, options) {
+            if (typeof options?.exit === 'number') {
+                if (input instanceof Error) {
+                    throw input;
+                }
+                throw new Error(input);
+            }
+            return undefined;
+        },
+        log() { },
+        warn(input) {
+            return input;
+        },
+    };
+}