@sanity/runtime-cli 11.2.5 → 12.0.1

package/dist/commands/blueprints/destroy.js

@@ -2,14 +2,14 @@ import { Flags } from '@oclif/core';
 import { BlueprintCommand } from '../../baseCommands.js';
 import { blueprintDestroyCore } from '../../cores/blueprints/destroy.js';
 export default class DestroyCommand extends BlueprintCommand {
-    static description = 'Destroy a Blueprint deployment (will not delete local files)';
+    static description = 'Destroy a Blueprint Stack deployment and its resources (will not delete local files)';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack-id <stackId> --project-id <projectId> --force --no-wait',
     ];
     static flags = {
         force: Flags.boolean({
-            description: 'Force destroy (skip confirmation)',
+            description: 'Force Stack destruction (skip confirmation)',
             aliases: ['f'],
             default: false,
         }),
@@ -28,7 +28,7 @@ export default class DestroyCommand extends BlueprintCommand {
             aliases: ['stackId', 'stack'],
         }),
         'no-wait': Flags.boolean({
-            description: 'Do not wait for destruction to complete',
+            description: 'Do not wait for Stack destruction to complete',
             default: false,
         }),
     };

package/dist/commands/blueprints/info.js

@@ -2,14 +2,14 @@ import { Flags } from '@oclif/core';
 import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { blueprintInfoCore } from '../../cores/blueprints/info.js';
 export default class InfoCommand extends DeployedBlueprintCommand {
-    static description = 'Show information about a Blueprint deployment';
+    static description = 'Show information about a Blueprint Stack deployment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack-id <stackId>',
     ];
     static flags = {
         id: Flags.string({
-            description: 'Stack ID to show info for (defaults to current stack)',
+            description: 'Stack ID to show info for (defaults to current Stack)',
         }),
     };
     async run() {

package/dist/commands/blueprints/init.d.ts

@@ -13,6 +13,7 @@ export default class InitCommand extends Command {
         'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/blueprints/init.js

@@ -48,6 +48,10 @@ export default class InitCommand extends Command {
             aliases: ['name'],
             exclusive: ['stack-id'],
         }),
+        verbose: Flags.boolean({
+            description: 'Verbose output',
+            default: false,
+        }),
     };
     async run() {
         const { args, flags } = await this.parse(InitCommand);

package/dist/commands/blueprints/logs.js

@@ -2,7 +2,7 @@ import { Flags } from '@oclif/core';
 import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { blueprintLogsCore } from '../../cores/blueprints/logs.js';
 export default class LogsCommand extends DeployedBlueprintCommand {
-    static description = 'Display logs for a Blueprint deployment';
+    static description = 'Display logs for a Blueprint Stack deployment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --watch',
@@ -10,7 +10,7 @@ export default class LogsCommand extends DeployedBlueprintCommand {
     static flags = {
         watch: Flags.boolean({
             char: 'w',
-            description: 'Watch for new logs (streaming mode)',
+            description: 'Watch for new Stack logs (streaming mode)',
             aliases: ['follow'],
         }),
     };

package/dist/commands/blueprints/plan.js

@@ -9,6 +9,7 @@ export default class PlanCommand extends BlueprintCommand {
             log: (message) => this.log(message),
             token: this.sanityToken,
             blueprint: this.blueprint,
+            flags: this.flags,
         });
         if (!success)
             this.error(error);

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 export declare const BLUEPRINT_CONFIG_VERSION = "v2025-05-08";
-export declare const BLUEPRINT_DIR = ".sanity";
+export declare const BLUEPRINT_CONFIG_DIR = ".sanity";
 export declare const BLUEPRINT_CONFIG_FILE = "blueprint.config.json";
+export declare let RUNTIME_CLI_VERSION: string | undefined;
 declare const _default: {
     isTest: boolean;
     apiUrl: string;

package/dist/config.js

@@ -1,8 +1,15 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { env } from 'node:process';
 import getToken from './utils/get-token.js';
 export const BLUEPRINT_CONFIG_VERSION = 'v2025-05-08';
-export const BLUEPRINT_DIR = '.sanity';
+export const BLUEPRINT_CONFIG_DIR = '.sanity';
 export const BLUEPRINT_CONFIG_FILE = 'blueprint.config.json';
+export let RUNTIME_CLI_VERSION;
+try {
+    RUNTIME_CLI_VERSION = JSON.parse(readFileSync(join(dirname(import.meta.url), '..', 'package.json'), 'utf8')).version;
+}
+catch { }
 const nodeEnv = env.NODE_ENV?.toLowerCase() ?? 'production';
 const isTest = nodeEnv === 'test';
 const sanityEnv = env.SANITY_INTERNAL_ENV?.toLowerCase() ?? 'production';

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

@@ -4,11 +4,11 @@ export interface BlueprintConfigOptions extends CoreConfig {
     token: string;
     blueprint: ReadBlueprintResult;
     flags: {
-        'test-config'?: boolean;
         edit?: boolean;
         'project-id'?: string;
         'organization-id'?: string;
         'stack-id'?: string;
+        verbose?: boolean;
     };
 }
 export declare function blueprintConfigCore(options: BlueprintConfigOptions): Promise<CoreResult>;

package/dist/cores/blueprints/config.js

@@ -1,89 +1,103 @@
 import { highlight } from 'cardinal';
 import chalk from 'chalk';
-import { writeConfigFile } from '../../actions/blueprints/config.js';
-import { BLUEPRINT_CONFIG_FILE, BLUEPRINT_DIR } from '../../config.js';
-import { capitalize, niceId, warn } from '../../utils/display/presenters.js';
-import { promptForProject } from '../../utils/display/prompt.js';
+import { patchConfigFile, writeConfigFile, } from '../../actions/blueprints/config.js';
+import { BLUEPRINT_CONFIG_DIR, BLUEPRINT_CONFIG_FILE } from '../../config.js';
+import { capitalize, filePathRelativeToCwd, niceId, warn } from '../../utils/display/presenters.js';
+import { promptForProject, promptForStack } from '../../utils/display/prompt.js';
 export async function blueprintConfigCore(options) {
-    const { bin = 'sanity', log, token, flags } = options;
-    const { edit: editConfig = false, 'test-config': testConfig = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, } = flags;
-    const { blueprint } = options;
-    const { stackId: configStackId, scopeType: configScopeType, scopeId: configScopeId } = blueprint;
-    try {
-        if (!configStackId && !configScopeType && !configScopeId) {
-            log(warn('Incomplete configuration.'));
-            if (!editConfig) {
-                // blueprint.json exists but no config JSON
-                log(`Run \`${bin} blueprints doctor\` for diagnostics.`);
-                return { success: true }; // not necessarily fatal
-            }
+    const { bin = 'sanity', blueprint, log, token, flags } = options;
+    const { edit: editConfig = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, verbose: v = false, } = flags;
+    const { stackId: configStackId, scopeType: configScopeType, scopeId: configScopeId, blueprintConfig, fileInfo, } = blueprint;
+    const blueprintFilePath = fileInfo.blueprintFilePath;
+    const configPath = blueprintConfig?.configPath;
+    if (!configStackId && !configScopeType && !configScopeId) {
+        log(warn('Incomplete configuration.'));
+        if (!editConfig) {
+            // blueprint.json exists but no config JSON
+            log(`Run \`${bin} blueprints doctor\` for diagnostics.`);
+            return { success: true }; // not necessarily fatal
         }
-        log(chalk.bold('Current configuration:'));
-        log(`  Blueprint scoped to: ${chalk.blue(capitalize(configScopeType || 'unknown'))} ${niceId(configScopeId || 'unknown')}`);
-        log(`  Deployment ID:  ${niceId(configStackId || 'unknown')}`);
-        // passing new config without --edit flag is not allowed
-        if ((flagProjectId || flagOrganizationId || flagStackId) && !editConfig) {
-            log('To update the configuration, use the --edit flag.');
+    }
+    log(chalk.bold('Current Blueprint configuration:'));
+    if (configPath) {
+        if (v)
+            log(`        File: ${filePathRelativeToCwd(configPath)}`);
+    }
+    log(`  Deployment: ${chalk.blue('Stack')} ${niceId(configStackId || 'unknown')}`);
+    log(`   Scoped to: ${chalk.blue(capitalize(configScopeType || 'unknown'))} ${niceId(configScopeId || 'unknown')}`);
+    if (blueprintConfig?.updatedAt) {
+        if (v)
+            log(`     Updated: ${new Date(blueprintConfig.updatedAt).toLocaleString()}`);
+    }
+    // passing new config without --edit flag is not allowed
+    if ((flagProjectId || flagOrganizationId || flagStackId) && !editConfig) {
+        log('To update the configuration, use the --edit flag.');
+        return { success: true };
+    }
+    if (!editConfig) {
+        // no edit; return success early
+        return { success: true };
+    }
+    else {
+        // if a config property flag was passed, set the value and return success
+        // do not try to validate correctness of combined flags; this should not be interactive
+        const providedConfigFlag = [flagProjectId, flagStackId, flagOrganizationId].some(Boolean);
+        if (providedConfigFlag) {
+            const configUpdate = {};
+            if (flagProjectId)
+                configUpdate.projectId = flagProjectId;
+            if (flagStackId)
+                configUpdate.stackId = flagStackId;
+            if (flagOrganizationId)
+                configUpdate.organizationId = flagOrganizationId;
+            try {
+                patchConfigFile(blueprintFilePath, configUpdate);
+            }
+            catch {
+                return { success: false, error: 'Unable to update configuration.' };
+            }
+            log('\nConfiguration updated.');
             return { success: true };
         }
-        // no edit or test: return success
-        if (!editConfig && !testConfig)
+        // organization-based Blueprints are not yet supported for interactive editing
+        if (configScopeType === 'organization') {
+            return { success: false, error: 'Only project-based Blueprints are supported.' };
+        }
+        // otherwise, prompt for values interactively
+        let updatedProjectId = flagProjectId;
+        if (!updatedProjectId) {
+            const pickedProject = await promptForProject({
+                token,
+                knownProjectId: configScopeId,
+            });
+            updatedProjectId = pickedProject.projectId;
+        }
+        if (!updatedProjectId)
+            return { success: false, error: 'Project ID is required.' };
+        let updatedStackId = flagStackId;
+        if (!updatedStackId) {
+            const pickedStack = await promptForStack({ projectId: updatedProjectId, token });
+            updatedStackId = pickedStack.stackId;
+        }
+        if (!updatedStackId)
+            return { success: false, error: 'Stack is required.' };
+        try {
+            // update or create config JSON
+            writeConfigFile({ blueprintFilePath, projectId: updatedProjectId, stackId: updatedStackId });
+            log(`\n${chalk.bold('New configuration:')}`);
+            log(`  Deployment: ${chalk.blue('Stack')} ${niceId(updatedStackId)}`);
+            log(`   Scoped to: ${chalk.blue('Project')} ${niceId(updatedProjectId)}`);
+            log('');
+            log('Configuration updated.');
             return { success: true };
-        // warn about deprecated test-config flag
-        if (testConfig) {
-            log(warn(`The "test" flag is deprecated. Use "${bin} blueprints doctor" instead.`));
         }
-        // editing...
-        if (editConfig) {
-            if (configScopeType === 'project') {
-                // maintain original project-based flow
-                const updatedProjectId = flagProjectId ||
-                    (await promptForProject({
-                        token,
-                        knownProjectId: configScopeId,
-                    })).projectId;
-                if (!updatedProjectId) {
-                    return {
-                        success: false,
-                        error: 'Project ID is required.',
-                    };
-                }
-                // LAUNCH LIMIT: 1 Stack per Project - configStackId is always inferred from projectId if not set in config JSON
-                let updatedStackId = flagStackId ?? // flag first
-                    configStackId ?? // existing config second
-                    `ST-${updatedProjectId}`; //?? LAUNCH LIMIT: 1 Stack per Project - project-based third
-                // (await promptForStackId({projectId: updatedProjectId, knownStackId: configStackId})) // prompt for stackId
-                const isProjectBasedId = updatedStackId === `ST-${updatedProjectId}`;
-                log(`\n${chalk.bold('New configuration:')}`);
-                log(`  Blueprint scoped to: ${chalk.blue(capitalize(configScopeType))} ${niceId(updatedProjectId)}`);
-                log(`  Deployment ID:  ${niceId(updatedStackId)}`);
-                // LAUNCH LIMIT: 1 Stack per Project - do not set Stack ID if it's project-based
-                if (isProjectBasedId)
-                    updatedStackId = undefined;
-                try {
-                    // update or create config JSON
-                    writeConfigFile({ projectId: updatedProjectId, stackId: updatedStackId });
-                    log('Configuration updated successfully.');
-                    return { success: true };
-                }
-                catch {
-                    log(`Unable to update config. These values should be set in ${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`);
-                    log(highlight(JSON.stringify({ metadata: { projectId: updatedProjectId, stackId: updatedStackId } }, null, 2)));
-                    return {
-                        success: false,
-                        error: `Be sure to update your ${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`,
-                    };
-                }
-            }
-            else {
-                log(warn('Only project-based Blueprints are currently supported.'));
-                return { success: false, error: 'Only project-based Blueprints are supported.' };
-            }
+        catch {
+            log(`Unable to update config. These values should be set in ${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`);
+            log(highlight(JSON.stringify({ metadata: { projectId: updatedProjectId, stackId: updatedStackId } }, null, 2)));
+            return {
+                success: false,
+                error: `Be sure to update your ${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`,
+            };
         }
-        // Default return (shouldn't reach here with proper flow control)
-        return { success: true };
-    }
-    catch {
-        return { success: false, error: 'Unknown error' };
     }
 }

package/dist/cores/blueprints/deploy.js

@@ -64,16 +64,16 @@ export async function blueprintDeployCore(options) {
             auth,
         });
         if (!deployOk) {
-            spinner.fail(`${chalk.red('Failed')} to update deployment`);
-            return { success: false, error: deployError || 'Failed to update deployment' };
+            spinner.fail(`${chalk.red('Failed')} to update Stack deployment`);
+            return { success: false, error: deployError || 'Failed to update Stack deployment' };
         }
         spinner.stop().clear();
         if (noWait) {
-            log(chalk.bold.green('Deployment started!'));
+            log(chalk.bold.green('Stack deployment started!'));
             log(`Use \`${bin} blueprints info\` to check status`);
             return { success: true, data: { resources } };
         }
-        log(chalk.dim('Deployment progress:'));
+        log(chalk.dim('Stack deployment progress:'));
         let logStreamCleanup = null;
         try {
             logStreamCleanup = await setupLogStreaming({
@@ -87,23 +87,23 @@ export async function blueprintDeployCore(options) {
                 if (!ok) {
                     if (logStreamCleanup)
                         logStreamCleanup();
-                    return { success: false, error: 'Failed to check deployment status' };
+                    return { success: false, error: 'Failed to check Stack deployment status' };
                 }
                 const operation = currentStack.recentOperation;
                 if (!operation) {
                     if (logStreamCleanup)
                         logStreamCleanup();
-                    return { success: false, error: 'No deployment operation found' };
+                    return { success: false, error: 'No Stack deployment operation found' };
                 }
                 if (operation.status === 'FAILED') {
                     if (logStreamCleanup)
                         logStreamCleanup();
-                    return { success: false, error: 'Deployment failed' };
+                    return { success: false, error: 'Stack deployment failed' };
                 }
                 if (operation.status === 'COMPLETED') {
                     if (logStreamCleanup)
                         logStreamCleanup();
-                    log(chalk.bold.green('Deployment completed!'));
+                    log(chalk.bold.green('Stack deployment completed!'));
                     return { success: true, data: { resources } };
                 }
                 await setTimeout(1500);

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

@@ -9,6 +9,7 @@ export interface BlueprintDestroyOptions extends CoreConfig {
         'organization-id'?: string;
         'stack-id'?: string;
         'no-wait'?: boolean;
+        verbose?: boolean;
     };
 }
 export declare function blueprintDestroyCore(options: BlueprintDestroyOptions): Promise<CoreResult>;

package/dist/cores/blueprints/destroy.js

@@ -1,13 +1,13 @@
 import { setTimeout } from 'node:timers/promises';
+import { confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
 import ora from 'ora';
 import { setupLogStreaming } from '../../actions/blueprints/logs-streaming.js';
 import { destroyStack, getStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintDestroyCore(options) {
     const { log, token, blueprint, flags } = options;
-    const { force = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'no-wait': noWait = false, } = flags;
+    const { force = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'no-wait': noWait = false, verbose: _verbose = false, } = flags;
     // 3-flag combo: just destroy it
     if ((flagProjectId || flagOrganizationId) && flagStackId && force) {
         let scopeType;
@@ -28,8 +28,8 @@ export async function blueprintDestroyCore(options) {
             auth: { token, scopeType, scopeId },
         });
         if (!ok)
-            return { success: false, error: error || 'Failed to destroy deployment' };
-        log(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
+            return { success: false, error: error || 'Failed to destroy Stack deployment' };
+        log(`Stack deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
         return { success: true };
     }
     const { scopeType, scopeId, stackId } = blueprint;
@@ -41,42 +41,38 @@ export async function blueprintDestroyCore(options) {
         if (flagStackId) {
             const flagStack = await getStack({ stackId: flagStackId, auth });
             if (!flagStack.ok)
-                return { success: false, error: flagStack.error || 'Failed to get stack' };
+                return { success: false, error: flagStack.error || 'Failed to get Stack' };
             stack = flagStack.stack;
         }
         else if (stackId) {
             const blueprintStack = await getStack({ stackId, auth });
             if (!blueprintStack.ok)
-                return { success: false, error: blueprintStack.error || 'Failed to get stack' };
+                return { success: false, error: blueprintStack.error || 'Failed to get Stack' };
             stack = blueprintStack.stack;
         }
         if (!stack)
-            return { success: false, error: 'Deployment not found' };
+            return { success: false, error: 'Stack deployment not found' };
         const destroySpinner = ora({
-            text: `Destroying ${chalk.bold(stack.name)} ${niceId(stack.id)}...`,
+            text: `Destroying Stack deployment "${chalk.bold(stack.name)}" ${niceId(stack.id)}...`,
             color: 'red',
         });
         if (!force) {
-            const { confirm } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirm',
-                    message: `Are you sure you want to destroy stack "${stack.name}" ${niceId(stack.id)}?`,
-                    default: false,
-                },
-            ]);
-            if (!confirm) {
-                log('Deployment destruction cancelled');
+            const confirmed = await confirm({
+                message: `Are you sure you want to destroy stack "${stack.name}" ${niceId(stack.id)}?`,
+                default: false,
+            });
+            if (!confirmed) {
+                log('Stack deployment destruction cancelled');
                 return { success: true };
             }
             destroySpinner.start();
             // 5 second countdown
             let i = 5;
             while (i >= 0) {
-                destroySpinner.text = `Destroying deployment in ${chalk.bold((i--).toString())} seconds...`;
+                destroySpinner.text = `Destroying Stack deployment in ${chalk.bold((i--).toString())} seconds...`;
                 await setTimeout(1000);
             }
-            destroySpinner.text = 'Destroying deployment 💥';
+            destroySpinner.text = 'Destroying Stack deployment 💥';
             await setTimeout(500);
         }
         else {
@@ -85,15 +81,15 @@ export async function blueprintDestroyCore(options) {
         const isoNow = new Date().toISOString();
         const { ok, error } = await destroyStack({ stackId: stack.id, auth });
         if (!ok) {
-            destroySpinner.fail('Failed to destroy deployment');
-            return { success: false, error: error || 'Failed to destroy deployment' };
+            destroySpinner.fail('Failed to destroy Stack deployment');
+            return { success: false, error: error || 'Failed to destroy Stack deployment' };
         }
         destroySpinner.stop().clear();
         if (noWait) {
-            log(chalk.bold.magenta('Destruction started!'));
+            log(chalk.bold.magenta('Stack destruction started!'));
             return { success: true };
         }
-        log(chalk.dim('Destruction progress:'));
+        log(chalk.dim('Stack destruction progress:'));
         let logStreamCleanup = null;
         try {
             logStreamCleanup = await setupLogStreaming({
@@ -110,13 +106,13 @@ export async function blueprintDestroyCore(options) {
                     // it's possible that the operation is "gone" or available and "COMPLETED"
                     if (logStreamCleanup)
                         logStreamCleanup();
-                    log(chalk.bold.magenta('Destruction completed!'));
+                    log(chalk.bold.magenta('Stack destruction completed!'));
                     return { success: true };
                 }
                 if (operation.status === 'FAILED') {
                     if (logStreamCleanup)
                         logStreamCleanup();
-                    return { success: false, error: 'Destruction failed' };
+                    return { success: false, error: 'Stack destruction failed' };
                 }
                 await setTimeout(1500);
             }