@sanity/runtime-cli 12.3.0 → 13.0.0

package/dist/actions/sanity/projects.js

@@ -1,9 +1,11 @@
 import config from '../../config.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 const { apiUrl } = config;
 export const projectsApiPath = `${apiUrl}v2021-06-07/projects`;
 export const orgsApiPath = `${apiUrl}v2021-06-07/organizations`;
-export async function listProjects({ token }) {
-    const projectsFetch = await fetch(projectsApiPath, {
+export async function listProjects({ token, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const projectsFetch = await fetchFn(projectsApiPath, {
         method: 'GET',
         headers: {
             Authorization: `Bearer ${token}`,
@@ -17,8 +19,9 @@ export async function listProjects({ token }) {
         projects,
     };
 }
-export async function groupProjectsByOrganization({ token, }) {
-    const projectsResponse = await listProjects({ token });
+export async function groupProjectsByOrganization({ token, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const projectsResponse = await listProjects({ token, logger });
     if (!projectsResponse.ok) {
         return {
             ok: false,
@@ -26,7 +29,7 @@ export async function groupProjectsByOrganization({ token, }) {
             organizations: [],
         };
     }
-    const orgsFetch = await fetch(orgsApiPath, {
+    const orgsFetch = await fetchFn(orgsApiPath, {
         method: 'GET',
         headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
     });
@@ -48,11 +51,12 @@ export async function groupProjectsByOrganization({ token, }) {
         organizations: orgsWithProjects,
     };
 }
-export async function getProject({ token, scopeId, scopeType, }) {
+export async function getProject({ token, scopeId, scopeType, logger, }) {
     if (scopeType !== 'project') {
         throw new Error('Scope type must be project');
     }
-    const response = await fetch(`${projectsApiPath}/${scopeId}`, {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${projectsApiPath}/${scopeId}`, {
         method: 'GET',
         headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
     });

package/dist/baseCommands.d.ts

@@ -2,19 +2,56 @@ import type { Interfaces } from '@oclif/core';
 import { Command } from '@oclif/core';
 import type { ReadBlueprintResult } from './actions/blueprints/blueprint.js';
 import type { AuthParams, ScopeType, Stack } from './utils/types.js';
-export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BlueprintCommand)['baseFlags'] & T['flags']>;
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof RuntimeCommand)['baseFlags'] & T['flags']>;
 export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare const baseFlags: {
+    json: Interfaces.BooleanFlag<boolean>;
+    path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    trace: Interfaces.BooleanFlag<boolean>;
+    verbose: Interfaces.BooleanFlag<boolean>;
+};
+/**
+ * @description Unhides a flag by setting its hidden property to false
+ * Also makes oclif's types happy when destructuring the flag
+ */
+export declare function unhide<T>(flag: T): T;
+/**
+ * @description Guarantees flags and args.
+ * Also centralizes baseFlags and enables oclif's built-in --json for all subclasses.
+ * @extends Command
+ */
+export declare abstract class RuntimeCommand<T extends typeof Command> extends Command {
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    static baseFlags: {
+        json: Interfaces.BooleanFlag<boolean>;
+        path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        trace: Interfaces.BooleanFlag<boolean>;
+        verbose: Interfaces.BooleanFlag<boolean>;
+    };
+    static enableJsonFlag: boolean;
+    /**
+     * Generates help text for this command class
+     * @param bin - The bin name to use for the help text; e.g. 'sanity', defaults to 'sanity-run'
+     * @param commandId - The sub-command to use for the help text; optional but recommended for better help text
+     * @returns The oclif-styled help text for the command
+     * @example const helpText = InfoCommand.getHelpText('sanity', 'blueprints info')
+     */
+    static getHelpText(bin?: string, commandId?: string): string;
+    init(): Promise<void>;
+}
 /**
  * @description Guarantees flags, args, sanityToken, and blueprint.
  * Blueprint parser errors are logged and the command exits with an error
- * @extends Command
+ * @extends RuntimeCommand
  */
-export declare abstract class BlueprintCommand<T extends typeof Command> extends Command {
+export declare abstract class LocalBlueprintCommand<T extends typeof Command> extends RuntimeCommand<T> {
     protected sanityToken: string;
     protected blueprint: ReadBlueprintResult;
-    protected flags: Flags<T>;
-    protected args: Args<T>;
     static baseFlags: {
+        json: Interfaces.BooleanFlag<boolean>;
+        path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        trace: Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
     };
     init(): Promise<void>;
@@ -26,15 +63,18 @@ export declare abstract class BlueprintCommand<T extends typeof Command> extends
 /**
  * @description Guarantees flags, args, sanityToken, blueprint, scopeType, scopeId, stackId, auth, and deployedStack.
  * If scope or stack is missing, the command exits with an error
- * @extends BlueprintCommand
+ * @extends LocalBlueprintCommand
  */
-export declare abstract class DeployedBlueprintCommand<T extends typeof Command> extends BlueprintCommand<T> {
+export declare abstract class DeployedStackCommand<T extends typeof Command> extends LocalBlueprintCommand<T> {
     protected auth: AuthParams;
     protected deployedStack: Stack;
     protected scopeType: ScopeType;
     protected scopeId: string;
     protected stackId: string;
     static baseFlags: {
+        json: Interfaces.BooleanFlag<boolean>;
+        path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        trace: Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
     };
     init(): Promise<void>;

package/dist/baseCommands.js

@@ -1,24 +1,89 @@
 // * https://oclif.io/docs/base_class
-import { Command, Flags as OclifFlags } from '@oclif/core';
+import { Command, CommandHelp, Flags as OclifFlags } from '@oclif/core';
 import { initBlueprintConfig, initDeployedBlueprintConfig } from './cores/index.js';
-const baseFlags = {
+import { Logger } from './utils/logger.js';
+const hidden = true;
+export const baseFlags = {
+    json: OclifFlags.boolean({
+        // override defaults from oclif's built-in --json flag
+        description: 'Format output as json.',
+        hidden,
+    }),
+    path: OclifFlags.string({
+        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,
-        hidden: true, // prevent help output on all commands
+        hidden,
     }),
 };
 /**
- * @description Guarantees flags, args, sanityToken, and blueprint.
- * Blueprint parser errors are logged and the command exits with an error
+ * @description Unhides a flag by setting its hidden property to false
+ * Also makes oclif's types happy when destructuring the flag
+ */
+export function unhide(flag) {
+    return { ...flag, hidden: false };
+}
+/**
+ * @description Guarantees flags and args.
+ * Also centralizes baseFlags and enables oclif's built-in --json for all subclasses.
  * @extends Command
  */
-export class BlueprintCommand extends Command {
-    sanityToken;
-    blueprint;
+export class RuntimeCommand extends Command {
     flags;
     args;
     static baseFlags = baseFlags;
+    static enableJsonFlag = true; // oclif's built-in --json flag
+    /**
+     * Generates help text for this command class
+     * @param bin - The bin name to use for the help text; e.g. 'sanity', defaults to 'sanity-run'
+     * @param commandId - The sub-command to use for the help text; optional but recommended for better help text
+     * @returns The oclif-styled help text for the command
+     * @example const helpText = InfoCommand.getHelpText('sanity', 'blueprints info')
+     */
+    static getHelpText(bin = 'sanity-run', commandId) {
+        // biome-ignore lint/complexity/noThisInStatic: this is this command class - not confusing
+        const thisClass = this;
+        const rawArgs = thisClass.args || {};
+        const args = Object.entries(rawArgs).reduce((acc, [name, arg]) => {
+            acc[name] = { ...arg, name };
+            return acc;
+        }, {});
+        const commandLoadable = {
+            //! required properties
+            id: commandId || thisClass.id || '',
+            flags: thisClass.flags || {},
+            args,
+            aliases: thisClass.aliases || [],
+            hidden: thisClass.hidden || false,
+            hiddenAliases: thisClass.hiddenAliases || [],
+            load: async () => thisClass,
+            //* optional properties
+            // bin, // seems to not be used in the CommandHelp class
+            // thisClass, // doesn't change the help text
+            help: thisClass.help,
+            usage: thisClass.usage,
+            examples: thisClass.examples,
+            description: thisClass.description,
+            summary: thisClass.summary,
+            state: thisClass.state,
+            deprecateAliases: thisClass.deprecateAliases,
+            deprecationOptions: thisClass.deprecationOptions,
+            strict: thisClass.strict,
+            hasDynamicHelp: thisClass.hasDynamicHelp,
+        };
+        const commandHelp = new CommandHelp(commandLoadable, { bin }, {
+            maxWidth: 120,
+        });
+        return commandHelp.generate();
+    }
     async init() {
         const { args, flags } = await this.parse({
             flags: this.ctor.flags,
@@ -30,9 +95,22 @@ export class BlueprintCommand extends Command {
         this.flags = flags;
         this.args = args;
         await super.init();
+    }
+}
+/**
+ * @description Guarantees flags, args, sanityToken, and blueprint.
+ * Blueprint parser errors are logged and the command exits with an error
+ * @extends RuntimeCommand
+ */
+export class LocalBlueprintCommand extends RuntimeCommand {
+    sanityToken;
+    blueprint;
+    static baseFlags = baseFlags;
+    async init() {
+        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);
@@ -53,9 +131,9 @@ export class BlueprintCommand extends Command {
 /**
  * @description Guarantees flags, args, sanityToken, blueprint, scopeType, scopeId, stackId, auth, and deployedStack.
  * If scope or stack is missing, the command exits with an error
- * @extends BlueprintCommand
+ * @extends LocalBlueprintCommand
  */
-export class DeployedBlueprintCommand extends BlueprintCommand {
+export class DeployedStackCommand extends LocalBlueprintCommand {
     auth;
     deployedStack;
     scopeType;
@@ -67,7 +145,7 @@ export class DeployedBlueprintCommand extends BlueprintCommand {
         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

@@ -3,8 +3,9 @@
  * @deprecated Use `functions add` instead.
  * We're in the process of deprecating the `blueprints add` command.
  */
-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 args: {

package/dist/commands/blueprints/add.js

@@ -4,15 +4,19 @@
  * We're in the process of deprecating the `blueprints add` command.
  */
 import { Args, Flags } from '@oclif/core';
-import { BlueprintCommand } from '../../baseCommands.js';
+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 BlueprintCommand {
+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 BlueprintCommand {
     ];
     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 BlueprintCommand {
             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 BlueprintCommand {
             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 BlueprintCommand {
         // )
         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 { BlueprintCommand } from '../../baseCommands.js';
-export default class ConfigCommand extends BlueprintCommand<typeof ConfigCommand> {
+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 { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintConfigCore } from '../../cores/blueprints/config.js';
-export default class ConfigCommand extends BlueprintCommand {
-    static description = 'View or edit Blueprint configuration';
+import { Logger } from '../../utils/logger.js';
+export default class ConfigCommand extends LocalBlueprintCommand {
+    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 BlueprintCommand {
             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 BlueprintCommand {
     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 { DeployedBlueprintCommand } from '../../baseCommands.js';
-export default class DeployCommand extends DeployedBlueprintCommand<typeof DeployCommand> {
+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 { DeployedBlueprintCommand } from '../../baseCommands.js';
+import { DeployedStackCommand } from '../../baseCommands.js';
 import { blueprintDeployCore } from '../../cores/blueprints/deploy.js';
-export default class DeployCommand extends DeployedBlueprintCommand {
-    static description = 'Deploy a Blueprint';
+import { Logger } from '../../utils/logger.js';
+export default class DeployCommand extends DeployedStackCommand {
+    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 DeployedBlueprintCommand {
     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 { BlueprintCommand } from '../../baseCommands.js';
-export default class DestroyCommand extends BlueprintCommand<typeof DestroyCommand> {
+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 { BlueprintCommand } from '../../baseCommands.js';
+import { LocalBlueprintCommand } from '../../baseCommands.js';
 import { blueprintDestroyCore } from '../../cores/blueprints/destroy.js';
-export default class DestroyCommand extends BlueprintCommand {
-    static description = 'Destroy a Blueprint Stack deployment and its resources (will not delete local files)';
+import { Logger } from '../../utils/logger.js';
+export default class DestroyCommand extends LocalBlueprintCommand {
+    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 BlueprintCommand {
     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,11 +1,13 @@
-import { Command } from '@oclif/core';
-export default class DoctorCommand extends Command {
+import { RuntimeCommand } from '../../baseCommands.js';
+export default class DoctorCommand extends RuntimeCommand<typeof DoctorCommand> {
+    static summary: string;
     static description: string;
     static examples: never[];
     static flags: {
-        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         fix: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/doctor.js

@@ -1,32 +1,35 @@
-import { Command, Flags } from '@oclif/core';
+import { Flags } from '@oclif/core';
+import { baseFlags, RuntimeCommand, unhide } from '../../baseCommands.js';
 import config from '../../config.js';
 import { blueprintDoctorCore } from '../../cores/blueprints/doctor.js';
-export default class DoctorCommand extends Command {
-    static description = 'Diagnose potential issues with Blueprint configuration';
+import { Logger } from '../../utils/logger.js';
+export default class DoctorCommand extends RuntimeCommand {
+    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 = {
-        verbose: Flags.boolean({
-            description: 'Provide detailed information about issues',
-            default: false,
-        }),
-        path: Flags.string({
-            description: 'Path to the Blueprint configuration file',
-        }),
+        path: unhide(baseFlags.path),
         fix: Flags.boolean({
             description: 'Interactively fix configuration issues',
             default: false,
         }),
+        json: unhide(baseFlags.json),
+        verbose: unhide(baseFlags.verbose),
     };
     async run() {
-        const { flags } = await this.parse(DoctorCommand);
         const { token } = config;
-        const { success, error } = await blueprintDoctorCore({
+        const result = await blueprintDoctorCore({
             bin: this.config.bin,
-            log: (message) => this.log(message),
+            log: Logger(this.log.bind(this), this.flags),
             token,
-            flags,
+            flags: this.flags,
         });
+        const { success, error } = result;
         if (!success)
             this.error(error);
+        return result.data;
     }
 }

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

@@ -1,5 +1,6 @@
-import { DeployedBlueprintCommand } from '../../baseCommands.js';
-export default class InfoCommand extends DeployedBlueprintCommand<typeof InfoCommand> {
+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 { DeployedBlueprintCommand } from '../../baseCommands.js';
+import { DeployedStackCommand } from '../../baseCommands.js';
 import { blueprintInfoCore } from '../../cores/blueprints/info.js';
-export default class InfoCommand extends DeployedBlueprintCommand {
-    static description = 'Show information about a Blueprint Stack deployment';
+import { Logger } from '../../utils/logger.js';
+export default class InfoCommand extends DeployedStackCommand {
+    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 { Command } from '@oclif/core';
-export default class InitCommand extends Command {
+import { RuntimeCommand } from '../../baseCommands.js';
+export default class InitCommand extends RuntimeCommand<typeof InitCommand> {
+    static summary: string;
     static description: string;
     static examples: string[];
     static args: {