@sanity/runtime-cli 14.11.0 → 14.12.1

package/dist/baseCommands.js

@@ -1,7 +1,12 @@
 // * https://oclif.io/docs/base_class
 import { Command, CommandHelp, Flags as OclifFlags } from '@oclif/core';
-import { initBlueprintConfig, initDeployedBlueprintConfig } from './cores/index.js';
+import { findBlueprintFile, loadBlueprintFile, parseBlueprintContent, } from './actions/blueprints/blueprint.js';
+import { backfillProjectBasedStackId, readConfigFile } from './actions/blueprints/config.js';
+import { resolveIds } from './actions/blueprints/resolve.js';
+import { getStack, resolveStackIdByNameOrId } from './actions/blueprints/stacks.js';
+import { presentBlueprintParserErrors } from './utils/display/errors.js';
 import { Logger } from './utils/logger.js';
+import { validTokenOrErrorMessage } from './utils/validated-token.js';
 /**
  * Fallback error-to-hint patterns for RuntimeCommand.catch().
  * Each entry maps a regex to a function that returns suggestion strings.
@@ -11,23 +16,25 @@ const CATCH_HINT_PATTERNS = [
 // Add patterns here as needed, for example:
 // [/scope/i, (bin) => [`Run \`npx ${bin} blueprints promote\` to change the Stack scope.`]],
 ];
-const hidden = true;
+export const pathFlagConfig = {
+    description: 'Path to a Blueprint file or directory containing one',
+    env: 'SANITY_BLUEPRINT_PATH',
+    aliases: ['blueprint-path'],
+    char: 'p',
+};
 export const baseFlags = {
     json: OclifFlags.boolean({
         // override defaults from oclif's built-in --json flag
         description: 'Format output as json',
     }),
     path: OclifFlags.string({
-        description: 'Path to a Blueprint file or directory containing one',
-        env: 'SANITY_BLUEPRINT_PATH',
-        aliases: ['blueprint-path'],
-        char: 'p',
-        hidden,
+        ...pathFlagConfig,
+        hidden: true,
     }),
     trace: OclifFlags.boolean({
         description: 'Trace output',
         default: false,
-        hidden,
+        hidden: true,
     }),
     'validate-resources': OclifFlags.boolean({
         description: 'Validate resources',
@@ -37,13 +44,12 @@ export const baseFlags = {
     verbose: OclifFlags.boolean({
         description: 'Verbose output',
         default: false,
-        hidden,
+        hidden: true,
     }),
 };
-export const stackFlag = OclifFlags.string({
+export const stackFlagConfig = {
     description: 'Stack name or ID to use instead of the locally configured Stack',
-    hidden: true,
-});
+};
 export const projectIdFlagConfig = {
     description: 'Sanity project ID used to scope Blueprint and Stack',
     aliases: ['project', 'projectId'],
@@ -52,13 +58,6 @@ export const organizationIdFlagConfig = {
     description: 'Sanity organization ID used to scope Blueprint and Stack',
     aliases: ['organization', 'organizationId', 'org'],
 };
-/**
- * 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 };
-}
 /**
  * Guarantees flags and args.
  * Also centralizes baseFlags and enables oclif's built-in --json for all subclasses.
@@ -155,69 +154,185 @@ export class RuntimeCommand extends Command {
     }
 }
 /**
- * Guarantees flags, args, sanityToken, and blueprint.
- * Blueprint parser errors are logged and the command exits with an error
+ * Base command that resolves context declaratively from a `static needs` array.
+ * Commands declare what they *directly use*; the base class resolves transitive
+ * dependencies automatically (e.g. 'deployedStack' implies token, scope, stackId).
+ *
+ * When a command needs only remote context (e.g. `['deployedStack']`),
+ * no local blueprint file is required -- flags and config are sufficient.
+ *
+ * @example
+ * ```ts
+ * class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
+ *   static needs = ['deployedStack'] as const
+ *   // token, scope, stackId resolved automatically
+ * }
+ * ```
+ *
  * @extends RuntimeCommand
  */
