@sanity/runtime-cli 14.0.0 → 14.1.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity-run COMMAND
 running command...
 $ sanity-run (--version)
-@sanity/runtime-cli/14.0.0 linux-x64 node-v24.13.0
+@sanity/runtime-cli/14.1.0 linux-x64 node-v24.13.1
 $ sanity-run --help [COMMAND]
 USAGE
   $ sanity-run COMMAND
@@ -98,7 +98,7 @@ EXAMPLES
   $ sanity-run blueprints add function --name my-function --fn-type document-create --fn-type document-update --lang js
 ```
 
-_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/add.ts)_
+_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/add.ts)_
 
 ## `sanity-run blueprints config`
 
@@ -133,7 +133,7 @@ EXAMPLES
   $ sanity-run blueprints config --edit --project-id <projectId> --stack <name-or-id>
 ```
 
-_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/config.ts)_
+_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/config.ts)_
 
 ## `sanity-run blueprints deploy`
 
@@ -158,13 +158,15 @@ DESCRIPTION
 
   Use --no-wait to queue the deployment and return immediately without waiting for completion.
 
+  Set SANITY_ASSET_TIMEOUT (seconds) to override the 60-second timeout for processing resource assets.
+
 EXAMPLES
   $ sanity-run blueprints deploy
 
   $ sanity-run blueprints deploy --no-wait
 ```
 
-_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/deploy.ts)_
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/deploy.ts)_
 
 ## `sanity-run blueprints destroy`
 
@@ -196,7 +198,7 @@ EXAMPLES
   $ sanity-run blueprints destroy --stack <name-or-id> --project-id <projectId> --force --no-wait
 ```
 
-_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/destroy.ts)_
+_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/destroy.ts)_
 
 ## `sanity-run blueprints doctor`
 
@@ -210,7 +212,7 @@ FLAGS
   -p, --path=<value>  [env: SANITY_BLUEPRINT_PATH] Path to a Blueprint file or directory containing one
       --fix           Interactively fix configuration issues
       --json          Format output as json.
-      --verbose       Verbose output
+      --[no-]verbose  Verbose output; defaults to true
 
 DESCRIPTION
   Diagnose potential issues with local Blueprint and remote Stack configuration
@@ -222,7 +224,7 @@ DESCRIPTION
   issues.
 ```
 
-_See code: [src/commands/blueprints/doctor.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/doctor.ts)_
+_See code: [src/commands/blueprints/doctor.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/doctor.ts)_
 
 ## `sanity-run blueprints info`
 
@@ -252,7 +254,7 @@ EXAMPLES
   $ sanity-run blueprints info --stack <name-or-id>
 ```
 
-_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/info.ts)_
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/info.ts)_
 
 ## `sanity-run blueprints init [DIR]`
 
@@ -302,7 +304,7 @@ EXAMPLES
   $ sanity-run blueprints init --blueprint-type <json|js|ts> --stack-name <stackName>
 ```
 
-_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/init.ts)_
+_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/init.ts)_
 
 ## `sanity-run blueprints logs`
 
@@ -331,7 +333,7 @@ EXAMPLES
   $ sanity-run blueprints logs --watch
 ```
 
-_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/logs.ts)_
+_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/logs.ts)_
 
 ## `sanity-run blueprints plan`
 
@@ -357,7 +359,7 @@ EXAMPLES
   $ sanity-run blueprints plan
 ```
 
-_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/plan.ts)_
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/plan.ts)_
 
 ## `sanity-run blueprints stacks`
 
@@ -386,7 +388,7 @@ EXAMPLES
   $ sanity-run blueprints stacks --organization-id <organizationId>
 ```
 
-_See code: [src/commands/blueprints/stacks.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/blueprints/stacks.ts)_
+_See code: [src/commands/blueprints/stacks.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/blueprints/stacks.ts)_
 
 ## `sanity-run functions add`
 
@@ -435,7 +437,7 @@ EXAMPLES
   $ sanity-run functions add --name my-function --type document-create --type document-update --lang js
 ```
 
-_See code: [src/commands/functions/add.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/add.ts)_
+_See code: [src/commands/functions/add.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/add.ts)_
 
 ## `sanity-run functions dev`
 
@@ -469,7 +471,7 @@ EXAMPLES
   $ sanity-run functions dev --timeout 60
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/dev.ts)_
 
 ## `sanity-run functions env add NAME KEY VALUE`
 
@@ -496,7 +498,7 @@ EXAMPLES
   $ sanity-run functions env add MyFunction API_URL https://api.example.com/
 ```
 
-_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/env/add.ts)_
+_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/env/add.ts)_
 
 ## `sanity-run functions env list NAME`
 
@@ -520,7 +522,7 @@ EXAMPLES
   $ sanity-run functions env list MyFunction
 ```
 
-_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/env/list.ts)_
+_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/env/list.ts)_
 
 ## `sanity-run functions env remove NAME KEY`
 
@@ -546,7 +548,7 @@ EXAMPLES
   $ sanity-run functions env remove MyFunction API_URL
 ```
 
-_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/env/remove.ts)_
+_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/env/remove.ts)_
 
 ## `sanity-run functions logs [NAME]`
 
@@ -586,7 +588,7 @@ EXAMPLES
   $ sanity-run functions logs <name> --delete
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/logs.ts)_
 
 ## `sanity-run functions test [NAME]`
 
