@sanity/runtime-cli 17.12.0 → 17.13.0-next.g2501ffa

package/dist/actions/blueprints/pre-deploy.js

@@ -1,15 +1,52 @@
+import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
+import { prepareAsset as prepareFunctionAsset } from '../../utils/functions/prepare-asset.js';
 import { runCommand } from '../../utils/package-manager.js';
-import { styleText } from '../../utils/style-text.js';
-import { isAssetResource, } from '../../utils/types.js';
+import { prepareStudioAsset } from '../../utils/studios/prepare-asset.js';
+import { setupLogPolling } from './logs-polling.js';
+import { getOperationStateInfo } from './operations-state.js';
 import { processAssets } from './process-assets.js';
 import { updateStack } from './stacks.js';
-import { waitForOperation } from './wait-for-operation.js';
+/**
+ * A list of configurations for pre-deployment of resources. The first resourceType to match in the list will take precedence.
+ */
+const preDeployConfigs = [
+    {
+        resourceType: 'sanity.studio',
+        async prepareAsset(options) {
+            return prepareStudioAsset({
+                resource: options.resource,
+                blueprintFileDir: options.blueprintFileDir,
+            });
+        },
+    },
+    {
+        resourceType: (type) => type.startsWith(SANITY_FUNCTION_PREFIX),
+        async prepareAsset(options) {
+            return prepareFunctionAsset({
+                resource: options.resource,
+                blueprintFileDir: options.blueprintFileDir,
+                installer: options.installer,
+            });
+        },
+    },
+];
+function hasPreDeployResources(resources) {
+    return resources.some((r) => {
+        return !!getPredeployConfig(r);
+    });
+}
+function getPredeployConfig(r) {
+    return preDeployConfigs.find((c) => {
+        return ((typeof c.resourceType === 'function' && c.resourceType(r.type)) ||
+            (typeof c.resourceType !== 'function' && c.resourceType === r.type));
+    });
+}
 export async function preDeploy(options) {
-    const { resources, stackId, auth, blueprintFileDir, installer, logger } = options;
-    const hasAssetResources = resources.some(isAssetResource);
-    if (hasAssetResources) {
+    const { resources, stackId, auth, blueprintFileDir, installer, fetchFn } = options;
+    const resourceMetadata = [];
+    if (hasPreDeployResources(resources)) {
         const preDeployStackResult = await preDeployStack(options);
         if (!preDeployStackResult.success) {
             return preDeployStackResult;
@@ -19,17 +56,23 @@ export async function preDeploy(options) {
             resources,
             stackId,
             auth,
-            logger,
+            fetchFn,
         });
-        const assetResources = resolvedResources.filter(isAssetResource);
-        let processedAssets;
+        const assetResources = [];
+        for (const r of resolvedResources) {
+            const config = getPredeployConfig(r);
+            if (typeof config !== 'undefined' && typeof config.prepareAsset === 'function') {
+                assetResources.push({ resource: r, prepareAsset: config.prepareAsset });
+            }
+        }
+        let processedAssets = [];
         try {
             processedAssets = await processAssets({
                 assetResources,
                 auth,
                 blueprintFileDir,
                 installer,
-                logger,
+                fetchFn,
                 onProgress: (progress) => options.onAssetEvent?.({ type: 'progress', progress }),
                 onResult: (result) => options.onAssetEvent?.({ type: 'result', result }),
             });
@@ -47,13 +90,23 @@ export async function preDeploy(options) {
             if (idx === -1)
                 throw new Error('Unable to update resource asset');
             resources[idx] = asset.resource;
+            if (asset.success) {
+                const { name, type } = asset.resource;
+                resourceMetadata.push({
+                    name,
+                    type,
+                    assetHash: asset.hash,
+                    assetReused: asset.exists,
+                    ...asset.metadata,
+                });
+            }
         }
     }
-    return { success: true };
+    return { success: true, resourceMetadata };
 }
 async function preDeployStack(options) {
-    const { scopeType, scopeId, stackId, stackName, resources, auth, logger, bin, verbose } = options;
-    const spinner = logger.ora('Starting pre-deploy...').start();
+    const { scopeType, scopeId, stackId, stackName, resources, auth, bin, fetchFn, waitForFn } = options;
+    options.onPreDeployStackStart?.();
     const stackMutation = {
         scopeType,
         scopeId,
@@ -61,9 +114,9 @@ async function preDeployStack(options) {
         preDeploy: true,
         document: { resources },
     };
-    const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackMutation, auth, logger });
+    const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackMutation, auth, fetchFn });
     if (!deployOk) {
-        spinner.fail(`${styleText('red', 'Failed')} to complete Stack pre-deployment`);
+        options.onPreDeployStackFail?.();
         return {
             success: false,
             error: deployError || 'Failed to complete Stack pre-deployment',
@@ -73,22 +126,37 @@ async function preDeployStack(options) {
             ],
         };
     }
