@sanity/runtime-cli 12.4.0 → 13.0.1

package/dist/baseCommands.js

@@ -1,6 +1,7 @@
 // * https://oclif.io/docs/base_class
 import { Command, CommandHelp, Flags as OclifFlags } from '@oclif/core';
 import { initBlueprintConfig, initDeployedBlueprintConfig } from './cores/index.js';
+import { Logger } from './utils/logger.js';
 const hidden = true;
 export const baseFlags = {
     json: OclifFlags.boolean({
@@ -12,6 +13,11 @@ export const baseFlags = {
         description: 'Path to the directory containing the Blueprint',
         hidden,
     }),
+    trace: OclifFlags.boolean({
+        description: 'Trace output',
+        default: false,
+        hidden,
+    }),
     verbose: OclifFlags.boolean({
         description: 'Verbose output',
         default: false,
@@ -104,7 +110,7 @@ export class LocalBlueprintCommand extends RuntimeCommand {
         await super.init();
         const result = await initBlueprintConfig({
             bin: this.config.bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
         });
         if (!result.ok) {
             this.error(result.error);
@@ -139,7 +145,7 @@ export class DeployedStackCommand extends LocalBlueprintCommand {
         const result = await initDeployedBlueprintConfig({
             bin: this.config.bin,
             blueprint: this.blueprint,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             token: this.sanityToken,
             validateToken: false,
         });

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

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

package/dist/commands/blueprints/add.js

@@ -6,13 +6,17 @@
 import { Args, Flags } from '@oclif/core';
 import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionAddCore } from '../../cores/functions/index.js';
+import { Logger } from '../../utils/logger.js';
 // import {warn} from '../../utils/display/presenters.js'
 export default class AddCommand extends LocalBlueprintCommand {
     // static state = 'deprecated'
     // static deprecationOptions = {
     //   message: '`blueprints add` is deprecated. Use `functions add` instead.',
     // }
-    static description = 'Add a Resource to a Blueprint';
+    static summary = 'Add a function resource to a Blueprint';
+    static description = `Scaffolds a new Sanity Function in your Blueprint. Functions are serverless handlers triggered by document events (create, update, delete, publish) or media library events.
+
+After adding a function, use 'functions dev' to test locally, then 'blueprints deploy' to publish it.`;
     static examples = [
         '<%= config.bin %> <%= command.id %> function',
         '<%= config.bin %> <%= command.id %> function --helpers',
@@ -22,19 +26,19 @@ export default class AddCommand extends LocalBlueprintCommand {
     ];
     static args = {
         type: Args.string({
-            description: 'Type of Resource to add (e.g. function)',
+            description: 'Type of resource to add (only "function" is supported)',
             options: ['function'],
             required: true,
         }),
     };
     static flags = {
         example: Flags.string({
-            description: 'Example to use for the Resource',
+            description: 'Example to use for the function resource. Discover examples at https://www.sanity.io/exchange/type=recipes/by=sanity',
             aliases: ['recipe'],
             exclusive: ['name', 'fn-type', 'language', 'javascript', 'fn-helpers', 'fn-installer'],
         }),
         name: Flags.string({
-            description: 'Name of the Resource to add',
+            description: 'Name of the resource to add',
             char: 'n',
         }),
         'fn-type': Flags.string({
@@ -54,7 +58,7 @@ export default class AddCommand extends LocalBlueprintCommand {
             dependsOn: ['name'],
         }),
         language: Flags.string({
-            description: 'Language of the new Function',
+            description: 'Language of the new function',
             aliases: ['function-language', 'fn-language', 'lang'],
             options: ['ts', 'js'],
             default: 'ts',
@@ -65,12 +69,12 @@ export default class AddCommand extends LocalBlueprintCommand {
             exclusive: ['language'],
         }),
         'fn-helpers': Flags.boolean({
-            description: 'Add helpers to the new Function',
+            description: 'Add helpers to the new function',
             aliases: ['function-helpers', 'helpers'],
             allowNo: true,
         }),
         'fn-installer': Flags.string({
-            description: 'How to install the @sanity/functions helpers',
+            description: 'Which package manager to use when installing the @sanity/functions helpers',
             aliases: ['function-installer', 'installer'],
             options: ['skip', 'npm', 'pnpm', 'yarn'],
         }),
@@ -92,7 +96,7 @@ export default class AddCommand extends LocalBlueprintCommand {
         // )
         const { success, error } = await functionAddCore({
             bin,
-            log: (msg) => this.log(msg),
+            log: Logger(this.log.bind(this), this.flags),
             blueprint,
             flags: {
                 example: flags.example,

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

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

package/dist/commands/blueprints/config.js

@@ -1,8 +1,14 @@
 import { Flags } from '@oclif/core';
 import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintConfigCore } from '../../cores/blueprints/config.js';
+import { Logger } from '../../utils/logger.js';
 export default class ConfigCommand extends LocalBlueprintCommand {
-    static description = 'View or edit Blueprint configuration';
+    static summary = 'View or edit the local Blueprint configuration';
+    static description = `Manages the local Blueprint configuration, which links your Blueprint to a Sanity project and Stack.
+
+Without flags, displays the current configuration. Use --edit to interactively modify settings, or combine --edit with ID flags to update values directly (useful for scripting and automation).
+
+If you need to switch your Blueprint to a different Stack, use --edit --stack-id.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --edit',
@@ -16,12 +22,12 @@ export default class ConfigCommand extends LocalBlueprintCommand {
             default: false,
         }),
         'project-id': Flags.string({
-            description: 'Directly set the Project ID in the configuration. Requires --edit flag',
+            description: 'Directly set the project ID in the configuration. Requires --edit flag',
             aliases: ['project', 'projectId'],
             dependsOn: ['edit'],
         }),
         'organization-id': Flags.string({
-            description: 'Directly set the Organization ID in the configuration. Requires --edit flag',
+            description: 'Directly set the organization ID in the configuration. Requires --edit flag',
             aliases: ['organization', 'organizationId', 'org'],
             dependsOn: ['edit'],
         }),
@@ -34,7 +40,7 @@ export default class ConfigCommand extends LocalBlueprintCommand {
     async run() {
         const { success, error } = await blueprintConfigCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             blueprint: this.blueprint,
             token: this.sanityToken,
             flags: this.flags,

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

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

package/dist/commands/blueprints/deploy.js

@@ -1,8 +1,14 @@
 import { Flags } from '@oclif/core';
 import { DeployedStackCommand } from '../../baseCommands.js';
 import { blueprintDeployCore } from '../../cores/blueprints/deploy.js';
+import { Logger } from '../../utils/logger.js';
 export default class DeployCommand extends DeployedStackCommand {
-    static description = 'Deploy a Blueprint';
+    static summary = 'Deploy the local Blueprint to the remote Stack';
+    static 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.
+
+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.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --no-wait',
@@ -16,7 +22,7 @@ export default class DeployCommand extends DeployedStackCommand {
     async run() {
         const { success, error } = await blueprintDeployCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             auth: this.auth,
             stackId: this.stackId,
             scopeType: this.scopeType,

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

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

package/dist/commands/blueprints/destroy.js

@@ -1,8 +1,14 @@
 import { Flags } from '@oclif/core';
 import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintDestroyCore } from '../../cores/blueprints/destroy.js';
+import { Logger } from '../../utils/logger.js';
 export default class DestroyCommand extends LocalBlueprintCommand {
-    static description = 'Destroy a Blueprint Stack deployment and its resources (will not delete local files)';
+    static summary = 'Destroy the remote Stack deployment and its resources (will not delete local files)';
+    static description = `Permanently removes the remote Stack and all its provisioned resources. Your local Blueprint files remain untouched, allowing you to redeploy later with 'blueprints init' + 'blueprints deploy'.
+
+This is a destructive operation. You will be prompted to confirm unless --force is specified.
+
+Use this to clean up test environments or decommission a Stack you no longer need.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack-id <stackId> --project-id <projectId> --force --no-wait',
@@ -37,7 +43,7 @@ export default class DestroyCommand extends LocalBlueprintCommand {
     async run() {
         const { success, error } = await blueprintDestroyCore({
             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/doctor.d.ts

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

package/dist/commands/blueprints/doctor.js

@@ -2,8 +2,13 @@ import { Flags } from '@oclif/core';
 import { baseFlags, RuntimeCommand, unhide } from '../../baseCommands.js';
 import config from '../../config.js';
 import { blueprintDoctorCore } from '../../cores/blueprints/doctor.js';
+import { Logger } from '../../utils/logger.js';
 export default class DoctorCommand extends RuntimeCommand {
-    static description = 'Diagnose potential issues with Blueprint configuration';
+    static summary = 'Diagnose potential issues with local Blueprint and remote Stack configuration';
+    static description = `Analyzes your local Blueprint and remote Stack configuration for common issues, such as missing authentication, invalid project references, or misconfigured resources.
+
+Run this command when encountering errors with other Blueprint commands. Use --fix to interactively resolve detected issues.`;
+    // TODO: add "Supports --json for programmatic consumption of diagnostic results." to help text
     static examples = [];
     static flags = {
         path: unhide(baseFlags.path),
@@ -18,7 +23,7 @@ export default class DoctorCommand extends RuntimeCommand {
         const { token } = config;
         const result = await blueprintDoctorCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             token,
             flags: this.flags,
         });

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

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

package/dist/commands/blueprints/info.js

@@ -1,21 +1,27 @@
 import { Flags } from '@oclif/core';
 import { DeployedStackCommand } from '../../baseCommands.js';
 import { blueprintInfoCore } from '../../cores/blueprints/info.js';
+import { Logger } from '../../utils/logger.js';
 export default class InfoCommand extends DeployedStackCommand {
-    static description = 'Show information about a Blueprint Stack deployment';
+    static summary = "Show information about the local Blueprint's remote Stack deployment";
+    static description = `Displays the current state and metadata of your remote Stack deployment, including deployed resources, status, and configuration.
+
+Use this command to verify a deployment succeeded, check what resources are live, or confirm which Stack your local Blueprint is connected to.
+
+Run 'blueprints stacks' to see all available Stacks in your project or organization.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --id <stackId>',
     ];
     static flags = {
         id: Flags.string({
-            description: 'Stack ID to show info for (defaults to current Stack)',
+            description: 'Stack ID to show info for (defaults to the current Stack)',
         }),
     };
     async run() {
         const { success, error } = await blueprintInfoCore({
             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/init.d.ts

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

package/dist/commands/blueprints/init.js

@@ -1,9 +1,17 @@
 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 RuntimeCommand {
-    static description = 'Initialize a new Blueprint Stack deployment';
+    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]',
@@ -13,51 +21,52 @@ export default class InitCommand extends RuntimeCommand {
     ];
     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: unhide(baseFlags.verbose),
     };
     async run() {
-        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: this.args,
             flags: this.flags,

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

@@ -1,5 +1,6 @@
 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 { DeployedStackCommand } from '../../baseCommands.js';
 import { blueprintLogsCore } from '../../cores/blueprints/logs.js';
+import { Logger } from '../../utils/logger.js';
 export default class LogsCommand extends DeployedStackCommand {
-    static description = 'Display logs for a Blueprint Stack deployment';
+    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 DeployedStackCommand {
     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 { 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 { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintPlanCore } from '../../cores/blueprints/plan.js';
+import { Logger } from '../../utils/logger.js';
 export default class PlanCommand extends LocalBlueprintCommand {
-    static description = 'Enumerate resources to be deployed - will not modify any resources';
+    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 { 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 { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintStacksCore } from '../../cores/blueprints/stacks.js';
+import { Logger } from '../../utils/logger.js';
 export default class StacksCommand extends LocalBlueprintCommand {
-    static description = 'List all Blueprint Stacks';
+    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 LocalBlueprintCommand {
     ];
     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 LocalBlueprintCommand {
     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 { 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 { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionAddCore } from '../../cores/functions/index.js';
+import { Logger } from '../../utils/logger.js';
 export default class AddCommand extends LocalBlueprintCommand {
-    static description = 'Add a Function to your Blueprint';
+    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 LocalBlueprintCommand {
     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 { 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 { LocalBlueprintCommand } from '../../baseCommands.js';
 import { functionDevCore } from '../../cores/functions/dev.js';
+import { Logger } from '../../utils/logger.js';
 export default class DevCommand extends LocalBlueprintCommand {
-    static description = 'Start the Sanity Function emulator';
-    static examples = ['<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 8974'];
+    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 LocalBlueprintCommand {
         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 { 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 { DeployedStackCommand } from '../../../baseCommands.js';
 import { functionEnvAddCore } from '../../../cores/functions/env/add.js';
+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,