@sanity/runtime-cli 12.3.0 → 13.0.0

package/dist/commands/blueprints/init.js

@@ -1,8 +1,17 @@
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
+import { baseFlags, RuntimeCommand, unhide } from '../../baseCommands.js';
 import { blueprintInitCore } from '../../cores/blueprints/init.js';
+import { Logger } from '../../utils/logger.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class InitCommand extends Command {
-    static description = 'Initialize a new Blueprint Stack deployment';
+export default class InitCommand extends RuntimeCommand {
+    static summary = 'Initialize a local Blueprint and optionally provision a remote Stack deployment';
+    static description = `A Blueprint is your local infrastructure-as-code configuration that defines Sanity resources (datasets, functions, etc.). A Stack is the remote deployment target where your Blueprint is applied.
+[NOTE: Currently, accounts are limited to three (3) Stacks per project scope.]
+
+This is typically the first command you run in a new project. It creates a local Blueprint manifest file (sanity.blueprint.ts, .js, or .json) and provisions a new remote Stack.
+Additionally, a Blueprint configuration file is created in .sanity/ containing the scope and Stack IDs. This is .gitignored by default.
+
+After initialization, use 'blueprints plan' to preview changes, then 'blueprints deploy' to apply them.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> [directory]',
@@ -12,58 +21,55 @@ export default class InitCommand extends Command {
     ];
     static args = {
         dir: Args.string({
-            description: 'Directory to create the Blueprint in',
+            description: 'Directory to create the local Blueprint in',
         }),
     };
     static flags = {
         dir: Flags.string({
-            description: 'Directory to create the Blueprint in',
+            description: 'Directory to create the local Blueprint in',
         }),
         example: Flags.string({
-            description: 'Example to use for the Blueprint',
+            description: 'Example to use for the local Blueprint',
             aliases: ['recipe'],
             exclusive: ['blueprint-type', 'stack-id', 'stack-name'], // set automatically
         }),
         'blueprint-type': Flags.string({
-            description: 'Blueprint manifest type to use for the Blueprint',
+            description: 'Blueprint manifest type to use for the local Blueprint',
             options: ['json', 'js', 'ts'],
             aliases: ['type'],
         }),
         'project-id': Flags.string({
-            description: 'Sanity Project ID to use for the Blueprint',
+            description: 'Sanity project ID used to scope local Blueprint and remote Stack',
             aliases: ['project', 'projectId'],
         }),
         'organization-id': Flags.string({
-            description: 'Sanity Organization ID to use for the Blueprint',
+            description: 'Sanity organization ID used to scope local Blueprint and remote Stack',
             aliases: ['organization', 'organizationId', 'org'],
         }),
         'stack-id': Flags.string({
-            description: 'Existing Stack ID to use for the Blueprint',
+            description: 'Existing Stack ID used to scope local Blueprint',
             aliases: ['stack', 'stackId'],
             dependsOn: ['project-id'],
             exclusive: ['stack-name'],
         }),
         'stack-name': Flags.string({
-            description: 'Name to use for a NEW Stack',
+            description: 'Name to use for a new Stack provisioned during initialization',
             aliases: ['name'],
             exclusive: ['stack-id'],
         }),
-        verbose: Flags.boolean({
-            description: 'Verbose output',
-            default: false,
-        }),
+        verbose: unhide(baseFlags.verbose),
     };
     async run() {
-        const { args, flags } = await this.parse(InitCommand);
-        const result = await validTokenOrErrorMessage();
+        const log = Logger(this.log.bind(this), this.flags);
+        const result = await validTokenOrErrorMessage(log);
         if (!result.ok)
             this.error(result.error.message);
         const { success, error } = await blueprintInitCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log,
             token: result.value,
-            args,
-            flags,
+            args: this.args,
+            flags: this.flags,
         });
         if (!success)
             this.error(error);

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

@@ -1,5 +1,6 @@
-import { DeployedBlueprintCommand } from '../../baseCommands.js';
-export default class LogsCommand extends DeployedBlueprintCommand<typeof LogsCommand> {
+import { DeployedStackCommand } from '../../baseCommands.js';
+export default class LogsCommand extends DeployedStackCommand<typeof LogsCommand> {
+    static summary: string;
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/blueprints/logs.js

@@ -1,8 +1,14 @@
 import { Flags } from '@oclif/core';
-import { DeployedBlueprintCommand } from '../../baseCommands.js';
+import { DeployedStackCommand } from '../../baseCommands.js';
 import { blueprintLogsCore } from '../../cores/blueprints/logs.js';
-export default class LogsCommand extends DeployedBlueprintCommand {
-    static description = 'Display logs for a Blueprint Stack deployment';
+import { Logger } from '../../utils/logger.js';
+export default class LogsCommand extends DeployedStackCommand {
+    static summary = "Display logs for the current Blueprint's Stack deployment";
+    static description = `Retrieves Stack deployment logs, useful for debugging and monitoring deployment activity.
+
+Use --watch (-w) to stream logs in real-time.
+
+If you're not seeing expected logs, verify your Stack is deployed with 'blueprints info'.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --watch',
@@ -17,7 +23,7 @@ export default class LogsCommand extends DeployedBlueprintCommand {
     async run() {
         const { success, streaming, error } = await blueprintLogsCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             auth: this.auth,
             stackId: this.stackId,
             deployedStack: this.deployedStack,

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

@@ -1,5 +1,6 @@
-import { BlueprintCommand } from '../../baseCommands.js';
-export default class PlanCommand extends BlueprintCommand<typeof PlanCommand> {
+import { LocalBlueprintCommand } from '../../baseCommands.js';
+export default class PlanCommand extends LocalBlueprintCommand<typeof PlanCommand> {
+    static summary: string;
     static description: string;
     static examples: string[];
     run(): Promise<void>;

package/dist/commands/blueprints/plan.js

@@ -1,12 +1,16 @@
-import { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintPlanCore } from '../../cores/blueprints/plan.js';
-export default class PlanCommand extends BlueprintCommand {
-    static description = 'Enumerate resources to be deployed - will not modify any resources';
+import { Logger } from '../../utils/logger.js';
+export default class PlanCommand extends LocalBlueprintCommand {
+    static summary = 'Enumerate resources to be deployed to the remote Stack - will not modify any resources';
+    static description = `Use this command to preview what changes will be applied to your remote Stack before deploying. This is a safe, read-only operation—no resources are created, modified, or deleted.
+
+Run 'blueprints plan' after making local changes to your Blueprint manifest to verify the expected diff. When ready, run 'blueprints deploy' to apply changes.`;
     static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
         const { success, error } = await blueprintPlanCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             token: this.sanityToken,
             blueprint: this.blueprint,
             flags: this.flags,

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

@@ -1,5 +1,6 @@
-import { BlueprintCommand } from '../../baseCommands.js';
-export default class StacksCommand extends BlueprintCommand<typeof StacksCommand> {
+import { LocalBlueprintCommand } from '../../baseCommands.js';
+export default class StacksCommand extends LocalBlueprintCommand<typeof StacksCommand> {
+    static summary: string;
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/blueprints/stacks.js

@@ -1,8 +1,12 @@
 import { Flags } from '@oclif/core';
-import { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintStacksCore } from '../../cores/blueprints/stacks.js';
-export default class StacksCommand extends BlueprintCommand {
-    static description = 'List all Blueprint Stacks';
+import { Logger } from '../../utils/logger.js';
+export default class StacksCommand extends LocalBlueprintCommand {
+    static summary = "List all remote Stack deployments (defaults to the current Blueprint's project scope)";
+    static description = `Shows all Stacks associated with a project or organization. By default, lists Stacks scoped to the local Blueprint.
+
+Use this to discover existing Stacks you can scope a local Blueprint to (using 'blueprints config --edit'), or to audit what's deployed across your project.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --project-id <projectId>',
@@ -10,12 +14,12 @@ export default class StacksCommand extends BlueprintCommand {
     ];
     static flags = {
         'project-id': Flags.string({
-            description: 'Project ID to show stacks for',
+            description: 'Project ID to show Stack deployments for',
             aliases: ['projectId', 'project'],
             exclusive: ['organization-id'],
         }),
         'organization-id': Flags.string({
-            description: 'Organization ID to show stacks for',
+            description: 'Organization ID to show Stack deployments for',
             aliases: ['organizationId', 'organization', 'org'],
             exclusive: ['project-id'],
         }),
@@ -23,7 +27,7 @@ export default class StacksCommand extends BlueprintCommand {
     async run() {
         const { success, error } = await blueprintStacksCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             token: this.sanityToken,
             blueprint: this.blueprint,
             flags: this.flags,

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

@@ -1,5 +1,6 @@
-import { BlueprintCommand } from '../../baseCommands.js';
-export default class AddCommand extends BlueprintCommand<typeof AddCommand> {
+import { LocalBlueprintCommand } from '../../baseCommands.js';
+export default class AddCommand extends LocalBlueprintCommand<typeof AddCommand> {
+    static summary: string;
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/functions/add.js

@@ -1,8 +1,14 @@
 import { Flags } from '@oclif/core';
-import { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionAddCore } from '../../cores/functions/index.js';
-export default class AddCommand extends BlueprintCommand {
-    static description = 'Add a Function to your Blueprint';
+import { Logger } from '../../utils/logger.js';
+export default class AddCommand extends LocalBlueprintCommand {
+    static summary = 'Add a Function to your Blueprint';
+    static description = `Scaffolds a new Function in the functions/ folder and templates a resource for your Blueprint manifest.
+
+Functions are serverless handlers triggered by document events (create, update, delete, publish) or media library events.
+
+After adding, use 'functions dev' to test locally, then 'blueprints deploy' to publish.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --helpers',
@@ -63,7 +69,7 @@ export default class AddCommand extends BlueprintCommand {
     async run() {
         const { success, error } = await functionAddCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             blueprint: this.blueprint,
             flags: this.flags,
         });

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

@@ -1,5 +1,6 @@
-import { BlueprintCommand } from '../../baseCommands.js';
-export default class DevCommand extends BlueprintCommand<typeof DevCommand> {
+import { LocalBlueprintCommand } from '../../baseCommands.js';
+export default class DevCommand extends LocalBlueprintCommand<typeof DevCommand> {
+    static summary: string;
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/functions/dev.js

@@ -1,9 +1,20 @@
 import { Flags } from '@oclif/core';
-import { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionDevCore } from '../../cores/functions/dev.js';
-export default class DevCommand extends BlueprintCommand {
-    static description = 'Start the Sanity Function emulator';
-    static examples = ['<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 8974'];
+import { Logger } from '../../utils/logger.js';
+export default class DevCommand extends LocalBlueprintCommand {
+    static summary = 'Start the Sanity Function emulator';
+    static description = `Runs a local, web-based development server to test your functions before deploying.
+
+Open the emulator in your browser to interactively test your functions with the payload editor.
+
+Optionally, set the host and port with the --host and --port flags. Function timeout can be configured with the --timeout flag.
+
+To invoke a function with the CLI, use 'functions test'.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 8974',
+        '<%= config.bin %> <%= command.id %> --timeout 60',
+    ];
     static flags = {
         host: Flags.string({
             char: 'h',
@@ -25,7 +36,7 @@ export default class DevCommand extends BlueprintCommand {
         const { flags } = await this.parse(DevCommand);
         const { success, error, streaming } = await functionDevCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             flags,
         });
         if (!success)

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

@@ -1,11 +1,12 @@
-import { DeployedBlueprintCommand } from '../../../baseCommands.js';
-export default class EnvAddCommand extends DeployedBlueprintCommand<typeof EnvAddCommand> {
+import { DeployedStackCommand } from '../../../baseCommands.js';
+export default class EnvAddCommand extends DeployedStackCommand<typeof EnvAddCommand> {
+    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>>;
         value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
-    static description: string;
     static examples: string[];
     run(): Promise<void>;
 }

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

@@ -1,20 +1,24 @@
 import { Args } from '@oclif/core';
-import { DeployedBlueprintCommand } from '../../../baseCommands.js';
+import { DeployedStackCommand } from '../../../baseCommands.js';
 import { functionEnvAddCore } from '../../../cores/functions/env/add.js';
-export default class EnvAddCommand extends DeployedBlueprintCommand {
+import { Logger } from '../../../utils/logger.js';
+export default class EnvAddCommand extends DeployedStackCommand {
+    static summary = 'Add or set an environment variable for a deployed function';
+    static description = `Sets an environment variable in a deployed Sanity Function. If the variable already exists, its value is updated.
+
+Environment variables are useful for API keys, configuration values, and other secrets that shouldn't be hardcoded. Changes take effect on the next function invocation.`;
     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 }),
         value: Args.string({ description: 'The value of the environment variable', required: true }),
     };
-    static description = 'Add or set the value of an environment variable for a Sanity function';
     static examples = [
         '<%= config.bin %> <%= command.id %> MyFunction API_URL https://api.example.com/',
     ];
     async run() {
         const { success, error } = await functionEnvAddCore({
             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/list.d.ts

@@ -1,9 +1,10 @@
-import { DeployedBlueprintCommand } from '../../../baseCommands.js';
-export default class EnvListCommand extends DeployedBlueprintCommand<typeof EnvListCommand> {
+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 { DeployedBlueprintCommand } from '../../../baseCommands.js';
+import { DeployedStackCommand } from '../../../baseCommands.js';
 import { functionEnvListCore } from '../../../cores/functions/env/list.js';
-export default class EnvListCommand extends DeployedBlueprintCommand {
+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 { DeployedBlueprintCommand } from '../../../baseCommands.js';
-export default class EnvRemoveCommand extends DeployedBlueprintCommand<typeof EnvRemoveCommand> {
+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 { DeployedBlueprintCommand } from '../../../baseCommands.js';
+import { DeployedStackCommand } from '../../../baseCommands.js';
 import { functionEnvRemoveCore } from '../../../cores/functions/env/remove.js';
-export default class EnvRemoveCommand extends DeployedBlueprintCommand {
+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 { DeployedBlueprintCommand } from '../../baseCommands.js';
-export default class LogsCommand extends DeployedBlueprintCommand<typeof LogsCommand> {
+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, Record<string, unknown>>;
+        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 { DeployedBlueprintCommand } from '../../baseCommands.js';
+import { DeployedStackCommand } from '../../baseCommands.js';
 import { functionLogsCore } from '../../cores/functions/logs.js';
-export default class LogsCommand extends DeployedBlueprintCommand {
+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: true }),
+        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',
@@ -50,7 +54,8 @@ export default class LogsCommand extends DeployedBlueprintCommand {
     async run() {
         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: this.args,
             flags: this.flags,
             auth: this.auth,
@@ -60,6 +65,7 @@ export default class LogsCommand extends DeployedBlueprintCommand {
             scopeId: this.scopeId,
             token: this.sanityToken,
             stackId: this.stackId,
+            helpText: LogsCommand.getHelpText(this.config.bin, 'functions logs'),
         });
         if (!success)
             this.error(error);

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

@@ -1,9 +1,10 @@
-import { BlueprintCommand } from '../../baseCommands.js';
-export default class TestCommand extends BlueprintCommand<typeof TestCommand> {
+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, Record<string, unknown>>;
+        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 { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionTestCore } from '../../cores/functions/test.js';
-export default class TestCommand extends BlueprintCommand {
+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: true }),
+        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'`,
@@ -151,6 +155,7 @@ export default class TestCommand extends BlueprintCommand {
         }),
     };
     async run() {
+        const { name } = this.args;
         if (this.flags.event === 'update') {
             const hasDataPair = this.flags['data-before'] && this.flags['data-after'];
             const hasFilePair = this.flags['file-before'] && this.flags['file-after'];
@@ -164,10 +169,12 @@ export default class TestCommand extends BlueprintCommand {
         }
         const { success, error } = await functionTestCore({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
-            args: this.args,
+            log: Logger(this.log.bind(this), this.flags),
+            error: (msg, options) => this.error(msg, options),
+            args: { ...this.args, name },
             flags: this.flags,
             blueprint: this.blueprint,
+            helpText: TestCommand.getHelpText(this.config.bin, 'functions test'),
         });
         if (!success)
             this.error(error);

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

@@ -1,8 +1,5 @@
-import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
-import type { CoreConfig, CoreResult } from '../index.js';
-export interface BlueprintConfigOptions extends CoreConfig {
-    token: string;
-    blueprint: ReadBlueprintResult;
+import type { BlueprintConfig, CoreResult } from '../index.js';
+export interface BlueprintConfigOptions extends BlueprintConfig {
     flags: {
         edit?: boolean;
         'project-id'?: string;

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)}`);