-export class LocalBlueprintCommand extends RuntimeCommand {
+export class ResolvedCommand extends RuntimeCommand {
+    static needs = [];
+    static baseFlags = {
+        ...baseFlags,
+        stack: OclifFlags.string({ ...stackFlagConfig, hidden: true }),
+        'project-id': OclifFlags.string({ ...projectIdFlagConfig, hidden: true }),
+        'organization-id': OclifFlags.string({ ...organizationIdFlagConfig, hidden: true }),
+    };
+    // Populated by init() according to `needs`
     sanityToken;
     blueprint;
-    static baseFlags = baseFlags;
-    async init() {
-        await super.init();
-        const result = await initBlueprintConfig({
-            bin: this.config.bin,
-            log: Logger(this.log.bind(this), this.flags),
-            validateResources: this.flags['validate-resources'],
-            blueprintPath: this.flags.path,
-        });
-        if (!result.ok) {
-            const suggestions = [];
-            if (/token|login/i.test(result.error)) {
-                suggestions.push('Run `npx @sanity/cli login` to authenticate.');
-            }
-            else if (/blueprint/i.test(result.error) && /error/i.test(result.error)) {
-                suggestions.push('Fix the Blueprint errors listed above.');
-            }
-            suggestions.push(`Run \`${this.config.bin} blueprints doctor\` to check your configuration.`);
-            this.error(result.error, { suggestions });
-        }
-        this.sanityToken = result.value.token;
-        this.blueprint = result.value.blueprint;
-    }
-}
-/**
- * Guarantees flags, args, sanityToken, blueprint, scopeType, scopeId, stackId, auth, and deployedStack.
- * If scope or stack is missing, the command exits with an error
- * @extends LocalBlueprintCommand
- */
-export class DeployedStackCommand extends LocalBlueprintCommand {
-    auth;
-    deployedStack;
     scopeType;
     scopeId;
     stackId;
-    static baseFlags = { ...baseFlags, stack: stackFlag };
+    auth;
+    deployedStack;
     async init() {
-        await super.init();
-        const result = await initDeployedBlueprintConfig({
-            bin: this.config.bin,
-            blueprint: this.blueprint,
-            log: Logger(this.log.bind(this), this.flags),
-            token: this.sanityToken,
-            validateToken: false,
-            validateResources: this.flags['validate-resources'],
-            stackOverride: this.flags.stack,
+        await super.init(); // RuntimeCommand: parse flags + args
+        const needs = new Set(this.constructor.needs);
+        if (needs.size === 0)
+            return;
+        const log = Logger(this.log.bind(this), this.flags);
+        const needsToken = needs.has('token') || needs.has('scope') || needs.has('stackId') || needs.has('deployedStack');
+        const needsScope = needs.has('scope') || needs.has('deployedStack');
+        const needsStack = needs.has('stackId') || needs.has('deployedStack');
+        const needsBlueprint = needs.has('blueprint');
+        const needsDeployedStack = needs.has('deployedStack');
+        // 1. Token
+        if (needsToken) {
+            const check = await validTokenOrErrorMessage(log);
+            if (!check.ok) {
+                this.error(check.error.message, {
+                    suggestions: ['Run `npx @sanity/cli login` to authenticate.'],
+                });
+            }
+            this.sanityToken = check.value;
+        }
+        // 2. Read config file (cheap single-file JSON read).
+        // Anchor to --path flag or the blueprint file location if found, else cwd.
+        const blueprintFileInfo = findBlueprintFile(this.flags.path);
+        const blueprintConfig = readConfigFile(blueprintFileInfo?.blueprintFilePath);
+        // 3. Blueprint (if needed)
+        let blueprintModule;
+        if (needsBlueprint) {
+            if (!blueprintFileInfo) {
+                this.error('Could not find Blueprint file! Use the `blueprints init` command.', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints init\` to create one.`,
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            const loaded = await loadBlueprintFile(blueprintFileInfo);
+            const parsed = parseBlueprintContent(loaded.rawBlueprint, {
+                validateResources: this.flags['validate-resources'],
+            });
+            if (parsed.errors.length > 0) {
+                log(presentBlueprintParserErrors(parsed.errors));
+                this.error('Blueprint file contains errors.', {
+                    suggestions: [
+                        'Fix the Blueprint errors listed above.',
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            blueprintModule = loaded.module;
+            // Assemble the full ReadBlueprintResult -- will be completed with resolved IDs below
+            this.blueprint = {
+                fileInfo: blueprintFileInfo,
+                blueprintConfig,
+                rawBlueprint: loaded.rawBlueprint,
+                ...parsed,
+            };
+        }
+        // 4. Resolve IDs
+        const resolved = resolveIds({
+            flags: {
+                projectId: this.flags['project-id'],
+                organizationId: this.flags['organization-id'],
+            },
+            module: blueprintModule,
+            config: blueprintConfig,
         });
-        if (!result.ok) {
-            this.error(result.error, {
-                suggestions: [`Run \`${this.config.bin} blueprints doctor\` to check your configuration.`],
+        // Legacy stack ID inference (only when we have a blueprint file path for the write side-effect)
+        if (!resolved.stackId && resolved.projectId && blueprintFileInfo) {
+            try {
+                const inferred = await backfillProjectBasedStackId({
+                    blueprintFilePath: blueprintFileInfo.blueprintFilePath,
+                    projectId: resolved.projectId,
+                    logger: log,
+                });
+                if (inferred) {
+                    resolved.stackId = inferred;
+                    resolved.sources.stackId = 'inferred';
+                }
+            }
+            catch {
+                // assumption was wrong; leave stackId undefined
+            }
+        }
+        // Backfill resolved IDs onto the blueprint result if it was loaded
+        if (this.blueprint) {
+            Object.assign(this.blueprint, {
+                organizationId: resolved.organizationId,
+                projectId: resolved.projectId,
+                stackId: resolved.stackId,
+                scopeType: resolved.scopeType,
+                scopeId: resolved.scopeId,
+                sources: resolved.sources,
             });
         }
-        this.scopeType = result.value.scopeType;
-        this.scopeId = result.value.scopeId;
-        this.stackId = result.value.stackId;
-        this.auth = result.value.auth;
-        this.deployedStack = result.value.deployedStack;
+        // 5. Scope
+        if (needsScope) {
+            if (!resolved.scopeType || !resolved.scopeId) {
+                this.error('Missing scope: provide --project-id or --organization-id, or configure a Blueprint.', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            this.scopeType = resolved.scopeType;
+            this.scopeId = resolved.scopeId;
+        }
+        // 6. Stack
+        if (needsStack) {
+            let { stackId } = resolved;
+            const stackOverride = this.flags.stack;
+            if (stackOverride) {
+                const auth = {
+                    token: this.sanityToken,
+                    scopeType: this.scopeType,
+                    scopeId: this.scopeId,
+                };
+                stackId = await resolveStackIdByNameOrId(stackOverride, auth, log);
+            }
+            if (!stackId) {
+                this.error('Missing Stack: provide --stack, or configure a Blueprint with a Stack.', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            this.stackId = stackId;
+        }
+        // 7. Auth
+        if (needsScope) {
+            this.auth = { token: this.sanityToken, scopeType: this.scopeType, scopeId: this.scopeId };
+        }
+        // 8. Deployed Stack
+        if (needsDeployedStack) {
+            const spinner = log.ora('Loading Stack deployment...').start();
+            const response = await getStack({ stackId: this.stackId, auth: this.auth, logger: log });
+            if (!response.ok) {
+                spinner.fail('Could not load Stack deployment');
+                this.error('Missing Stack deployment', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            spinner.stop().clear();
+            this.deployedStack = response.stack;
+        }
     }
 }

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 { LocalBlueprintCommand } from '../../baseCommands.js';
-export default class AddCommand extends LocalBlueprintCommand<typeof AddCommand> {
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class AddCommand extends ResolvedCommand<typeof AddCommand> {
+    static needs: readonly ["blueprint"];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/add.js

@@ -4,13 +4,14 @@
  * We're in the process of deprecating the `blueprints add` command.
  */
 import { Args, Flags } from '@oclif/core';
-import { LocalBlueprintCommand } from '../../baseCommands.js';
+import { ResolvedCommand } from '../../baseCommands.js';
 import { FUNCTION_TYPES } from '../../constants.js';
 import { functionAddCore } from '../../cores/functions/index.js';
 import { Logger } from '../../utils/logger.js';
 import { INSTALLER_OPTIONS } from '../../utils/types.js';
 // import {warn} from '../../utils/display/presenters.js'
-export default class AddCommand extends LocalBlueprintCommand {
+export default class AddCommand extends ResolvedCommand {
+    static needs = ['blueprint'];
     // static state = 'deprecated'
     // static deprecationOptions = {
     //   message: '`blueprints add` is deprecated. Use `functions add` instead.',

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

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

package/dist/commands/blueprints/config.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { LocalBlueprintCommand, organizationIdFlagConfig, projectIdFlagConfig, } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintConfigCore } from '../../cores/blueprints/config.js';
 import { Logger } from '../../utils/logger.js';
-export default class ConfigCommand extends LocalBlueprintCommand {
+export default class ConfigCommand extends ResolvedCommand {
+    static needs = ['token', 'blueprint'];
     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.
 

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

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

package/dist/commands/blueprints/deploy.js

@@ -1,9 +1,10 @@
 import { Flags } from '@oclif/core';
-import { DeployedStackCommand, stackFlag, unhide } from '../../baseCommands.js';
+import { ResolvedCommand, stackFlagConfig } from '../../baseCommands.js';
 import { blueprintDeployCore } from '../../cores/blueprints/deploy.js';
 import { Logger } from '../../utils/logger.js';
 import { INSTALLER_OPTIONS } from '../../utils/types.js';
-export default class DeployCommand extends DeployedStackCommand {
+export default class DeployCommand extends ResolvedCommand {
+    static needs = ['deployedStack', 'blueprint'];
     static summary = 'Deploy the local Blueprint to the remote Stack';
     static description = `Applies your local Blueprint to the remote Stack, creating, updating, or removing resources as needed. This is the primary command for applying infrastructure changes.
 
@@ -21,7 +22,7 @@ Set SANITY_ASSET_TIMEOUT (seconds) to override the 60-second timeout for process
         '<%= config.bin %> <%= command.id %> --fn-installer npm',
     ];
     static flags = {
-        stack: unhide(stackFlag),
+        stack: Flags.string({ ...stackFlagConfig }),
         message: Flags.string({
             description: 'Message describing the deployment (e.g. reason for change)',
             char: 'm',

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

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

package/dist/commands/blueprints/destroy.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { LocalBlueprintCommand, organizationIdFlagConfig, projectIdFlagConfig, } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintDestroyCore } from '../../cores/blueprints/destroy.js';
 import { Logger } from '../../utils/logger.js';
-export default class DestroyCommand extends LocalBlueprintCommand {
+export default class DestroyCommand extends ResolvedCommand {
+    static needs = ['token', 'blueprint'];
     static summary = 'Destroy a remote Stack deployment and its resources';
     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'.
 

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

@@ -6,7 +6,6 @@ export default class DoctorCommand extends RuntimeCommand<typeof DoctorCommand>
     static flags: {
         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<Record<string, unknown> | undefined>;

package/dist/commands/blueprints/doctor.js

@@ -1,5 +1,5 @@
 import { Flags } from '@oclif/core';
-import { baseFlags, RuntimeCommand, unhide } from '../../baseCommands.js';
+import { pathFlagConfig, RuntimeCommand } from '../../baseCommands.js';
 import config from '../../config.js';
 import { blueprintDoctorCore } from '../../cores/blueprints/doctor.js';
 import { Logger } from '../../utils/logger.js';
@@ -14,12 +14,11 @@ Run this command when encountering errors with other Blueprint commands. Use --f
         '<%= config.bin %> <%= command.id %> --fix',
     ];
     static flags = {
-        path: unhide(baseFlags.path),
+        path: Flags.string({ ...pathFlagConfig }),
         fix: Flags.boolean({
             description: 'Interactively fix configuration issues',
             default: false,
         }),
-        json: unhide(baseFlags.json),
         verbose: Flags.boolean({
             description: 'Verbose output; defaults to true',
             default: true,

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

@@ -1,10 +1,12 @@
-import { DeployedStackCommand } from '../../baseCommands.js';
-export default class InfoCommand extends DeployedStackCommand<typeof InfoCommand> {
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
+    static needs: readonly ["deployedStack"];
     static summary: string;
     static description: string;
     static examples: string[];
     static flags: {
         stack: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/info.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { DeployedStackCommand } from '../../baseCommands.js';
+import { projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintInfoCore } from '../../cores/blueprints/info.js';
 import { Logger } from '../../utils/logger.js';
-export default class InfoCommand extends DeployedStackCommand {
+export default class InfoCommand extends ResolvedCommand {
+    static needs = ['deployedStack'];
     static summary = 'Display the status and resources of the remote Stack deployment';
     static description = `Displays the current state and metadata of your remote Stack deployment, including deployed resources, status, and configuration.
 
@@ -12,12 +13,14 @@ Run 'blueprints stacks' to see all available Stacks in your project or organizat
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --project-id <id> --stack <name-or-id>',
     ];
     static flags = {
         stack: Flags.string({
-            description: 'Stack name or ID to use instead of the locally configured Stack',
+            description: 'Stack name or ID',
             aliases: ['id'],
         }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
     };
     async run() {
         const result = await blueprintInfoCore({

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

@@ -14,7 +14,6 @@ export default class InitCommand extends RuntimeCommand<typeof InitCommand> {
         'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/blueprints/init.js

@@ -1,5 +1,5 @@
 import { Args, Flags } from '@oclif/core';
-import { baseFlags, organizationIdFlagConfig, projectIdFlagConfig, RuntimeCommand, unhide, } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, RuntimeCommand } from '../../baseCommands.js';
 import { blueprintInitCore } from '../../cores/blueprints/init.js';
 import { Logger } from '../../utils/logger.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
@@ -50,7 +50,6 @@ After initialization, use 'blueprints plan' to preview changes, then 'blueprints
             aliases: ['name'],
             exclusive: ['stack-id'],
         }),
-        verbose: unhide(baseFlags.verbose),
     };
     async run() {
         const log = Logger(this.log.bind(this), 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> {
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class LogsCommand extends ResolvedCommand<typeof LogsCommand> {
+    static needs: readonly ["deployedStack"];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/logs.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { DeployedStackCommand, stackFlag, unhide } from '../../baseCommands.js';
+import { ResolvedCommand, stackFlagConfig } from '../../baseCommands.js';
 import { blueprintLogsCore } from '../../cores/blueprints/logs.js';
 import { Logger } from '../../utils/logger.js';
-export default class LogsCommand extends DeployedStackCommand {
+export default class LogsCommand extends ResolvedCommand {
+    static needs = ['deployedStack'];
     static summary = "Display logs for the current Blueprint's Stack deployment";
     static description = `Retrieves Stack deployment logs, useful for debugging and monitoring deployment activity.
 
@@ -14,7 +15,7 @@ If you're not seeing expected logs, verify your Stack is deployed with 'blueprin
         '<%= config.bin %> <%= command.id %> --watch',
     ];
     static flags = {
-        stack: unhide(stackFlag),
+        stack: Flags.string({ ...stackFlagConfig }),
         watch: Flags.boolean({
             char: 'w',
             description: 'Watch for new Stack logs (streaming mode)',

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

@@ -1,5 +1,6 @@
-import { LocalBlueprintCommand } from '../../baseCommands.js';
-export default class PlanCommand extends LocalBlueprintCommand<typeof PlanCommand> {
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class PlanCommand extends ResolvedCommand<typeof PlanCommand> {
+    static needs: readonly ["token", "blueprint"];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/plan.js

@@ -1,14 +1,16 @@
-import { LocalBlueprintCommand, stackFlag, unhide } from '../../baseCommands.js';
+import { Flags } from '@oclif/core';
+import { ResolvedCommand, stackFlagConfig } from '../../baseCommands.js';
 import { blueprintPlanCore } from '../../cores/blueprints/plan.js';
 import { Logger } from '../../utils/logger.js';
-export default class PlanCommand extends LocalBlueprintCommand {
+export default class PlanCommand extends ResolvedCommand {
+    static needs = ['token', 'blueprint'];
     static summary = 'Preview changes that will be applied to the remote Stack';
     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 %>'];
     static flags = {
-        stack: unhide(stackFlag),
+        stack: Flags.string({ ...stackFlagConfig }),
     };
     async run() {
         const result = await blueprintPlanCore({

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

@@ -1,5 +1,6 @@
-import { DeployedStackCommand } from '../../baseCommands.js';
-export default class PromoteCommand extends DeployedStackCommand<typeof PromoteCommand> {
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class PromoteCommand extends ResolvedCommand<typeof PromoteCommand> {
+    static needs: readonly ["deployedStack", "blueprint"];
     static summary: string;
     static description: string;
     static hidden: boolean;

package/dist/commands/blueprints/promote.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { DeployedStackCommand } from '../../baseCommands.js';
+import { ResolvedCommand } from '../../baseCommands.js';
 import { blueprintPromoteCore } from '../../cores/blueprints/promote.js';
 import { Logger } from '../../utils/logger.js';
-export default class PromoteCommand extends DeployedStackCommand {
+export default class PromoteCommand extends ResolvedCommand {
+    static needs = ['deployedStack', 'blueprint'];
     static summary = 'Promote a Stack from project scope to organization scope';
     static description = `Promotes a deployed Stack to organization scope, enabling management of org-level resources. Promotion cannot be reversed.
 

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

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

package/dist/commands/blueprints/stacks.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { LocalBlueprintCommand, organizationIdFlagConfig, projectIdFlagConfig, } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintStacksCore } from '../../cores/blueprints/stacks.js';
 import { Logger } from '../../utils/logger.js';
-export default class StacksCommand extends LocalBlueprintCommand {
+export default class StacksCommand extends ResolvedCommand {
+    static needs = ['token', 'blueprint'];
     static summary = 'List remote Stack deployments for your project or organization';
     static description = `Shows all Stacks associated with a project or organization. By default, lists Stacks scoped to the local Blueprint.