@sanity/runtime-cli 12.4.0 → 13.0.1

package/dist/commands/functions/env/list.d.ts

@@ -1,9 +1,10 @@
 import { DeployedStackCommand } from '../../../baseCommands.js';
 export default class EnvListCommand extends DeployedStackCommand<typeof EnvListCommand> {
+    static summary: string;
+    static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
-    static description: string;
     static examples: string[];
     run(): Promise<void>;
 }

package/dist/commands/functions/env/list.js

@@ -1,16 +1,20 @@
 import { Args } from '@oclif/core';
 import { DeployedStackCommand } from '../../../baseCommands.js';
 import { functionEnvListCore } from '../../../cores/functions/env/list.js';
+import { Logger } from '../../../utils/logger.js';
 export default class EnvListCommand extends DeployedStackCommand {
+    static summary = 'List environment variables for a deployed function';
+    static description = `Displays all environment variables (keys only) configured in a deployed Sanity Function.
+
+Use 'functions env add' to set variables or 'functions env remove' to delete them.`;
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
-    static description = 'List the environment variables for a Sanity function';
     static examples = ['<%= config.bin %> <%= command.id %> MyFunction'];
     async run() {
         const { success, error } = await functionEnvListCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             args: this.args,
             auth: this.auth,
             blueprint: this.blueprint,

package/dist/commands/functions/env/remove.d.ts

@@ -1,10 +1,11 @@
 import { DeployedStackCommand } from '../../../baseCommands.js';
 export default class EnvRemoveCommand extends DeployedStackCommand<typeof EnvRemoveCommand> {
+    static summary: string;
+    static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
-    static description: string;
     static examples: string[];
     run(): Promise<void>;
 }

package/dist/commands/functions/env/remove.js

@@ -1,17 +1,21 @@
 import { Args } from '@oclif/core';
 import { DeployedStackCommand } from '../../../baseCommands.js';
 import { functionEnvRemoveCore } from '../../../cores/functions/env/remove.js';
+import { Logger } from '../../../utils/logger.js';
 export default class EnvRemoveCommand extends DeployedStackCommand {
+    static summary = 'Remove an environment variable from a deployed function';
+    static description = `Deletes an environment variable from a deployed Sanity Function. The change takes effect on the next function invocation.
+
+Use 'functions env list' to see current variables before removing.`;
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
         key: Args.string({ description: 'The name of the environment variable', required: true }),
     };
-    static description = 'Remove an environment variable for a Sanity function';
     static examples = ['<%= config.bin %> <%= command.id %> MyFunction API_URL'];
     async run() {
         const { success, error } = await functionEnvRemoveCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             args: this.args,
             auth: this.auth,
             blueprint: this.blueprint,

package/dist/commands/functions/logs.d.ts

@@ -1,9 +1,10 @@
 import { DeployedStackCommand } from '../../baseCommands.js';
 export default class LogsCommand extends DeployedStackCommand<typeof LogsCommand> {
+    static summary: string;
+    static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
-    static description: string;
     static examples: string[];
     static flags: {
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/functions/logs.js

@@ -1,11 +1,15 @@
 import { Args, Flags } from '@oclif/core';
 import { DeployedStackCommand } from '../../baseCommands.js';
 import { functionLogsCore } from '../../cores/functions/logs.js';
+import { Logger } from '../../utils/logger.js';
 export default class LogsCommand extends DeployedStackCommand {
+    static summary = 'Retrieve or delete logs for a Sanity Function';
+    static description = `Fetches execution logs from a deployed function, useful for debugging production issues or monitoring activity.
+
+Use --watch (-w) to stream logs in real-time. Use --delete to clear all logs for a function (requires confirmation unless --force is specified).`;
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: false }),
     };
-    static description = 'Retrieve or delete logs for a Sanity Function';
     static examples = [
         '<%= config.bin %> <%= command.id %> <name>',
         '<%= config.bin %> <%= command.id %> <name> --json',
@@ -48,12 +52,11 @@ export default class LogsCommand extends DeployedStackCommand {
         }),
     };
     async run() {
-        const { name } = this.args;
         const { success, error } = await functionLogsCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             error: (msg, options) => this.error(msg, options),
-            args: { name },
+            args: this.args,
             flags: this.flags,
             auth: this.auth,
             blueprint: this.blueprint,

package/dist/commands/functions/test.d.ts

@@ -1,9 +1,10 @@
 import { LocalBlueprintCommand } from '../../baseCommands.js';
 export default class TestCommand extends LocalBlueprintCommand<typeof TestCommand> {
+    static summary: string;
+    static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
-    static description: string;
     static examples: string[];
     static flags: {
         data: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/functions/test.js

@@ -1,11 +1,15 @@
 import { Args, Flags } from '@oclif/core';
 import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionTestCore } from '../../cores/functions/test.js';
+import { Logger } from '../../utils/logger.js';
 export default class TestCommand extends LocalBlueprintCommand {
+    static summary = 'Invoke a local Sanity Function';
+    static description = `Executes a function locally with the provided payload, simulating how it would run when deployed. Use this to test your function logic before deploying.
+
+Provide test data via --data (inline JSON), --file (JSON file), or --document-id (fetch from Sanity). For update events, use the before/after flag pairs to simulate document changes.`;
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: false }),
     };
-    static description = 'Invoke a local Sanity Function';
     static examples = [
         `<%= config.bin %> <%= command.id %> <name> --data '{ "id": 1 }'`,
         `<%= config.bin %> <%= command.id %> <name> --file 'payload.json'`,
@@ -165,7 +169,7 @@ export default class TestCommand extends LocalBlueprintCommand {
         }
         const { success, error } = await functionTestCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             error: (msg, options) => this.error(msg, options),
             args: { ...this.args, name },
             flags: this.flags,

package/dist/cores/blueprints/config.js

@@ -4,7 +4,7 @@ import { filePathRelativeToCwd, labeledId, warn } from '../../utils/display/pres
 import { promptForProject, promptForStack } from '../../utils/display/prompt.js';
 export async function blueprintConfigCore(options) {
     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 { edit: editConfig = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, verbose: _v = false, } = flags;
     const providedConfigFlag = [flagProjectId, flagStackId, flagOrganizationId].some(Boolean);
     const { stackId: configStackId, scopeType: configScopeType, scopeId: configScopeId, blueprintConfig, fileInfo, } = blueprint;
     const blueprintFilePath = fileInfo.blueprintFilePath;
@@ -17,7 +17,7 @@ export async function blueprintConfigCore(options) {
         }
     }
     if (blueprintConfig)
-        printConfig({ configLabel: 'Current', log, config: blueprintConfig, v });
+        printConfig({ configLabel: 'Current', log, config: blueprintConfig });
     // passing new config without --edit flag is not allowed
     if (providedConfigFlag && !editConfig) {
         log('To update the configuration, use the --edit flag.');
@@ -40,7 +40,7 @@ export async function blueprintConfigCore(options) {
                 configUpdate.organizationId = flagOrganizationId;
             try {
                 const newConfig = patchConfigFile(blueprintFilePath, configUpdate);
-                printConfig({ configLabel: 'Updated', log, config: newConfig, v });
+                printConfig({ configLabel: 'Updated', log, config: newConfig });
                 return { success: true };
             }
             catch {
@@ -54,6 +54,7 @@ export async function blueprintConfigCore(options) {
             const pickedProject = await promptForProject({
                 token,
                 knownProjectId: configScopeId,
+                logger: log,
             });
             updatedProjectId = pickedProject.projectId;
         }
@@ -61,18 +62,18 @@ export async function blueprintConfigCore(options) {
             return { success: false, error: 'Project ID is required.' };
         let updatedStackId = flagStackId;
         if (!updatedStackId) {
-            const pickedStack = await promptForStack({ projectId: updatedProjectId, token });
+            const pickedStack = await promptForStack({ projectId: updatedProjectId, token, logger: log });
             updatedStackId = pickedStack.stackId;
         }
         if (!updatedStackId)
             return { success: false, error: 'Stack is required.' };
         try {
             // update or create config JSON
-            const newConfig = await writeConfigFile(blueprintFilePath, {
+            const newConfig = writeConfigFile(blueprintFilePath, {
                 projectId: updatedProjectId,
                 stackId: updatedStackId,
             });
-            printConfig({ configLabel: 'Updated', log, config: newConfig, v });
+            printConfig({ configLabel: 'Updated', log, config: newConfig });
             return { success: true };
         }
         catch {
@@ -81,12 +82,11 @@ export async function blueprintConfigCore(options) {
     }
 }
 function printConfig(options) {
-    const { configLabel, log, config, v = false } = options;
+    const { configLabel, log, config } = options;
     const { projectId, organizationId, stackId, updatedAt } = config;
     const scopeType = projectId ? 'project' : 'organization';
     const scopeId = projectId ? projectId : organizationId;
-    if (v)
-        log(JSON.stringify(config));
+    log.verbose(JSON.stringify(config));
     log(`${chalk.bold(`${configLabel} configuration:`)}`);
     log(`  Deployment: ${labeledId('stack', stackId)}`);
     log(`   Scoped to: ${labeledId(scopeType, scopeId)}`);

package/dist/cores/blueprints/deploy.js

@@ -1,6 +1,5 @@
 import { setTimeout } from 'node:timers/promises';
 import chalk from 'chalk';
-import ora from 'ora';
 import { stashAsset } from '../../actions/blueprints/assets.js';
 import { setupLogStreaming } from '../../actions/blueprints/logs-streaming.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
@@ -8,7 +7,7 @@ import { niceId } from '../../utils/display/presenters.js';
 import { isLocalFunctionCollection, isLocalFunctionResource } from '../../utils/types.js';
 export async function blueprintDeployCore(options) {
     const { bin = 'sanity', log, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
-    const { verbose } = flags;
+    const { verbose: _verbose } = flags;
     const noWait = flags['no-wait'] || false;
     log(`Deploying "${deployedStack.name}" ${niceId(deployedStack.id)}...`);
     try {
@@ -21,8 +20,8 @@ export async function blueprintDeployCore(options) {
         if (allFunctionResources.length > 0) {
             log('Processing function assets...');
             for (const resource of allFunctionResources) {
-                const fnSpinner = ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
-                const result = await stashAsset({ resource, auth });
+                const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
+                const result = await stashAsset({ resource, auth, logger: log });
                 if (result.success && result.assetId) {
                     resource.src = result.assetId;
                     if (isLocalFunctionCollection(resource)) {
@@ -45,18 +44,16 @@ export async function blueprintDeployCore(options) {
                         fnSpinner.succeed(`${resource.name} ${niceId(result.assetId)}`);
                         log(`   Source: ${resource.src}`);
                     }
-                    if (verbose) {
-                        if (result.hash) {
-                            if (result.hash.length > 24) {
-                                log(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
-                            }
-                            else {
-                                log(`   Hash: ${result.hash}`);
-                            }
+                    if (result.hash) {
+                        if (result.hash.length > 24) {
+                            log.verbose(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
+                        }
+                        else {
+                            log.verbose(`   Hash: ${result.hash}`);
                         }
-                        if (result.exists)
-                            log('   Asset unchanged');
                     }
+                    if (result.exists)
+                        log.verbose('   Asset unchanged');
                 }
                 else {
                     const errorMsg = isLocalFunctionCollection(resource)
@@ -67,7 +64,7 @@ export async function blueprintDeployCore(options) {
                 }
             }
         }
-        const spinner = ora('Deploying...').start();
+        const spinner = log.ora('Deploying...').start();
         const isoNow = new Date().toISOString();
         const { ok: deployOk, stack, error: deployError, } = await updateStack({
             stackId,
@@ -78,6 +75,7 @@ export async function blueprintDeployCore(options) {
                 document: { resources: validResources },
             },
             auth,
+            logger: log,
         });
         if (!deployOk) {
             spinner.fail(`${chalk.red('Failed')} to update Stack deployment`);
@@ -99,7 +97,7 @@ export async function blueprintDeployCore(options) {
                 log,
             });
             while (true) {
-                const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth });
+                const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth, logger: log });
                 if (!ok) {
                     if (logStreamCleanup)
                         logStreamCleanup();

package/dist/cores/blueprints/destroy.js

@@ -1,7 +1,6 @@
 import { setTimeout } from 'node:timers/promises';
 import { confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
-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';
@@ -26,6 +25,7 @@ export async function blueprintDestroyCore(options) {
         const { ok, error, stack } = await destroyStack({
             stackId: flagStackId,
             auth: { token, scopeType, scopeId },
+            logger: log,
         });
         if (!ok)
             return { success: false, error: error || 'Failed to destroy Stack deployment' };
@@ -39,20 +39,20 @@ export async function blueprintDestroyCore(options) {
     let stack;
     try {
         if (flagStackId) {
-            const flagStack = await getStack({ stackId: flagStackId, auth });
+            const flagStack = await getStack({ stackId: flagStackId, auth, logger: log });
             if (!flagStack.ok)
                 return { success: false, error: flagStack.error || 'Failed to get Stack' };
             stack = flagStack.stack;
         }
         else if (stackId) {
-            const blueprintStack = await getStack({ stackId, auth });
+            const blueprintStack = await getStack({ stackId, auth, logger: log });
             if (!blueprintStack.ok)
                 return { success: false, error: blueprintStack.error || 'Failed to get Stack' };
             stack = blueprintStack.stack;
         }
         if (!stack)
             return { success: false, error: 'Stack deployment not found' };
-        const destroySpinner = ora({
+        const destroySpinner = log.ora({
             text: `Destroying Stack deployment "${chalk.bold(stack.name)}" ${niceId(stack.id)}...`,
             color: 'red',
         });
@@ -79,7 +79,7 @@ export async function blueprintDestroyCore(options) {
             destroySpinner.start();
         }
         const isoNow = new Date().toISOString();
-        const { ok, error } = await destroyStack({ stackId: stack.id, auth });
+        const { ok, error } = await destroyStack({ stackId: stack.id, auth, logger: log });
         if (!ok) {
             destroySpinner.fail('Failed to destroy Stack deployment');
             return { success: false, error: error || 'Failed to destroy Stack deployment' };
@@ -99,7 +99,7 @@ export async function blueprintDestroyCore(options) {
                 log,
             });
             while (true) {
-                const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth });
+                const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth, logger: log });
                 const operation = currentStack?.recentOperation;
                 if (!ok || !operation || operation?.status === 'COMPLETED') {
                     // Operation is also marked destroyed when stack is deleted;

package/dist/cores/blueprints/doctor.js

@@ -4,6 +4,7 @@ import { findBlueprintFile, readLocalBlueprint, } from '../../actions/blueprints
 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 { createTracedFetch } from '../../utils/traced-fetch.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 import { blueprintConfigCore } from './config.js';
 const diagLookup = {
@@ -20,24 +21,23 @@ const diagLookup = {
 export async function blueprintDoctorCore(options) {
     const { bin, log, token, flags: { verbose: v, path: p, fix }, } = options;
     const yikes = (s) => {
-        log(chalk.bgRedBright.whiteBright.bold(` ${s} `));
+        log.error(chalk.bgRedBright.whiteBright.bold(` ${s} `));
     };
     const here = cwd();
     const path = p || here;
     let tokenOrError;
-    if (v)
-        log(`Checking ${filePathRelativeToCwd(path)}`);
+    log.verbose(`Checking ${filePathRelativeToCwd(path)}`);
     // 3 states: null == unknown, true == good, false == bad
     const diagnostics = {};
     for (const key in diagLookup) {
         diagnostics[key] = null;
     }
     // ONLINE
+    const fetchFn = createTracedFetch(log);
     try {
-        const res = await fetch(config.apiUrl);
+        const res = await fetchFn(config.apiUrl);
         if (res.ok) {
-            if (v)
-                log(`Successfully pinged ${config.apiUrl}`);
+            log.verbose(`Successfully pinged ${config.apiUrl}`);
             diagnostics.online = res.ok;
         }
         else {
@@ -51,7 +51,7 @@ export async function blueprintDoctorCore(options) {
     // TOKEN
     if (token) {
         diagnostics.tokenPresent = true;
-        tokenOrError = await validTokenOrErrorMessage(token);
+        tokenOrError = await validTokenOrErrorMessage(log, token);
         if (tokenOrError.ok) {
             diagnostics.tokenValid = true;
         }
@@ -66,8 +66,7 @@ export async function blueprintDoctorCore(options) {
     // BLUEPRINT file
     const blueprintFile = findBlueprintFile(path);
     if (blueprintFile?.blueprintFilePath) {
-        if (v)
-            log(`Found blueprint file at ${blueprintFile.blueprintFilePath.replace(here, '.')}`);
+        log.verbose(`Found blueprint file at ${blueprintFile.blueprintFilePath.replace(here, '.')}`);
         diagnostics.blueprintPresent = true;
     }
     else {
@@ -75,21 +74,18 @@ export async function blueprintDoctorCore(options) {
     }
     let blueprint;
     try {
-        blueprint = await readLocalBlueprint(path);
+        blueprint = await readLocalBlueprint(log, path);
         if (blueprint.errors.length === 0) {
-            if (v)
-                log(`Blueprint has no errors`);
+            log.verbose(`Blueprint has no errors`);
             diagnostics.blueprintValid = true;
         }
         else {
-            if (v)
-                log(`Blueprint errors: \n${blueprint.errors.join('\n  ')}`);
+            log.verbose(`Blueprint errors: \n${blueprint.errors.join('\n  ')}`);
             diagnostics.blueprintValid = false;
         }
     }
     catch {
-        if (v)
-            yikes(`Unable to read blueprint`);
+        yikes(`Unable to read blueprint`);
         diagnostics.blueprintValid = false;
     }
     if (blueprint) {
@@ -97,18 +93,15 @@ export async function blueprintDoctorCore(options) {
         const configPath = blueprintConfig?.configPath;
         // CONFIG file
         if (configPath) {
-            if (v)
-                log(`Found config file at ${configPath.replace(here, '.')}`);
+            log.verbose(`Found config file at ${configPath.replace(here, '.')}`);
             diagnostics.configFilePresent = true;
             if (scopeType && scopeId && stackId) {
                 diagnostics.configFileValid = true;
-                if (v) {
-                    const configOutput = [
-                        `${capitalize(scopeType)}: ${niceId(scopeId)}`,
-                        `Deployment: ${niceId(stackId)}`,
-                    ].join('\n');
-                    log(indent(configOutput));
-                }
+                const configOutput = [
+                    `${capitalize(scopeType)}: ${niceId(scopeId)}`,
+                    `Deployment: ${niceId(stackId)}`,
+                ].join('\n');
+                log.verbose(indent(configOutput));
             }
             else {
                 diagnostics.configFileValid = false;
@@ -122,10 +115,10 @@ export async function blueprintDoctorCore(options) {
             const stackResponse = await getStack({
                 auth: { token, scopeType: 'project', scopeId: projectId },
                 stackId,
+                logger: log,
             });
             if (stackResponse.ok) {
-                if (v)
-                    log(`Deployment "Stack" ${niceId(stackId)} ready`);
+                log.verbose(`Deployment "Stack" ${niceId(stackId)} ready`);
                 diagnostics.stackReady = true;
                 diagnostics.userHasAccess = true;
             }

package/dist/cores/blueprints/info.js

@@ -8,9 +8,9 @@ export async function blueprintInfoCore(options) {
         const targetStackId = flagStackId || stackId;
         let stack = deployedStack;
         if (flagStackId) {
-            const existingStackResponse = await getStack({ stackId: targetStackId, auth });
+            const existingStackResponse = await getStack({ stackId: targetStackId, auth, logger: log });
             if (!existingStackResponse.ok) {
-                log(`Could not retrieve Stack deployment info for ${niceId(targetStackId)}`);
+                log.error(`Could not retrieve Stack deployment info for ${niceId(targetStackId)}`);
                 return {
                     success: false,
                     error: existingStackResponse.error || 'Failed to retrieve Stack deployment',
@@ -25,7 +25,7 @@ export async function blueprintInfoCore(options) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Error: ${errorMessage}`);
+        log.error(`Error: ${errorMessage}`);
         return {
             success: false,
             error: errorMessage,

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

@@ -33,13 +33,13 @@ export declare function resolveScopeAndStack(params: {
     organizationId: string | undefined;
     stackId: string | undefined;
     stackName: string | undefined;
-    log: (message: string) => void;
+    log: CoreConfig['log'];
     token: string;
 }): Promise<ResolvedScope>;
 export declare function determineBlueprintExtension(params: {
     requestedType: string | undefined;
     blueprintDir: string;
-    log: (message: string) => void;
+    log: CoreConfig['log'];
 }): Promise<string>;
 export declare function createBlueprintFiles(params: {
     blueprintDir: string;
@@ -49,6 +49,6 @@ export declare function createBlueprintFiles(params: {
     scopeId: string;
     stackId: string | undefined;
     bin: string;
-    log: (message: string) => void;
+    log: CoreConfig['log'];
 }): Promise<CoreResult>;
 export {};

package/dist/cores/blueprints/init.js

@@ -33,7 +33,7 @@ export async function blueprintInitCore(options) {
         // look for existing blueprint file and maybe re-configure it
         const existingBlueprintFile = findBlueprintFile(blueprintDir);
         if (existingBlueprintFile) {
-            log(warn(`Existing Blueprint found: ${filePathRelativeToCwd(existingBlueprintFile.blueprintFilePath)}`));
+            log.warn(warn(`Existing Blueprint found: ${filePathRelativeToCwd(existingBlueprintFile.blueprintFilePath)}`));
             if (flagExample) {
                 return {
                     success: false,
@@ -54,7 +54,7 @@ export async function blueprintInitCore(options) {
                 if (!overwrite)
                     return { success: false, error: 'Initialization cancelled.' };
             }
-            const existingBlueprint = await readLocalBlueprint(existingBlueprintFile.blueprintFilePath);
+            const existingBlueprint = await readLocalBlueprint(log, existingBlueprintFile.blueprintFilePath);
             return blueprintConfigCore({
                 blueprint: existingBlueprint,
                 bin,
@@ -121,16 +121,21 @@ export function validateFlags(flags) {
 async function handleExampleInitialization(options) {
     const { exampleName, blueprintDir, userProvidedDirName, projectId, token, log } = options;
     log(warn(`Example feature is experimental. Setting up "${exampleName}"...`));
-    const exampleExists = await verifyExampleExists({ type: 'blueprint', name: exampleName });
+    const exampleExists = await verifyExampleExists({
+        type: 'blueprint',
+        name: exampleName,
+        logger: log,
+    });
     if (!exampleExists) {
         return { success: false, error: `Blueprint example "${exampleName}" does not exist.` };
     }
-    const resolvedProjectId = projectId || (await promptForProject({ token })).projectId;
+    const resolvedProjectId = projectId || (await promptForProject({ token, logger: log })).projectId;
     const stack = await createEmptyStack({
         token,
         scopeType: SCOPE_PROJECT,
         scopeId: resolvedProjectId,
         name: `example-${exampleName}`,
+        logger: log,
     });
     const exampleDir = userProvidedDirName || join(blueprintDir, exampleName);
     if (existsSync(exampleDir)) {
@@ -140,6 +145,7 @@ async function handleExampleInitialization(options) {
         exampleType: 'blueprint',
         exampleName,
         dir: exampleDir,
+        logger: log,
     });
     if (!addedExample) {
         return { success: false, error: `Unable to download example "${exampleName}"` };
@@ -184,18 +190,19 @@ export async function resolveScopeAndStack(params) {
             scopeType,
             scopeId,
             name: stackName,
+            logger: log,
         });
         resolvedStackId = stack.id;
     }
     if (!scopeId) {
         log('\nBlueprints are associated with a Sanity Project. Please select one:');
-        const pickedProject = await promptForProject({ token });
+        const pickedProject = await promptForProject({ token, logger: log });
         scopeType = SCOPE_PROJECT;
         scopeId = pickedProject.projectId;
     }
     if (!resolvedStackId) {
         log('\nBlueprints are deployed to a "Stack".');
-        const { stackId } = await promptForStack({ projectId: scopeId, token });
+        const { stackId } = await promptForStack({ projectId: scopeId, token, logger: log });
         resolvedStackId = stackId;
     }
     return {
@@ -252,11 +259,11 @@ export async function createBlueprintFiles(params) {
     if (blueprintExtension !== 'json') {
         const blueprintsPackage = '@sanity/blueprints';
         try {
-            await writeOrUpdateNodeDependency(blueprintFilePath, blueprintsPackage);
+            await writeOrUpdateNodeDependency(blueprintFilePath, blueprintsPackage, log);
             log(check(`${chalk.bold('Added dependency:')}    ${blueprintsPackage}`));
         }
         catch {
-            log(warn(`Unable to add ${blueprintsPackage} to your project.`));
+            log.warn(warn(`Unable to add ${blueprintsPackage} to your project.`));
         }
     }
     const nextStepParts = [];