-    spinner.stop().clear();
+    options.onPreDeployStackDone?.();
     if (stack.changeCount === 0)
         return { success: true };
-    logger(styleText('dim', 'Stack deployment progress:'));
-    logger('');
-    const outcome = await waitForOperation({
-        stackId,
-        operationId: stack.operationId,
-        auth,
-        log: logger,
-        bin,
-        verbose,
-        progressNoun: 'pre-deployment',
+    options.onPreDeployOperationStart?.();
+    const outcome = await waitForFn({
+        getIdleMessage() {
+            return `The pre-deployment is still running on Sanity servers.`;
+        },
+        async onRequestLatestState() {
+            return await getOperationStateInfo({
+                stackId,
+                operationId: stack.operationId,
+                auth,
+                fetchFn,
+                includeDestroyed: false,
+                progressNoun: 'pre-deployment',
+            });
+        },
+        onStartLogPolling(options) {
+            return setupLogPolling({
+                auth,
+                fetchFn,
+                operationId: stack.operationId,
+                stackId,
+                onActivity: options.onActivity,
+                onLogEntry: options.onLogEntry,
+            });
+        },
     });
     if (outcome.type === 'completed') {
-        logger(styleText(['bold', 'green'], 'Stack pre-deployment completed!'));
+        options.onPreDeployOperationDone?.();
     }
     else if (outcome.type === 'unconfirmed') {
         return {

package/dist/actions/blueprints/process-assets.d.ts

@@ -1,29 +1,31 @@
-import type { Logger } from '../../utils/logger.js';
+import type { BlueprintResource } from '@sanity/blueprints';
 import type { AssetResource, AuthParams, InstallerType } from '../../utils/types.js';
-type ProcessAssetsOptions = {
-    assetResources: AssetResource[];
+type ProcessAssetsOptions<R extends BlueprintResource> = {
+    assetResources: AssetResource<R>[];
     auth: AuthParams;
     blueprintFileDir: string;
     installer: InstallerType;
-    logger: Logger;
+    fetchFn: typeof fetch;
     onProgress?: (progress: ProcessAssetsProgress) => void;
-    onResult?: (result: ProcessedAsset) => void;
+    onResult?: (result: ProcessedAsset<R>) => void;
 };
 export type ProcessAssetsProgress = {
     completed: number;
     total: number;
     slow: boolean;
 };
-export type ProcessedAsset = {
+export type ProcessedAsset<R extends BlueprintResource> = {
     success: false;
-    resource: AssetResource;
+    resource: R;
     error: string;
     failureKind: 'processing' | 'upload';
 } | {
     success: true;
-    resource: AssetResource;
-    hash?: string;
-    exists?: boolean;
+    resource: R;
+    assetParameter: string;
+    hash: string;
+    exists: boolean;
+    metadata?: Record<string, unknown>;
 };
-export declare function processAssets(options: ProcessAssetsOptions): Promise<ProcessedAsset[]>;
+export declare function processAssets<R extends BlueprintResource>(options: ProcessAssetsOptions<R>): Promise<ProcessedAsset<R>[]>;
 export {};

package/dist/actions/blueprints/process-assets.js

@@ -21,8 +21,8 @@ export async function processAssets(options) {
     try {
         for (let start = 0; start < total; start += concurrency) {
             const batch = assetResources.slice(start, start + concurrency);
-            const batchResults = await Promise.all(batch.map(async (resource) => {
-                const result = await processAsset(resource, options);
+            const batchResults = await Promise.all(batch.map(async (assetResource) => {
+                const result = await processAsset(assetResource.resource, assetResource.prepareAsset, options);
                 completed += 1;
                 reportProgress();
                 onResult?.(result);
@@ -42,13 +42,13 @@ function getAssetConcurrency() {
     const configured = Number(env.SANITY_ASSET_CONCURRENCY);
     return Number.isSafeInteger(configured) && configured > 0 ? configured : DEFAULT_ASSET_CONCURRENCY;
 }
-async function processAsset(resource, options) {
-    const { auth, blueprintFileDir, installer, logger } = options;
+async function processAsset(resource, prepAsset, options) {
+    const { auth, blueprintFileDir, installer, fetchFn } = options;
     let assetTimeoutTimer;
     let result;
     try {
         result = await Promise.race([
-            stashAsset({ resource, blueprintFileDir, auth, logger, installer }),
+            stashAsset({ resource, prepAsset, blueprintFileDir, auth, fetchFn, installer }),
             new Promise((_, reject) => {
                 assetTimeoutTimer = setTimeout(() => {
                     reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
@@ -66,15 +66,17 @@ async function processAsset(resource, options) {
     if (result.success && result.assetId) {
         return {
             success: true,
-            resource: { ...resource, src: result.assetId },
+            resource: { ...resource, [result.assetParameter]: result.assetId },
+            assetParameter: result.assetParameter,
             hash: result.hash,
             exists: result.exists,
+            metadata: result.metadata,
         };
     }
     return {
         success: false,
         resource,
-        error: result.error || 'Failed to process asset',
+        error: ('error' in result && result.error) || 'Failed to process asset',
         failureKind: 'upload',
     };
 }

package/dist/actions/blueprints/stacks.d.ts

@@ -25,10 +25,10 @@ type GetStackResponse = {
     stack?: unknown;
     response?: Response;
 };
-export declare function getStack({ stackId, auth, logger, }: {
+export declare function getStack({ stackId, auth, fetchFn, }: {
     stackId: string;
     auth: AuthParams;
-    logger: Logger;
+    fetchFn: typeof fetch;
 }): Promise<GetStackResponse>;
 type CreateStackResponse = GetStackResponse;
 export declare function createStack({ stackMutation, auth, logger, }: {
@@ -55,11 +55,11 @@ type UpdateStackResponse = {
     error: string;
     stack?: unknown;
 };
-export declare function updateStack({ stackId, stackMutation, auth, logger, }: {
+export declare function updateStack({ stackId, stackMutation, auth, fetchFn, }: {
     stackId: string;
     stackMutation: StackMutation;
     auth: AuthParams;
-    logger: Logger;
+    fetchFn: typeof fetch;
 }): Promise<UpdateStackResponse>;
 interface PlanResourceSnapshot {
     name: string;

package/dist/actions/blueprints/stacks.js

@@ -24,8 +24,7 @@ export async function listStacks(auth, logger) {
         };
     }
 }
-export async function getStack({ stackId, auth, logger, }) {
-    const fetchFn = createTracedFetch(logger);
+export async function getStack({ stackId, auth, fetchFn, }) {
     try {
         const response = await fetchFn(`${stacksUrl}/${stackId}`, {
             method: 'GET',
@@ -92,8 +91,7 @@ export async function createEmptyStack({ token, scopeType, scopeId, name, logger
     }
     return response.stack;
 }
-export async function updateStack({ stackId, stackMutation, auth, logger, }) {
-    const fetchFn = createTracedFetch(logger);
+export async function updateStack({ stackId, stackMutation, auth, fetchFn, }) {
     try {
         const response = await fetchFn(`${stacksUrl}/${stackId}`, {
             method: 'PUT',

package/dist/actions/blueprints/wait-for-operation.d.ts

@@ -1,15 +1,6 @@
+import { type OperationOutcome } from '../../utils/blueprints/wait-for.js';
 import type { Logger } from '../../utils/logger.js';
 import type { AuthParams } from '../../utils/types.js';
-/** Result of waiting for a deploy/destroy operation to settle. */
-export type OperationOutcome = {
-    type: 'completed';
-} | {
-    type: 'failed';
-    logHints: string[];
-} | {
-    type: 'unconfirmed';
-    error?: string;
-};
 export interface WaitForOperationOptions {
     stackId: string;
     operationId: string;

package/dist/actions/blueprints/wait-for-operation.js

@@ -1,10 +1,7 @@
-import { setTimeout as sleep } from 'node:timers/promises';
-import { createHintCollector } from '../../utils/blueprints/hints.js';
-import { runCommand } from '../../utils/package-manager.js';
+import { createWaitFor } from '../../utils/blueprints/wait-for.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { setupLogPolling } from './logs-polling.js';
-import { classifyOperationPoll, getOperation, OPERATION_POLL_INITIAL_DELAY_MS, OPERATION_POLL_INTERVAL_MS, OPERATION_POLL_MAX_CONSECUTIVE_ERRORS, } from './operations.js';
-const IDLE_SPINNER_DELAY_MS = 30_000;
-const IDLE_SPINNER_UPDATE_INTERVAL_MS = 15_000;
+import { classifyOperationPoll, getOperation } from './operations.js';
 /**
  * Stream logs and poll an operation until it settles.
  * handles log-stream lifecycle, retry budget, and idle messaging;
@@ -12,107 +9,65 @@ const IDLE_SPINNER_UPDATE_INTERVAL_MS = 15_000;
  */
 export async function waitForOperation(options) {
     const { stackId, operationId, auth, log, bin, verbose = false, includeDestroyed, progressNoun, } = options;
-    const logHints = createHintCollector(bin);
-    let logStreamCleanup = null;
-    let idleSpinner;
-    const stopIdleSpinner = (restoreOperationProgress = false) => {
-        if (!idleSpinner)
-            return;
-        idleSpinner.stop();
-        idleSpinner = undefined;
-        if (restoreOperationProgress)
-            log.showProgress();
-    };
-    try {
-        log.showProgress();
-        let lastLogAt = Date.now();
-        let nextIdleSpinnerUpdateAt = IDLE_SPINNER_DELAY_MS;
-        let consecutiveErrors = 0;
-        let lastStatus;
-        logStreamCleanup = setupLogPolling({
-            stackId,
-            operationId,
-            auth,
-            log,
-            verbose,
-            onActivity: () => {
-                lastLogAt = Date.now();
-                nextIdleSpinnerUpdateAt = IDLE_SPINNER_DELAY_MS;
-                stopIdleSpinner(true);
-            },
-            onLogEntry: (logEntry) => logHints.inspectLog(logEntry),
-        });
-        // balk in case read replica lags
-        await sleep(OPERATION_POLL_INITIAL_DELAY_MS);
-        while (true) {
-            const { ok, error: pollError, operation, response, } = await getOperation({
+    const fetchFn = createTracedFetch(log);
+    const waitFor = createWaitFor({
+        bin,
+        log,
+        verbose,
+    });
+    return await waitFor({
+        async onRequestLatestState() {
+            const { ok, error, operation, response } = await getOperation({
                 stackId,
                 operationId,
                 auth,
-                logger: log,
+                fetchFn,
                 includeDestroyed,
             });
             const httpStatus = response?.status;
             const state = classifyOperationPoll({ ok, httpStatus, operation });
-            if (state === 'completed') {
-                if (logStreamCleanup)
-                    logStreamCleanup();
-                stopIdleSpinner();
-                log('');
-                return { type: 'completed' };
+            switch (state) {
+                case 'completed':
+                case 'failed':
+                    return {
+                        state,
+                    };
+                case 'error':
+                    return {
+                        state,
+                        error,
+                        verboseError: `Could not read ${progressNoun} status (HTTP ${httpStatus ?? 'unknown'}${error ? `: ${error}` : ''})`,
+                    };
+                case 'pending':
+                    if (httpStatus === 404 || !operation) {
+                        return {
+                            state: 'not_found',
+                            verboseError: `Waiting for ${progressNoun} status (HTTP 404); retrying.`,
+                        };
+                    }
+                    else {
+                        return {
+                            state,
+                            latestStatus: operation.status,
+                            verboseMessage: `${progressNoun} operation status: ${operation.status}.`,
+                        };
+                    }
+                default:
+                    throw new Error(`Unexpected poll state: ${state}`);
             }
-            if (state === 'failed') {
-                if (logStreamCleanup)
-                    logStreamCleanup();
-                stopIdleSpinner();
-                log('');
-                return { type: 'failed', logHints: logHints.getSuggestions() };
-            }
-            // tolerate a few consecutive errors; the operation was accepted and may still be running
-            if (state === 'error') {
-                consecutiveErrors += 1;
-                log.verbose(`Could not read ${progressNoun} status (HTTP ${httpStatus ?? 'unknown'}${pollError ? `: ${pollError}` : ''}); retrying (${consecutiveErrors}/${OPERATION_POLL_MAX_CONSECUTIVE_ERRORS}).`);
-                if (consecutiveErrors >= OPERATION_POLL_MAX_CONSECUTIVE_ERRORS) {
-                    if (logStreamCleanup)
-                        logStreamCleanup();
-                    stopIdleSpinner();
-                    log('');
-                    return { type: 'unconfirmed', error: pollError ?? undefined };
-                }
-            }
-            else {
-                consecutiveErrors = 0;
-                if (httpStatus === 404) {
-                    log.verbose(`Waiting for ${progressNoun} status (HTTP 404); retrying.`);
-                }
-                else if (operation && operation.status !== lastStatus) {
-                    log.verbose(`${progressNoun} operation status: ${operation.status}.`);
-                    lastStatus = operation.status;
-                }
-            }
-            const idleFor = Date.now() - lastLogAt;
-            if (idleFor >= nextIdleSpinnerUpdateAt) {
-                const elapsedIdleMs = IDLE_SPINNER_DELAY_MS +
-                    Math.floor((idleFor - IDLE_SPINNER_DELAY_MS) / IDLE_SPINNER_UPDATE_INTERVAL_MS) *
-                        IDLE_SPINNER_UPDATE_INTERVAL_MS;
-                const elapsedIdleSeconds = elapsedIdleMs / 1000;
-                const text = `No new activity for ${elapsedIdleSeconds} seconds. The ${progressNoun} is still running on Sanity servers. You can safely exit and check status later with \`${runCommand(bin)} blueprints info\`.`;
-                if (idleSpinner)
-                    idleSpinner.start(text);
-                else
-                    idleSpinner = log.ora(text).start();
-                nextIdleSpinnerUpdateAt = elapsedIdleMs + IDLE_SPINNER_UPDATE_INTERVAL_MS;
-            }
-            await sleep(OPERATION_POLL_INTERVAL_MS);
-        }
-    }
-    catch (error) {
-        if (logStreamCleanup)
-            logStreamCleanup();
-        throw error;
-    }
-    finally {
-        stopIdleSpinner();
-        log.clearProgress();
-    }
+        },
+        onStartLogPolling(options) {
+            return setupLogPolling({
+                stackId,
+                operationId,
+                auth,
+                fetchFn,
+                onActivity: options.onActivity,
+                onLogEntry: options.onLogEntry,
+            });
+        },
+        getIdleMessage() {
+            return `The ${progressNoun} is still running on Sanity servers.`;
+        },
+    });
 }

package/dist/baseCommands.js

@@ -9,6 +9,7 @@ import { CI_SETUP_DOCS_URL } from './constants.js';
 import { presentBlueprintParserErrors } from './utils/display/errors.js';
 import { Logger } from './utils/logger.js';
 import { styleText } from './utils/style-text.js';
+import { createTracedFetch } from './utils/traced-fetch.js';
 import { validTokenOrErrorMessage } from './utils/validated-token.js';
 /**
  * Fallback error-to-hint patterns for RuntimeCommand.catch().
@@ -378,7 +379,11 @@ export class ResolvedCommand extends RuntimeCommand {
         // 8. Deployed Stack
         if (needsDeployedStack) {
             const spinner = log.ora('Loading Stack deployment...').start();
-            const response = await getStack({ stackId: this.stackId, auth: this.auth, logger: log });
+            const response = await getStack({
+                stackId: this.stackId,
+                auth: this.auth,
+                fetchFn: createTracedFetch(log),
+            });
             if (!response.ok) {
                 spinner.fail('Could not load Stack deployment');
                 this.error('Missing Stack deployment', {

package/dist/commands/blueprints/deploy.js

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand, stackFlagConfig, } from '../../baseCommands.js';
+import { RUNTIME_CLI_NAME } from '../../config.js';
 import { blueprintDeployCore } from '../../cores/blueprints/deploy.js';
 import { Logger } from '../../utils/logger.js';
 import { INSTALLER_OPTIONS } from '../../utils/types.js';
@@ -79,6 +80,7 @@ Exit codes: 0 deployed, 2 deployment failed, 75 deployment accepted but completi
             scopeId: this.scopeId,
             deployedStack: this.deployedStack,
             blueprint: this.blueprint,
+            cliVersion: this.config.name === RUNTIME_CLI_NAME ? undefined : this.config.version,
             validateResources: this.flags['validate-resources'],
             flags: this.flags,
         });

package/dist/config.d.ts

@@ -17,6 +17,7 @@ declare const _default: {
     isLive: boolean;
     apiUrl: string;
     populusApiUrl: string;
+    studioDomain: string;
     isCi: boolean;
     token: string | null;
 };

package/dist/config.js

@@ -40,6 +40,11 @@ const apiUrls = {
     default: 'http://api.sanity/',
 };
 const apiUrl = sanityEnv ? (apiUrls[sanityEnv] ?? sanityEnv) : apiUrls.default;
+const studioDomains = {
+    production: 'sanity.studio',
+    staging: 'studio.sanity.work',
+};
+const studioDomain = studioDomains[sanityEnv] ?? studioDomains.production;
 // allow override of populus URL
 const populusApiUrl = env.POPULUS_API_URL ?? apiUrl;
 /**
@@ -78,6 +83,7 @@ export default {
     isLive,
     apiUrl,
     populusApiUrl,
+    studioDomain,
     isCi,
     get token() {
         return _token === undefined ? loadToken() : _token;

package/dist/constants.d.ts

@@ -51,6 +51,7 @@ export declare const LABEL_PUBSUB = "PubSub";
 export declare const LABEL_SCHEDULED = "Scheduled";
 export declare const LABEL_SYNC_TAG_INVALIDATE = "Sync Tag Invalidate";
 export declare const CI_SETUP_DOCS_URL = "https://www.sanity.io/docs/blueprints/deploy-blueprints-from-ci";
+export declare const STACKS_DOCS_URL = "https://www.sanity.io/docs/blueprints/stacks-and-scope";
 export declare const STEP_PHASE_GLYPH: Record<DurableStepPhase, string>;
 /** Stands in for environment variable values, which are never echoed back to the user */
 export declare const ENV_MASK = "********";

package/dist/constants.js

@@ -56,6 +56,7 @@ export const LABEL_PUBSUB = 'PubSub';
 export const LABEL_SCHEDULED = 'Scheduled';
 export const LABEL_SYNC_TAG_INVALIDATE = 'Sync Tag Invalidate';
 export const CI_SETUP_DOCS_URL = 'https://www.sanity.io/docs/blueprints/deploy-blueprints-from-ci';
+export const STACKS_DOCS_URL = 'https://www.sanity.io/docs/blueprints/stacks-and-scope';
 export const STEP_PHASE_GLYPH = {
     start: '▶',
     complete: '✔',

package/dist/cores/blueprints/config.js

@@ -1,6 +1,6 @@
+import { formatDateTime } from '@sanity/cli-core/dates';
 import { patchConfigFile, writeConfigFile, } from '../../actions/blueprints/config.js';
 import { resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
-import { formatDateTime } from '../../utils/display/dates.js';
 import { filePathRelativeToCwd, labeledId, warn } from '../../utils/display/presenters.js';
 import { CancelledError, runScopeAndStackWizard } from '../../utils/display/prompt.js';
 import { runCommand } from '../../utils/package-manager.js';

package/dist/cores/blueprints/deploy.d.ts

@@ -8,6 +8,8 @@ export interface BlueprintDeployOptions extends CoreConfig {
     scopeId: string;
     deployedStack: Stack;
     blueprint: ReadBlueprintResult;
+    /** Version of the CLI that hosts this plugin. Absent when the runtime CLI runs on its own. */
+    cliVersion?: string;
     flags: {
         'fn-installer'?: string;
         'no-wait'?: boolean;