@@ -640,7 +642,7 @@ EXAMPLES
   $ sanity-run functions test <name> --event update --data-before '{ "title": "before" }' --data-after '{ "title": "after" }'
 ```
 
-_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v14.0.0/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v14.1.0/src/commands/functions/test.ts)_
 
 ## `sanity-run help [COMMAND]`
 

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

@@ -16,7 +16,7 @@ export interface LocatedBlueprintsConfig extends BlueprintsConfig {
 export declare function readConfigFile(blueprintFilePath?: string): LocatedBlueprintsConfig | null;
 /**
  * Create or update the config file to disk.
- * One of organizationId or projectId must be provided. Not both.
+ * One of organizationId or projectId must be provided.
  * Blueprint config version and updatedAt timestamp are set automatically.
  * @param options - the options to write the config file
  * @param options.blueprintFilePath - the path to the blueprint file
@@ -26,13 +26,9 @@ export declare function readConfigFile(blueprintFilePath?: string): LocatedBluep
  */
 export declare function writeConfigFile(blueprintFilePath: string, options: {
     stackId?: string;
-} & ({
-    organizationId: string;
-    projectId?: string;
-} | {
-    projectId: string;
     organizationId?: string;
-})): BlueprintsConfig;
+    projectId?: string;
+}): BlueprintsConfig;
 /**
  * Update the config file with the given properties.
  * Config file must already exist.

package/dist/actions/blueprints/config.js

@@ -20,7 +20,7 @@ export function readConfigFile(blueprintFilePath) {
 }
 /**
  * Create or update the config file to disk.
- * One of organizationId or projectId must be provided. Not both.
+ * One of organizationId or projectId must be provided.
  * Blueprint config version and updatedAt timestamp are set automatically.
  * @param options - the options to write the config file
  * @param options.blueprintFilePath - the path to the blueprint file

package/dist/actions/blueprints/logs-streaming.d.ts

@@ -7,6 +7,7 @@ export interface LogStreamingConfig {
     showBanner?: boolean;
     verbose?: boolean;
     log: ReturnType<typeof Logger>;
+    onActivity?: () => void;
 }
 export interface StreamLogsOptions {
     stackId: string;

package/dist/actions/blueprints/logs-streaming.js

@@ -79,6 +79,7 @@ export async function setupLogStreaming(config) {
         if (!isNewerLog(logEntry, newestTimestamp))
             return;
         newestTimestamp = new Date(logEntry.timestamp).getTime();
+        config.onActivity?.();
         log(formatLogEntry(logEntry, verbose, previousLog));
         previousLog = logEntry;
     };

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

@@ -1,3 +1,4 @@
+import type { Blueprint } from '@sanity/blueprints-parser';
 import type { Logger } from '../../utils/logger.js';
 import type { AuthParams, ScopeType, Stack, StackMutation } from '../../utils/types.js';
 export declare const stacksUrl: string;
@@ -50,6 +51,56 @@ export declare function updateStack({ stackId, stackMutation, auth, logger, }: {
     auth: AuthParams;
     logger: ReturnType<typeof Logger>;
 }): Promise<UpdateStackResponse>;
+interface PlanResourceSnapshot {
+    name: string;
+    type: string;
+    parameters: Record<string, unknown>;
+}
+export interface PlanActionDetails {
+    name: string;
+    type: string;
+    parameters?: Record<string, unknown>;
+    existingResource?: PlanResourceSnapshot & {
+        id: string;
+        externalId?: string;
+    };
+    updatedResource?: PlanResourceSnapshot;
+}
+export interface DeploymentPlanAction {
+    type: 'create' | 'update' | 'destroy' | 'skip' | 'attach' | 'detach';
+    resourceType: string;
+    details: PlanActionDetails | null;
+}
+export interface DeploymentPlan {
+    plan: DeploymentPlanAction[];
+    summary: {
+        createCount: number;
+        updateCount: number;
+        destroyCount: number;
+        skipCount: number;
+        attachCount: number;
+        detachCount: number;
+    };
+}
+type PlanStackResponse = {
+    ok: true;
+    error: null;
+    problems: null;
+    deploymentPlan: DeploymentPlan;
+} | {
+    ok: false;
+    error: string;
+    problems: {
+        message: string;
+    }[] | null;
+    deploymentPlan: null;
+};
+export declare function planStack({ stackId, document, auth, logger, }: {
+    stackId: string;
+    document: Blueprint;
+    auth: AuthParams;
+    logger: ReturnType<typeof Logger>;
+}): Promise<PlanStackResponse>;
 interface DestroyStackResponse {
     ok: boolean;
     error: string | null;

package/dist/actions/blueprints/stacks.js

@@ -75,6 +75,24 @@ export async function updateStack({ stackId, stackMutation, auth, logger, }) {
         stack: data,
     };
 }
+export async function planStack({ stackId, document, auth, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${stacksUrl}/${stackId}/plan`, {
+        method: 'POST',
+        headers: getHeaders(auth),
+        body: JSON.stringify({ document }),
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: data.message || 'Failed to retrieve deployment plan',
+            problems: response.status === 400 && Array.isArray(data.problems) ? data.problems : null,
+            deploymentPlan: null,
+        };
+    }
+    return { ok: true, error: null, problems: null, deploymentPlan: data };
+}
 export async function resolveStackIdByNameOrId(value, auth, logger) {
     if (value.startsWith('ST-') && value.length === 13)
         return value;

package/dist/commands/blueprints/deploy.js

@@ -8,7 +8,9 @@ export default class DeployCommand extends DeployedStackCommand {
 
 Before deploying, run 'blueprints plan' to preview changes. After deployment, use 'blueprints info' to verify Stack status or 'blueprints logs' to monitor activity.
 
-Use --no-wait to queue the deployment and return immediately without waiting for completion.`;
+Use --no-wait to queue the deployment and return immediately without waiting for completion.
+
+Set SANITY_ASSET_TIMEOUT (seconds) to override the 60-second timeout for processing resource assets.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --no-wait',

package/dist/commands/blueprints/doctor.js

@@ -17,7 +17,11 @@ Run this command when encountering errors with other Blueprint commands. Use --f
             default: false,
         }),
         json: unhide(baseFlags.json),
-        verbose: unhide(baseFlags.verbose),
+        verbose: Flags.boolean({
+            description: 'Verbose output; defaults to true',
+            default: true,
+            allowNo: true,
+        }),
     };
     async run() {
         const { token } = config;

package/dist/cores/blueprints/config.js

@@ -53,7 +53,16 @@ export async function blueprintConfigCore(options) {
                 return { success: true };
             }
             catch {
-                return { success: false, error: 'Unable to update configuration.' };
+                // fallback to writeConfigFile if patchConfigFile fails
+                // creates a new config file with the given properties
+                try {
+                    const newConfig = writeConfigFile(blueprintFilePath, configUpdate);
+                    printConfig({ configLabel: 'Updated', log, config: newConfig });
+                    return { success: true };
+                }
+                catch {
+                    return { success: false, error: 'Unable to update configuration.' };
+                }
             }
         }
         // prompt for values interactively

package/dist/cores/blueprints/deploy.js

@@ -1,10 +1,14 @@
-import { setTimeout } from 'node:timers/promises';
+import { setTimeout as sleep } from 'node:timers/promises';
 import { stashAsset } from '../../actions/blueprints/assets.js';
 import { setupLogStreaming } from '../../actions/blueprints/logs-streaming.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
 import { isLocalFunctionCollection, isLocalFunctionResource } from '../../utils/types.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;
@@ -33,7 +37,26 @@ export async function blueprintDeployCore(options) {
             log('Processing function assets...');
             for (const resource of allFunctionResources) {
                 const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
-                const result = await stashAsset({ resource, auth, logger: log });
+                const warnTimer = setTimeout(() => {
+                    fnSpinner.text = `Still processing ${resource.name}, this can take a moment...`;
+                }, warnTimeoutMs);
+                let result;
+                try {
+                    result = await Promise.race([
+                        stashAsset({ resource, auth, logger: log }),
+                        sleep(assetTimeoutMs).then(() => {
+                            throw new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`);
+                        }),
+                    ]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    fnSpinner.fail(msg);
+                    return { success: false, error: msg };
+                }
+                finally {
+                    clearTimeout(warnTimer);
+                }
                 if (result.success && result.assetId) {
                     resource.src = result.assetId;
                     if (isLocalFunctionCollection(resource)) {
@@ -102,12 +125,17 @@ export async function blueprintDeployCore(options) {
         log(styleText('dim', 'Stack deployment progress:'));
         let logStreamCleanup = null;
         try {
+            let lastLogAt = Date.now();
+            let idleMessageShown = false;
             logStreamCleanup = await setupLogStreaming({
                 stackId: stack.id,
                 after: isoNow,
                 auth,
                 log,
                 verbose,
+                onActivity: () => {
+                    lastLogAt = Date.now();
+                },
             });
             while (true) {
                 const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth, logger: log });
@@ -133,7 +161,12 @@ export async function blueprintDeployCore(options) {
                     log(styleText(['bold', 'green'], 'Stack deployment completed!'));
                     return { success: true, data: { resources } };
                 }
-                await setTimeout(1500);
+                if (!idleMessageShown && Date.now() - lastLogAt > 60_000) {
+                    log(`No new activity for 60 seconds. The deployment is still running on Sanity servers.`);
+                    log(`You can safely exit and check status later with \`${bin} blueprints info\`.`);
+                    idleMessageShown = true;
+                }
+                await sleep(1500);
             }
         }
         catch (error) {

package/dist/cores/blueprints/destroy.js

@@ -1,11 +1,11 @@
-import { setTimeout } from 'node:timers/promises';
+import { setTimeout as sleep } from 'node:timers/promises';
 import { confirm } from '@inquirer/prompts';
 import { setupLogStreaming } from '../../actions/blueprints/logs-streaming.js';
 import { destroyStack, getStack, resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
 export async function blueprintDestroyCore(options) {
-    const { log, token, blueprint, flags } = options;
+    const { bin = 'sanity', log, token, blueprint, flags } = options;
     const { force = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, stack: flagStack, 'no-wait': noWait = false, verbose: _verbose = false, } = flags;
     // 3-flag combo: just destroy it
     if ((flagProjectId || flagOrganizationId) && flagStack && force) {
@@ -75,10 +75,10 @@ export async function blueprintDestroyCore(options) {
             let i = 5;
             while (i >= 0) {
                 destroySpinner.text = `Destroying Stack deployment in ${styleText('bold', (i--).toString())} seconds...`;
-                await setTimeout(1000);
+                await sleep(1000);
             }
             destroySpinner.text = 'Destroying Stack deployment 💥';
-            await setTimeout(500);
+            await sleep(500);
         }
         else {
             destroySpinner.start();
@@ -97,11 +97,16 @@ export async function blueprintDestroyCore(options) {
         log(styleText('dim', 'Stack destruction progress:'));
         let logStreamCleanup = null;
         try {
+            let lastLogAt = Date.now();
+            let idleMessageShown = false;
             logStreamCleanup = await setupLogStreaming({
                 stackId: stack.id,
                 after: isoNow,
                 auth,
                 log,
+                onActivity: () => {
+                    lastLogAt = Date.now();
+                },
             });
             while (true) {
                 const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth, logger: log });
@@ -119,7 +124,12 @@ export async function blueprintDestroyCore(options) {
                         logStreamCleanup();
                     return { success: false, error: 'Stack destruction failed' };
                 }
-                await setTimeout(1500);
+                if (!idleMessageShown && Date.now() - lastLogAt > 60_000) {
+                    log(`No new activity for 60 seconds. The destruction is still running on Sanity servers.`);
+                    log(`You can safely exit and check status later with \`${bin} blueprints info\`.`);
+                    idleMessageShown = true;
+                }
+                await sleep(1500);
             }
         }
         catch (error) {

package/dist/cores/blueprints/doctor.js

@@ -1,202 +1,295 @@
-import { cwd } from 'node:process';
+import { readFileSync } from 'node:fs';
+import { arch, cwd, version as nodeVersion, platform } from 'node:process';
+import * as resolve from 'empathic/resolve';
+import ora from 'ora';
 import { readLocalBlueprint, } from '../../actions/blueprints/blueprint.js';
 import { getStack } from '../../actions/blueprints/stacks.js';
-import config from '../../config.js';
-import { capitalize, check, filePathRelativeToCwd, indent, niceId, severe, unsure, } from '../../utils/display/presenters.js';
+import config, { RUNTIME_CLI_VERSION } from '../../config.js';
+import { check, filePathRelativeToCwd, niceId, severe, unsure, } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
 import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 import { blueprintConfigCore } from './config.js';
 const diagLookup = {
-    online: 'Online',
+    online: 'Host online',
     tokenValid: 'Authenticated',
     blueprintValid: 'Blueprint valid',
     stackReady: 'Stack ready',
     userHasAccess: 'User has access',
 };
+function sourceLabel(source) {
+    switch (source) {
+        case 'env':
+            return 'environment';
+        case 'module':
+            return 'blueprint module';
+        case 'config':
+            return 'config file';
+        case 'inferred':
+            return 'inferred';
+        default:
+            return 'unknown';
+    }
+}
+function renderSection(emit, title, rows) {
+    const pad = Math.max(...rows.map(([l]) => l.length)) + 3;
+    emit(styleText('bold', title));
+    for (const [label, value] of rows) {
+        emit(`  ${styleText('dim', label.padEnd(pad))}${value}`);
+    }
+}
 export async function blueprintDoctorCore(options) {
     const { bin, log, token, validateResources, flags: { verbose: v, path: p, fix }, } = options;
-    const yikes = (s) => {
-        log.error(styleText(['bgRedBright', 'whiteBright', 'bold'], ` ${s} `));
-    };
-    const here = cwd();
-    const path = p || here;
+    const path = p || cwd();
     let tokenOrError;
-    log.verbose(`Checking ${filePathRelativeToCwd(path)}`);
-    // 3 states: null == unknown, true == good, false == bad
     const diagnostics = {};
     for (const key in diagLookup) {
-        diagnostics[key] = null;
+        diagnostics[key] = { status: null };
     }
-    // ONLINE
+    const envRows = [['Directory', p ? filePathRelativeToCwd(path) : path]];
+    const configRows = [];
+    const stackRows = [];
+    const spinner = ora('Running diagnostics...').start();
+    // --- ONLINE ---
     const fetchFn = createTracedFetch(log);
     try {
         const res = await fetchFn(config.apiUrl);
         if (res.ok) {
-            log.verbose(`Successfully pinged ${config.apiUrl}`);
-            diagnostics.online = res.ok;
+            diagnostics.online = { status: true };
         }
         else {
-            yikes(`Failed to ping ${config.apiUrl}: ${res.status} ${res.statusText}`);
-            diagnostics.online = false;
+            diagnostics.online = { status: false, detail: `${res.status} ${res.statusText}` };
         }
     }
-    catch {
-        yikes(`Failed to ping ${config.apiUrl}`);
+    catch (err) {
+        const reason = err instanceof Error ? err.message : 'unknown error';
+        diagnostics.online = { status: false, detail: reason };
     }
-    // TOKEN
+    // --- TOKEN ---
     if (token) {
         tokenOrError = await validTokenOrErrorMessage(log, token);
         if (tokenOrError.ok) {
-            diagnostics.tokenValid = true;
+            diagnostics.tokenValid = { status: true };
         }
         else {
-            yikes(`Token error: ${tokenOrError.error.message}`);
-            diagnostics.tokenValid = false;
+            diagnostics.tokenValid = { status: false, detail: tokenOrError.error.message };
         }
     }
     else {
-        yikes('No authentication token found');
-        diagnostics.tokenValid = false;
+        diagnostics.tokenValid = { status: false, detail: 'no token found' };
     }
-    // BLUEPRINT file
+    // --- BLUEPRINT ---
     let localBlueprint;
     try {
         localBlueprint = await readLocalBlueprint(log, { resources: options.validateResources || false }, path);
-        log.verbose(`Found blueprint file at ${filePathRelativeToCwd(localBlueprint.fileInfo.blueprintFilePath)}`);
+        envRows.push(['Blueprint', filePathRelativeToCwd(localBlueprint.fileInfo.blueprintFilePath)]);
         if (localBlueprint.errors.length === 0) {
-            log.verbose(`Blueprint has no errors`);
-            diagnostics.blueprintValid = true;
+            diagnostics.blueprintValid = { status: true };
         }
         else {
-            log.verbose(`Blueprint errors: \n${localBlueprint.errors.join('\n  ')}`);
-            diagnostics.blueprintValid = false;
+            diagnostics.blueprintValid = {
+                status: false,
+                detail: `${localBlueprint.errors.length} error(s)`,
+            };
         }
     }
     catch {
-        yikes(`Unable to read blueprint`);
-        diagnostics.blueprintValid = false;
+        diagnostics.blueprintValid = { status: false, detail: 'unable to read file' };
     }
+    envRows.push(['API URL', config.apiUrl]);
+    envRows.push(['Runtime', `Node.js ${nodeVersion} (${platform}-${arch})`]);
+    if (RUNTIME_CLI_VERSION) {
+        envRows.push(['Internals', `v${RUNTIME_CLI_VERSION}`]);
+    }
+    const sanityCliPkgPath = resolve.from(path, '@sanity/cli/package.json', true);
+    if (sanityCliPkgPath) {
+        try {
+            const sanityCliPkg = JSON.parse(readFileSync(sanityCliPkgPath, 'utf8'));
+            envRows.push(['Sanity CLI', sanityCliPkg.version]);
+        }
+        catch { }
+    }
+    // --- CONFIGURATION ---
     if (localBlueprint) {
-        const { scopeType, scopeId, stackId, sources } = localBlueprint;
-        const sourceLabel = (source) => {
-            switch (source) {
-                case 'env':
-                    return 'environment';
-                case 'module':
-                    return 'blueprint module';
-                case 'config':
-                    return 'config file';
-                case 'inferred':
-                    return 'inferred';
-                default:
-                    return 'unknown';
-            }
-        };
+        const { scopeType, scopeId, stackId, sources, blueprintConfig } = localBlueprint;
+        if (blueprintConfig && 'configPath' in blueprintConfig && blueprintConfig.configPath) {
+            configRows.push(['Source', filePathRelativeToCwd(blueprintConfig.configPath)]);
+        }
+        else if (!blueprintConfig) {
+            configRows.push(['Source', styleText('dim', 'no config file')]);
+        }
+        if (blueprintConfig?.updatedAt) {
+            configRows.push(['Updated', new Date(blueprintConfig.updatedAt).toLocaleString('sv-SE')]);
+        }
         if (scopeType && scopeId) {
             const scopeSourceKey = scopeType === 'project' ? 'projectId' : 'organizationId';
-            log.verbose(indent(`${capitalize(scopeType)}: ${niceId(scopeId)} (from ${sourceLabel(sources?.[scopeSourceKey])})`));
+            const label = scopeType === 'project' ? 'Project' : 'Organization';
+            configRows.push([
+                label,
+                `${niceId(scopeId)}  ${styleText('dim', sourceLabel(sources?.[scopeSourceKey]))}`,
+            ]);
         }
         if (stackId) {
-            log.verbose(indent(`Deployment: ${niceId(stackId)} (from ${sourceLabel(sources?.stackId)})`));
+            configRows.push([
+                'Stack',
+                `${niceId(stackId)}  ${styleText('dim', sourceLabel(sources?.stackId))}`,
+            ]);
         }
-        // STACK + ACCESS
-        if (diagnostics.online && diagnostics.tokenValid && token && stackId && scopeType && scopeId) {
+        // --- STACK + ACCESS ---
+        if (diagnostics.online.status &&
+            diagnostics.tokenValid.status &&
+            token &&
+            stackId &&
+            scopeType &&
+            scopeId) {
             const stackResponse = await getStack({
                 auth: { token, scopeType, scopeId },
                 stackId,
                 logger: log,
             });
             if (stackResponse.ok) {
-                log.verbose(`Deployment "Stack" ${niceId(stackId)} ready`);
-                diagnostics.stackReady = true;
-                diagnostics.userHasAccess = true;
+                diagnostics.stackReady = { status: true };
+                diagnostics.userHasAccess = { status: true };
+                const stack = stackResponse.stack;
+                if (stack) {
+                    const label = stack.name ? `"${stack.name}" ${niceId(stackId)}` : niceId(stackId);
+                    stackRows.push(['Stack', label]);
+                    if (stack.recentOperation) {
+                        const op = stack.recentOperation;
+                        const time = op.completedAt || op.createdAt;
+                        const timestamp = time
+                            ? `  ${styleText('dim', new Date(time).toLocaleString('sv-SE'))}`
+                            : '';
+                        stackRows.push(['Operation', `${op.status}${timestamp}`]);
+                    }
+                }
             }
             else if (stackResponse.response?.status === 404) {
-                yikes(`Deployment "Stack" <${stackId}> not found`);
-                diagnostics.stackReady = false;
+                diagnostics.stackReady = {
+                    status: false,
+                    detail: `Stack ${niceId(stackId)} not found (404)`,
+                };
             }
             else if (stackResponse.response?.status === 403 || stackResponse.response?.status === 401) {
-                yikes(`User does not have access to "Stack" <${stackId}>`);
-                diagnostics.userHasAccess = false;
+                diagnostics.userHasAccess = {
+                    status: false,
+                    detail: `no access to Stack ${niceId(stackId)} (${stackResponse.response.status})`,
+                };
             }
             else {
-                yikes(`Unknown error with "Stack" <${stackId}>: ${stackResponse.error}`);
+                const statusSuffix = stackResponse.response?.status
+                    ? ` (${stackResponse.response.status})`
+                    : '';
+                diagnostics.stackReady = {
+                    status: null,
+                    detail: (stackResponse.error || 'unknown error') + statusSuffix,
+                };
+                diagnostics.userHasAccess = { status: null, detail: `unknown error${statusSuffix}` };
             }
         }
+        else if (stackId && scopeType && scopeId) {
+            diagnostics.stackReady = { status: null, detail: 'requires online + authenticated' };
+            diagnostics.userHasAccess = { status: null, detail: 'requires online + authenticated' };
+        }
+        else if (!stackId && !scopeType && !scopeId) {
+            diagnostics.stackReady = { status: null, detail: 'missing configuration' };
+            diagnostics.userHasAccess = { status: null, detail: 'missing configuration' };
+        }
         else {
+            const missing = [];
             if (!stackId)
-                yikes(`Blueprints configuration is missing a Stack ID`);
-            if (scopeType === 'project') {
-                if (!scopeId)
-                    yikes(`Blueprints configuration is missing a Project ID`);
-            }
-            else if (scopeType === 'organization') {
-                if (!scopeId)
-                    yikes(`Blueprints configuration is missing an Organization ID`);
-            }
-            else {
-                if (!scopeType)
-                    yikes(`Blueprints configuration is missing a Scope Type`);
-                if (!scopeId)
-                    yikes(`Blueprints configuration is missing a Scope ID`);
+                missing.push('Stack ID');
+            if (!scopeType)
+                missing.push('Scope Type');
+            if (!scopeId) {
+                const scopeLabel = scopeType === 'project'
+                    ? 'Project ID'
+                    : scopeType === 'organization'
+                        ? 'Organization ID'
+                        : 'Scope ID';
+                missing.push(scopeLabel);
             }
+            const detail = `missing ${missing.join(', ')}`;
+            diagnostics.stackReady = { status: null, detail };
+            diagnostics.userHasAccess = { status: null, detail };
         }
     }
-    log('');
+    // --- RENDER REPORT ---
+    spinner.stop();
+    // Environment (verbose)
+    renderSection((msg) => log.verbose(msg), 'Environment', envRows);
+    log.verbose('');
+    // Configuration (verbose)
+    if (configRows.length > 0) {
+        renderSection((msg) => log.verbose(msg), 'Configuration', configRows);
+        log.verbose('');
+    }
+    // Deployment (verbose)
+    if (stackRows.length > 0) {
+        renderSection((msg) => log.verbose(msg), 'Deployment', stackRows);
+        log.verbose('');
+    }
+    // Checks (always visible)
+    const maxLabel = Math.max(...Object.values(diagLookup).map((l) => l.length));
+    log(styleText('bold', 'Checks'));
     let allGood = true;
-    for (const [key, value] of Object.entries(diagnostics)) {
-        switch (value) {
+    for (const [key, entry] of Object.entries(diagnostics)) {
+        const label = diagLookup[key].padEnd(maxLabel);
+        const detail = entry.detail ? `  ${styleText('dim', entry.detail)}` : '';
+        switch (entry.status) {
             case true:
-                log(check(diagLookup[key]));
+                log(`  ${check(label)}${detail}`);
                 break;
             case false:
                 allGood = false;
-                log(severe(diagLookup[key]));
+                log(`  ${severe(label)}${detail}`);
                 break;
             case null:
                 allGood = false;
-                log(unsure(diagLookup[key]));
+                log(`  ${unsure(label)}${detail}`);
                 break;
-            default:
-                allGood = false;
-                log(severe(`${key} is ${value}`));
         }
     }
+    // Result
+    const flatDiagnostics = {};
+    for (const [key, entry] of Object.entries(diagnostics)) {
+        flatDiagnostics[key] = entry.status;
+    }
+    log('');
     const errorMessage = 'One or more checks failed';
     if (allGood) {
         log(styleText(['bold', 'green'], 'All checks passed'));
         if (fix)
             log(styleText(['bold', 'yellow'], 'Nothing to fix; --fix flag is ignored'));
-        return { success: true, data: { diagnostics } };
+        return { success: true, data: { diagnostics: flatDiagnostics } };
     }
-    else if (fix) {
+    if (fix) {
         if (p) {
             return {
                 success: false,
                 error: `${errorMessage}. --fix cannot be used with --path`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         if (!tokenOrError) {
             return {
                 success: false,
                 error: `${errorMessage}. Unable to fix: Missing authentication token`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         if (tokenOrError?.ok === false) {
             return {
                 success: false,
                 error: `${errorMessage}. Unable to fix: ${tokenOrError.error.message}`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         if (!localBlueprint) {
             return {
                 success: false,
                 error: `${errorMessage}. Unable to fix: Blueprint is missing or invalid`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         return blueprintConfigCore({
@@ -208,5 +301,6 @@ export async function blueprintDoctorCore(options) {
             flags: { edit: true, verbose: v },
         });
     }
-    return { success: false, error: errorMessage, data: { diagnostics } };
+    log(styleText('dim', `  Run \`${bin} blueprints doctor --fix\` to resolve configuration issues.`));
+    return { success: false, error: errorMessage, data: { diagnostics: flatDiagnostics } };
 }

package/dist/cores/blueprints/plan.js

@@ -1,32 +1,67 @@
-import { getStack, resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
-import { formatResourceTree, stackDeployDiff } from '../../utils/display/blueprints-formatting.js';
+import { planStack, resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
+import { formatDeploymentPlan, formatResourceTree, hasActionableChanges, } from '../../utils/display/blueprints-formatting.js';
 import { styleText } from '../../utils/style-text.js';
 export async function blueprintPlanCore(options) {
     const { bin = 'sanity', log, blueprint, token, flags } = options;
     const { verbose: _verbose = false } = flags;
     const { scopeType, scopeId, stackId: blueprintStackId, parsedBlueprint, fileInfo } = blueprint;
-    log(`${styleText(['bold', 'blueBright'], 'Blueprint Stack deployment plan')} ${styleText('dim', `(${fileInfo.fileName})`)}`);
+    log(`${styleText(['bold', 'blueBright'], 'Local Blueprint')} ${styleText('dim', `(${fileInfo.fileName})`)}`);
     log(formatResourceTree(parsedBlueprint.resources));
-    if (token && scopeType && scopeId) {
-        const stackId = flags.stack
-            ? await resolveStackIdByNameOrId(flags.stack, { token, scopeType, scopeId }, log)
-            : blueprintStackId;
-        if (stackId) {
-            const stackResponse = await getStack({
-                auth: { token, scopeType, scopeId },
-                stackId,
-                logger: log,
-            });
-            if (!stackResponse.ok) {
-                log(styleText('dim', 'Unable to retrieve live Stack deployment for comparison'));
-            }
-            else {
-                const diff = stackDeployDiff(parsedBlueprint, stackResponse.stack);
-                if (diff)
-                    log(diff);
+    if (!token || !scopeType || !scopeId) {
+        log(styleText('dim', 'Unable to retrieve live Stack deployment for comparison'));
+        const errorMessage = !token
+            ? `Missing authentication token. Run \`${bin} login\` to authenticate.`
+            : `Missing Blueprint configuration. Run \`${bin} blueprints doctor --fix\` to repair.`;
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+    const stackId = flags.stack
+        ? await resolveStackIdByNameOrId(flags.stack, { token, scopeType, scopeId }, log)
+        : blueprintStackId;
+    if (!stackId) {
+        log(styleText('dim', 'Unable to retrieve live Stack deployment for comparison'));
+        return {
+            success: false,
+            error: `Missing Stack deployment configuration. Run \`${bin} blueprints doctor --fix\` to repair.`,
+        };
+    }
+    const auth = { token, scopeType, scopeId };
+    const spinner = log.ora('Generating deployment plan...').start();
+    const planResponse = await planStack({
+        stackId,
+        document: parsedBlueprint,
+        auth,
+        logger: log,
+    });
+    spinner.stop().clear();
+    if (!planResponse.ok) {
+        if (planResponse.problems) {
+            log('');
+            for (const problem of planResponse.problems) {
+                const messages = problem.message
+                    .split('\n')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                for (const msg of messages) {
+                    log(`  ${styleText(['bold', 'red'], '✘')} ${msg}`);
+                }
             }
+            log(`\n  Fix the issues above before running "${styleText(['bold', 'magenta'], `${bin} blueprints deploy`)}"`);
         }
+        else {
+            log(styleText('dim', '\nUnable to retrieve deployment plan from server'));
+        }
+        return { success: false, error: 'Deployment plan has problems' };
+    }
+    log('');
+    log(formatDeploymentPlan(planResponse.deploymentPlan));
+    if (hasActionableChanges(planResponse.deploymentPlan)) {
+        log(`\n  Run "${styleText(['bold', 'magenta'], `${bin} blueprints deploy`)}" to apply these Stack changes`);
+    }
+    else {
+        log(`\n  ${styleText('dim', `No significant changes to deploy. Run \`${bin} blueprints deploy\` to apply.`)}`);
     }
-    log(`\n  Run "${styleText(['bold', 'magenta'], `${bin} blueprints deploy`)}" to deploy these Stack changes`);
     return { success: true };
 }

package/dist/utils/display/blueprints-formatting.d.ts

@@ -1,8 +1,10 @@
 import type { Blueprint, Resource } from '@sanity/blueprints-parser';
+import type { DeploymentPlan } from '../../actions/blueprints/stacks.js';
 import { type BlueprintResourceRecord, type Stack } from '../types.js';
 export declare function formatTitle(title: string, name: string): string;
 export declare function formatDeployedResourceTree(resources: BlueprintResourceRecord[] | undefined, verbose?: boolean): string;
 export declare function formatResourceTree(resources: Resource[] | undefined, verbose?: boolean): string;
 export declare function formatStackInfo(stack: Stack | Blueprint, isCurrentStack?: boolean): string;
 export declare function formatStacksListing(stacks: Stack[], currentStackId?: string): string;
-export declare function stackDeployDiff(localBlueprint: Blueprint, deployedStack: Stack): string | null;
+export declare function hasActionableChanges(deploymentPlan: DeploymentPlan): boolean;
+export declare function formatDeploymentPlan(deploymentPlan: DeploymentPlan): string;

package/dist/utils/display/blueprints-formatting.js

@@ -208,29 +208,143 @@ export function formatStacksListing(stacks, currentStackId) {
     }
     return output.join('\n');
 }
-export function stackDeployDiff(localBlueprint, deployedStack) {
-    const added = [];
-    const removed = [];
-    // look for new resources
-    for (const resource of localBlueprint.resources ?? []) {
-        const deployedResource = deployedStack.resources.find(({ name, type }) => resource.name === name && resource.type === type);
-        if (!deployedResource)
-            added.push(resource);
-    }
-    // look for destroyed resources
-    for (const resource of deployedStack.resources) {
-        const localResource = localBlueprint.resources?.find(({ name, type }) => resource.name === name && resource.type === type);
-        if (!localResource)
-            removed.push(resource);
-    }
-    if (added.length === 0 && removed.length === 0)
-        return null;
-    const output = [];
-    if (added.length > 0) {
-        output.push(`  ${styleText(['bold', 'greenBright'], '++')} ${added.map(({ name }) => styleText(['bgGreen', 'whiteBright'], `"${name}"`)).join(' ')}`);
+const IGNORED_PARAMS = {
+    [SANITY_FUNCTION_DOCUMENT]: new Set(['src']),
+    [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: new Set(['src']),
+    [SANITY_FUNCTION_SCHEDULE]: new Set(['src']),
+};
+const ASSET_RESOURCE_TYPES = new Set([
+    SANITY_FUNCTION_DOCUMENT,
+    SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
+    SANITY_FUNCTION_SCHEDULE,
+]);
+function stringifyUnknown(val) {
+    if (val === null || val === undefined)
+        return JSON.stringify(val);
+    if (Array.isArray(val))
+        return `[${val.map(stringifyUnknown).join(',')}]`;
+    if (typeof val === 'object') {
+        const obj = val;
+        const sorted = Object.keys(obj)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${stringifyUnknown(obj[k])}`);
+        return `{${sorted.join(',')}}`;
     }
-    if (removed.length > 0) {
-        output.push(`  ${styleText(['bold', 'redBright'], '--')} ${removed.map(({ name }) => styleText(['bgRed', 'whiteBright'], `"${name}"`)).join(' ')}`);
+    return JSON.stringify(val);
+}
+function detectChangedParams(details) {
+    const existing = details.existingResource?.parameters;
+    const updated = details.updatedResource?.parameters;
+    if (!existing || !updated)
+        return [];
+    const ignored = IGNORED_PARAMS[details.type];
+    const keys = new Set([...Object.keys(existing), ...Object.keys(updated)]);
+    const changed = [];
+    for (const key of keys) {
+        if (ignored?.has(key))
+            continue;
+        if (stringifyUnknown(existing[key]) !== stringifyUnknown(updated[key])) {
+            changed.push(key);
+        }
     }
-    return output.join('\n');
+    return changed;
+}
+function getAssetSrc(details) {
+    const src = details.updatedResource?.parameters?.src ?? details.parameters?.src;
+    return typeof src === 'string' && !src.startsWith('AS-') ? src : undefined;
+}
+function actionStyle(type, isUnchanged = false) {
+    if (isUnchanged)
+        return { icon: '=', color: 'dim' };
+    switch (type) {
+        case 'create':
+            return { icon: '+', color: 'green' };
+        case 'update':
+            return { icon: '~', color: 'yellow' };
+        case 'destroy':
+            return { icon: '-', color: 'red' };
+        case 'attach':
+            return { icon: '←', color: 'blue' };
+        case 'detach':
+            return { icon: '→', color: 'gray' };
+        // case 'skip':
+        default:
+            return { icon: '=', color: 'dim' };
+    }
+}
+export function hasActionableChanges(deploymentPlan) {
+    const { summary } = deploymentPlan;
+    if (summary.createCount || summary.destroyCount || summary.attachCount || summary.detachCount) {
+        return true;
+    }
+    return deploymentPlan.plan.some((action) => action.type === 'update' &&
+        action.details &&
+        (detectChangedParams(action.details).length > 0 ||
+            (ASSET_RESOURCE_TYPES.has(action.resourceType) &&
+                getAssetSrc(action.details) !== undefined)));
+}
+export function formatDeploymentPlan(deploymentPlan) {
+    const lines = [];
+    lines.push(styleText('bold', 'Deployment Plan'));
+    if (deploymentPlan.plan.length === 0) {
+        lines.push(styleText('dim', '  No changes'));
+        return lines.join('\n');
+    }
+    const typePad = Math.max(...deploymentPlan.plan.map((a) => a.type.length));
+    const names = deploymentPlan.plan.map((a) => a.details?.name ?? '');
+    const namePad = Math.max(...names.map((n) => n.length));
+    const enrichedPlan = deploymentPlan.plan.map((action) => {
+        const changedParams = action.type === 'update' && action.details ? detectChangedParams(action.details) : [];
+        // always represent asset updates as a change; hard to know if the asset has changed
+        const assetSrc = action.details && ASSET_RESOURCE_TYPES.has(action.resourceType)
+            ? getAssetSrc(action.details)
+            : undefined;
+        const isUnchanged = action.type === 'update' && changedParams.length === 0 && !assetSrc;
+        return { action, changedParams, isUnchanged };
+    });
+    let unchangedCount = 0;
+    for (const { action, changedParams, isUnchanged } of enrichedPlan) {
+        const name = action.details?.name ?? '';
+        if (isUnchanged)
+            unchangedCount++;
+        const style = actionStyle(action.type, isUnchanged);
+        const icon = styleText(['bold', style.color], style.icon);
+        const typeLabel = styleText(style.color, action.type.padEnd(typePad));
+        const nameLabel = isUnchanged
+            ? styleText('dim', name.padEnd(namePad))
+            : styleText('bold', name.padEnd(namePad));
+        const resourceType = styleText('dim', action.resourceType);
+        let suffix = '';
+        if (changedParams.length > 0) {
+            suffix = `  ${styleText('yellow', changedParams.join(', '))}`;
+        }
+        lines.push(`  ${icon} ${typeLabel}  ${nameLabel}  ${resourceType}${suffix}`);
+    }
+    const { summary } = deploymentPlan;
+    const parts = [];
+    if (summary.createCount)
+        parts.push(styleText('green', `${summary.createCount} create`));
+    if (summary.updateCount) {
+        let label = `${summary.updateCount} update`;
+        if (unchangedCount > 0 && unchangedCount < summary.updateCount) {
+            label += ` (${styleText('yellow', `${summary.updateCount - unchangedCount} changed`)})`;
+        }
+        else if (unchangedCount === summary.updateCount) {
+            label += ` ${styleText('dim', '(no changes)')}`;
+        }
+        parts.push(label);
+    }
+    if (summary.destroyCount)
+        parts.push(styleText('red', `${summary.destroyCount} destroy`));
+    if (summary.skipCount)
+        parts.push(styleText('dim', `${summary.skipCount} skip`));
+    if (summary.attachCount)
+        parts.push(styleText('blue', `${summary.attachCount} attach`));
+    if (summary.detachCount)
+        parts.push(styleText('dim', `${summary.detachCount} detach`));
+    if (parts.length > 0) {
+        lines.push('');
+        lines.push(`  ${parts.join(', ')}`);
+    }
+    return lines.join('\n');
 }

package/dist/utils/other/npmjs.js

@@ -1,7 +1,10 @@
+import { env } from 'node:process';
 import { createTracedFetch } from '../traced-fetch.js';
 export async function getLatestNpmVersion(pkg, logger) {
     const fetchFn = createTracedFetch(logger);
-    const url = `https://registry.npmjs.org/${pkg}/latest`;
+    // allow for registry override; helpful for testing
+    const registry = env.SANITY_INTERNAL_NPM_REGISTRY_URL || 'https://registry.npmjs.org';
+    const url = `${registry}/${pkg}/latest`;
     try {
         const res = await fetchFn(url);
         if (!res.ok)

package/oclif.manifest.json

@@ -318,7 +318,7 @@
     "blueprints:deploy": {
       "aliases": [],
       "args": {},
-      "description": "Pushes your local Blueprint configuration to the remote Stack; provisioning, updating, or destroying resources as needed. This is the primary command for applying infrastructure changes.\n\nBefore deploying, run 'blueprints plan' to preview changes. After deployment, use 'blueprints info' to verify Stack status or 'blueprints logs' to monitor activity.\n\nUse --no-wait to queue the deployment and return immediately without waiting for completion.",
+      "description": "Pushes your local Blueprint configuration to the remote Stack; provisioning, updating, or destroying resources as needed. This is the primary command for applying infrastructure changes.\n\nBefore deploying, run 'blueprints plan' to preview changes. After deployment, use 'blueprints info' to verify Stack status or 'blueprints logs' to monitor activity.\n\nUse --no-wait to queue the deployment and return immediately without waiting for completion.\n\nSet SANITY_ASSET_TIMEOUT (seconds) to override the 60-second timeout for processing resource assets.",
       "examples": [
         "<%= config.bin %> <%= command.id %>",
         "<%= config.bin %> <%= command.id %> --no-wait"
@@ -578,10 +578,9 @@
           "type": "boolean"
         },
         "verbose": {
-          "description": "Verbose output",
-          "hidden": false,
+          "description": "Verbose output; defaults to true",
           "name": "verbose",
-          "allowNo": false,
+          "allowNo": true,
           "type": "boolean"
         },
         "fix": {
@@ -2084,5 +2083,5 @@
       ]
     }
   },
-  "version": "14.0.0"
+  "version": "14.1.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "14.0.0",
+  "version": "14.1.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",