@sanity/runtime-cli 4.4.0 → 4.5.1

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

@@ -6,18 +6,6 @@ interface ListStacksResponse {
     stacks: Stack[];
 }
 export declare function listStacks(auth: AuthParams): Promise<ListStacksResponse>;
-interface GetStackByNameResponse {
-    ok: boolean;
-    error: string | null;
-    stack: Stack | null;
-    stackId: string | null;
-    availableStacks?: string[];
-}
-/** @deprecated Use getStack instead */
-export declare function getStackByName({ name, auth, }: {
-    name: string;
-    auth: AuthParams;
-}): Promise<GetStackByNameResponse>;
 interface GetStackResponse {
     ok: boolean;
     error: string | null;

package/dist/actions/blueprints/stacks.js

@@ -14,35 +14,6 @@ export async function listStacks(auth) {
         stacks,
     };
 }
-/** @deprecated Use getStack instead */
-export async function getStackByName({ name, auth, }) {
-    const { ok, stacks, error } = await listStacks(auth);
-    if (!ok || !stacks) {
-        return {
-            ok: false,
-            error: error || 'Failed to retrieve stacks',
-            stack: null,
-            stackId: null,
-        };
-    }
-    const foundStack = stacks.find((stack) => stack.name === name);
-    if (!foundStack) {
-        return {
-            ok: true,
-            error: null,
-            stack: null,
-            stackId: null,
-            availableStacks: stacks.map((s) => s.name),
-        };
-    }
-    const stackResult = await getStack({ stackId: foundStack.id, auth });
-    return {
-        ok: stackResult.ok,
-        error: stackResult.error,
-        stack: stackResult.stack,
-        stackId: foundStack.id,
-    };
-}
 export async function getStack({ stackId, auth, }) {
     const response = await fetch(`${stacksUrl}/${stackId}`, {
         method: 'GET',
@@ -56,6 +27,8 @@ export async function getStack({ stackId, auth, }) {
     };
 }
 export async function createStack({ stackPayload, auth, }) {
+    // LAUNCH LIMIT: 1 Stack per Project
+    stackPayload.useProjectBasedId = true;
     const response = await fetch(stacksUrl, {
         method: 'POST',
         headers: getHeaders(auth),
@@ -64,7 +37,7 @@ export async function createStack({ stackPayload, auth, }) {
     const stack = await response.json();
     return {
         ok: response.ok,
-        error: response.ok ? null : stack.message,
+        error: response.ok ? null : stack.message || stack.error,
         stack,
     };
 }

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

@@ -1,2 +1,2 @@
-import type { InvocationResponse, InvokeContextOptions, InvokePayloadOptions } from '../../utils/types.js';
-export declare function testAction(srcPath: string, options: InvokePayloadOptions, context: InvokeContextOptions): Promise<InvocationResponse>;
+import type { InvocationResponse, InvokeContextOptions, InvokePayloadOptions, LocalFunctionResource } from '../../utils/types.js';
+export declare function testAction(resource: LocalFunctionResource, options: InvokePayloadOptions, context: InvokeContextOptions): Promise<InvocationResponse>;

package/dist/actions/functions/test.js

@@ -1,10 +1,10 @@
 import buildPayload from '../../utils/build-payload.js';
 import invoke from '../../utils/invoke-local.js';
-export async function testAction(srcPath, options, context) {
+export async function testAction(resource, options, context) {
     const payload = buildPayload(options);
     const { timeout } = options;
     try {
-        const { json, logs } = await invoke(srcPath, payload, context, timeout);
+        const { json, logs } = await invoke(resource, payload, context, timeout);
         return { error: undefined, json, logs };
     }
     catch (error) {

package/dist/baseCommands.d.ts

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
+import { readLocalBlueprint } from './actions/blueprints/blueprint.js';
+import type { AuthParams, Stack } from './utils/types.js';
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BlueprintCommand)['baseFlags'] & T['flags']>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare abstract class BlueprintCommand<T extends typeof Command> extends Command {
+    protected sanityToken: string;
+    protected blueprint: Awaited<ReturnType<typeof readLocalBlueprint>>;
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    init(): Promise<void>;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<unknown>;
+    protected finally(_: Error | undefined): Promise<unknown>;
+}
+export declare abstract class DeployedBlueprintCommand<T extends typeof Command> extends BlueprintCommand<T> {
+    protected auth: AuthParams;
+    protected deployedStack: Stack;
+    protected projectId: string;
+    protected stackId: string;
+    init(): Promise<void>;
+}

package/dist/baseCommands.js

@@ -0,0 +1,69 @@
+// * https://oclif.io/docs/base_class
+import { Command } from '@oclif/core';
+import { readLocalBlueprint } from './actions/blueprints/blueprint.js';
+import { getStack } from './actions/blueprints/stacks.js';
+import { presentBlueprintParserErrors } from './utils/display/errors.js';
+import { validTokenOrErrorMessage } from './utils/validated-token.js';
+export class BlueprintCommand extends Command {
+    sanityToken;
+    blueprint;
+    flags;
+    args;
+    async init() {
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+        await super.init();
+        const { token, error: tokenErr } = await validTokenOrErrorMessage();
+        if (tokenErr)
+            this.error(tokenErr.message);
+        this.sanityToken = token;
+        const blueprint = await readLocalBlueprint();
+        if (blueprint.errors.length > 0) {
+            this.log(presentBlueprintParserErrors(blueprint.errors));
+            this.error('Blueprint parse errors.');
+        }
+        this.blueprint = blueprint;
+    }
+    async catch(err) {
+        // add any custom logic to handle errors from the command
+        // or simply return the parent class error handling
+        return super.catch(err);
+    }
+    async finally(_) {
+        // called after run and catch regardless of whether or not the command errored
+        return super.finally(_);
+    }
+}
+export class DeployedBlueprintCommand extends BlueprintCommand {
+    auth;
+    deployedStack;
+    projectId;
+    stackId;
+    async init() {
+        await super.init();
+        const { projectId, stackId } = this.blueprint;
+        if (!projectId)
+            this.error('Missing Project ID for Blueprint');
+        if (!stackId)
+            this.error('Missing Stack ID for Blueprint');
+        this.projectId = projectId;
+        this.stackId = stackId;
+        this.auth = { token: this.sanityToken, projectId };
+        const stackResponse = await getStack({ stackId, auth: this.auth });
+        if (!stackResponse.ok) {
+            this.error(stackResponse.error ?? 'Could not retrieve deployment info');
+        }
+        const { stack: deployedStack } = stackResponse;
+        if (!deployedStack) {
+            this.error('Unable to find deployed Stack. Run `sanity-run blueprints init`');
+        }
+        this.deployedStack = deployedStack;
+    }
+}

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

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Add extends Command {
+export default class AddCommand extends Command {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/blueprints/add.js

@@ -1,10 +1,11 @@
+import { cwd } from 'node:process';
 import { Args, Command, Flags } from '@oclif/core';
 import highlight from 'color-json';
 import inquirer from 'inquirer';
 import { findBlueprintFile } from '../../actions/blueprints/blueprint.js';
 import { createFunctionResource } from '../../actions/blueprints/resources.js';
 import { validateFunctionName, validateFunctionType } from '../../utils/validate/resource.js';
-export default class Add extends Command {
+export default class AddCommand extends Command {
     static description = 'Add a resource to a Blueprint';
     static examples = [
         '<%= config.bin %> <%= command.id %> function',
@@ -30,13 +31,13 @@ export default class Add extends Command {
         }),
     };
     async run() {
-        const { args, flags } = await this.parse(Add);
+        const { args, flags } = await this.parse(AddCommand);
+        if (args.type !== 'function')
+            this.error(`Unsupported Resource type: ${args.type}`);
         const existingBlueprint = findBlueprintFile();
         if (!existingBlueprint) {
-            this.error('No blueprint file found. Run `sanity blueprints init` first.');
+            this.error('No Blueprint file found. Run `sanity-run blueprints init` first.');
         }
-        if (args.type !== 'function')
-            this.error(`Unsupported resource type: ${args.type}`);
         const resourceName = flags.name;
         const functionType = flags['function-type'];
         await this.addFunction({ name: resourceName, type: functionType });
@@ -82,7 +83,7 @@ export default class Add extends Command {
             type: functionType,
             displayName: functionName,
         });
-        this.log(`\nCreated function: ${filePath}`);
+        this.log(`\nCreated function: ${filePath.replace(cwd(), '')}`);
         if (!resourceAdded) {
             // print the resource JSON for manual addition
             this.log('\nAdd this Function resource to your blueprint:');

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

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Config extends Command {
+export default class ConfigCommand extends Command {
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/blueprints/config.js

@@ -2,18 +2,21 @@ import { Command, Flags } from '@oclif/core';
 import highlight from 'color-json';
 import inquirer from 'inquirer';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk, writeConfigFile } from '../../actions/blueprints/blueprint.js';
+import { readLocalBlueprint, writeConfigFile } from '../../actions/blueprints/blueprint.js';
 import { listProjects } from '../../actions/blueprints/projects.js';
 import { getStack, listStacks } from '../../actions/blueprints/stacks.js';
 import { bold, dim, niceId } from '../../utils/display/colors.js';
+import { presentBlueprintParserErrors } from '../../utils/display/errors.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Config extends Command {
+export default class ConfigCommand extends Command {
     static description = 'View or edit Blueprint configuration';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --test-config',
         '<%= config.bin %> <%= command.id %> --edit',
-        '<%= config.bin %> <%= command.id %> --edit --project-id <projectId> --stack-id <stackId>',
+        '<%= config.bin %> <%= command.id %> --edit --project-id <projectId>',
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        // '<%= config.bin %> <%= command.id %> --edit --project-id <projectId> --stack-id <stackId>',
     ];
     static flags = {
         'test-config': Flags.boolean({
@@ -36,20 +39,25 @@ export default class Config extends Command {
             description: 'Update the Stack ID in the configuration. Requires --edit flag',
             aliases: ['stack', 'stackId'],
             dependsOn: ['edit'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     sanityToken;
     async run() {
-        const { flags } = await this.parse(Config);
+        const { flags } = await this.parse(ConfigCommand);
         const { edit: editConfig, 'project-id': editProjectId, 'stack-id': editStackId, 'test-config': testConfig, } = flags;
-        const blueprint = await readBlueprintOnDisk();
-        const { stackId: configStackId, projectId: configProjectId } = blueprint;
+        const blueprint = await readLocalBlueprint();
+        const { stackId: configStackId, projectId: configProjectId, errors } = blueprint;
+        if (errors.length > 0) {
+            this.log(presentBlueprintParserErrors(errors));
+            this.error('Blueprint parse errors.');
+        }
         if (!configStackId && !configProjectId) {
-            this.error('Project and Stack configuration is missing! Use `blueprints init` to create a configuration.');
+            this.error('Project configuration is missing! Use `sanity-run blueprints init` to create a configuration.');
         }
         this.log(bold('Current configuration:'));
         this.log(`  Sanity Project:  ${niceId(configProjectId)}`);
-        this.log(`  Blueprint Stack: ${niceId(configStackId)}`);
+        this.log(`  Blueprint deployment: ${niceId(configStackId)}`);
         if ((editProjectId || editStackId) && !editConfig) {
             this.log('To update the configuration, use the --edit flag.');
             return;
@@ -73,7 +81,10 @@ export default class Config extends Command {
         const projectId = editProjectId || (await this.promptForProjectId({ knownProjectId: configProjectId }));
         if (!projectId)
             this.error('Project ID is required.');
-        const stackId = editStackId || (await this.promptForStackId({ projectId, knownStackId: configStackId }));
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        // const stackId =
+        //   editStackId || (await this.promptForStackId({projectId, knownStackId: configStackId}))
+        const stackId = configStackId;
         if (testConfig) {
             if (projectId && stackId) {
                 const { ok: newConfigOk } = await this.testConfigAndReport({ stackId, projectId });
@@ -87,12 +98,14 @@ export default class Config extends Command {
         }
         try {
             // update or create .blueprint/config.json
-            writeConfigFile({ projectId, stackId });
+            // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+            writeConfigFile({ projectId /*, stackId*/ });
             this.log('Configuration updated successfully.');
         }
         catch (error) {
             this.log('Unable to dynamically update config. Use these values in your blueprint:');
-            this.log(highlight(JSON.stringify({ metadata: { projectId, stackId } }, null, 2)));
+            // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+            this.log(highlight(JSON.stringify({ metadata: { projectId /*, stackId*/ } }, null, 2)));
         }
     }
     async promptForProjectId({ knownProjectId }) {

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

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

package/dist/commands/blueprints/deploy.js

@@ -1,16 +1,17 @@
 import { setTimeout } from 'node:timers/promises';
-import { inspect } from 'node:util';
-import { Command, Flags } from '@oclif/core';
+import { Flags } from '@oclif/core';
 import Spinner from 'yocto-spinner';
 import { stashAsset } from '../../actions/blueprints/assets.js';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { bold, niceId, red } from '../../utils/display/colors.js';
 import { isLocalFunctionResource } from '../../utils/types.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Deploy extends Command {
+export default class DeployCommand extends DeployedBlueprintCommand {
     static description = 'Deploy a Blueprint';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --no-wait',
+    ];
     static flags = {
         'no-wait': Flags.boolean({
             description: 'Do not wait for deployment to complete',
@@ -18,28 +19,15 @@ export default class Deploy extends Command {
         }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { flags } = await this.parse(Deploy);
-        const { errors, projectId, stackId, parsedBlueprint: { resources }, deployedStack, } = await readBlueprintOnDisk({ getStack: true, token });
-        if (errors.length > 0) {
-            // printErrors(errors) // TODO: error printer in formatting
-            this.error(`Blueprint parse errors:\n${inspect(errors, { depth: null })}`);
-        }
-        if (!deployedStack || !stackId || !projectId) {
-            this.error('Before deploying, run `sanity blueprints init`');
-        }
-        if (stackId !== deployedStack.id)
-            this.error('Stack ID mismatch');
-        const auth = { token, projectId };
+        const flags = this.flags;
+        const { resources } = this.blueprint.parsedBlueprint;
         const validResources = resources?.filter((r) => r.type);
         const functionResources = validResources?.filter(isLocalFunctionResource);
         // First stash all function assets
         if (functionResources?.length) {
             for (const resource of functionResources) {
                 const fnSpinner = Spinner({ text: `Processing ${resource.name}...` }).start();
-                const result = await stashAsset({ resource, auth });
+                const result = await stashAsset({ resource, auth: this.auth });
                 if (result.success && result.assetId) {
                     const src = resource.src;
                     resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
@@ -54,21 +42,19 @@ export default class Deploy extends Command {
             }
         }
         const stackPayload = {
-            projectId,
-            name: deployedStack.name,
+            projectId: this.projectId,
+            name: this.deployedStack.name,
             document: { resources: validResources },
         };
-        this.debug('BLUEPRINT DOCUMENT:', stackPayload);
-        const spinner = Spinner({ text: 'Deploying stack...' }).start();
-        const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId: deployedStack.id, stackPayload, auth });
-        this.debug('STACK RESPONSE:', stack);
+        const spinner = Spinner({ text: 'Deploying...' }).start();
+        const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId: this.stackId, stackPayload, auth: this.auth });
         if (deployOk) {
-            spinner.success(`Stack "${bold(stack.name)}" ${niceId(stack.id)} deployment started!`);
+            spinner.success(`Deployment "${bold(stack.name)}" ${niceId(stack.id)} started!`);
             if (!flags['no-wait']) {
                 const waitSpinner = Spinner({ text: 'Waiting for deployment to complete...' }).start();
                 while (true) {
                     // TODO: watch logs and print those while polling
-                    const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth });
+                    const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth: this.auth });
                     if (!ok) {
                         waitSpinner.error('Failed to check deployment status');
                         break;
@@ -90,12 +76,11 @@ export default class Deploy extends Command {
                 }
             }
             else {
-                this.log('Use `sanity blueprints info` to check deployment status');
+                this.log('Use `sanity-run blueprints info` to check status');
             }
         }
         else {
-            this.debug('STACK ERROR RESPONSE:', stack);
-            spinner.error(`${red('Failed')} to update stack`);
+            spinner.error(`${red('Failed')} to update deployment`);
             this.log(`Error: ${deployError || JSON.stringify(stack, null, 2) || 'Unknown error'}`);
         }
     }

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

@@ -1,10 +1,11 @@
-import { Command } from '@oclif/core';
-export default class Destroy extends Command {
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
+export default class DestroyCommand extends DeployedBlueprintCommand<typeof DestroyCommand> {
     static description: string;
     static examples: string[];
     static flags: {
-        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        projectId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/blueprints/destroy.js

@@ -1,54 +1,51 @@
 import { setTimeout } from 'node:timers/promises';
-import { Command, Flags } from '@oclif/core';
+import { Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { destroyStack, getStack } from '../../actions/blueprints/stacks.js';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { bold, niceId } from '../../utils/display/colors.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Destroy extends Command {
-    static description = 'Destroy a deployed Blueprint Stack';
+export default class DestroyCommand extends DeployedBlueprintCommand {
+    static description = 'Destroy a Blueprint deployment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --id ST-a1b2c3',
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        // '<%= config.bin %> <%= command.id %> --id ST-a1b2c3 --projectId a1b2c3 --force',
     ];
     static flags = {
-        id: Flags.string({
-            description: 'Stack ID to destroy (defaults to current Stack)',
-            required: false,
-        }),
         force: Flags.boolean({
             description: 'Force destroy (skip confirmation)',
             default: false,
         }),
+        projectId: Flags.string({
+            description: 'Project associated with the Stack (defaults to current Project)',
+            dependsOn: ['id', 'force'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
+        }),
+        id: Flags.string({
+            description: 'Stack ID to destroy (defaults to current Stack)',
+            dependsOn: ['projectId', 'force'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
+        }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { flags } = await this.parse(Destroy);
-        const { errors, deployedStack, projectId } = await readBlueprintOnDisk({ getStack: true, token });
-        if (errors.length > 0) {
-            // printErrors(errors)
-            this.warn('Blueprint parse errors:');
-            console.dir(errors, { depth: null });
+        const flags = this.flags;
+        if (flags.projectId && flags.id && flags.force) {
+            // just try to destroy it
+            const auth = { token: this.sanityToken, projectId: flags.projectId };
+            const { ok, error, stack } = await destroyStack({ stackId: flags.id, auth });
+            if (!ok)
+                this.error(error || 'Failed to destroy deployment');
+            this.log(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
             return;
         }
-        if (!projectId)
-            this.error('Project resource not found in blueprint');
-        const auth = { token, projectId };
-        let stack = deployedStack;
+        let stack = this.deployedStack;
         if (flags.id) {
-            const { ok, stack: foundStack, error } = await getStack({ stackId: flags.id, auth });
+            const { ok, stack: foundStack, error } = await getStack({ stackId: flags.id, auth: this.auth });
             if (!ok)
                 this.error(error || 'Failed to get stack');
             stack = foundStack;
         }
-        else if (!stack) {
-            this.error('No stack found');
-        }
-        if (!stack)
-            this.error('Stack not found. Is it deployed?');
         const destroySpinner = Spinner({
             text: `Destroying ${bold(stack.name)} ${niceId(stack.id)}...`,
             color: 'red',
@@ -63,25 +60,25 @@ export default class Destroy extends Command {
                 },
             ]);
             if (!confirm) {
-                this.log('Stack destruction cancelled');
+                this.log('Deployment destruction cancelled');
                 return;
             }
             destroySpinner.start();
             let i = 5;
             while (i >= 0) {
-                destroySpinner.text = `Destroying stack in ${bold((i--).toString())} seconds...`;
+                destroySpinner.text = `Destroying deployment in ${bold((i--).toString())} seconds...`;
                 await setTimeout(1000);
             }
-            destroySpinner.text = 'Destroying stack 💥';
+            destroySpinner.text = 'Destroying deployment 💥';
             await setTimeout(500);
         }
         else {
             destroySpinner.start();
         }
-        const { ok, error } = await destroyStack({ stackId: stack.id, auth });
+        const { ok, error } = await destroyStack({ stackId: stack.id, auth: this.auth });
         if (!ok)
-            this.error(error || 'Failed to destroy stack');
+            this.error(error || 'Failed to destroy deployment');
         // TODO: update local config
-        destroySpinner.success(`Stack "${stack.name}" ${niceId(stack.id)} destroyed`);
+        destroySpinner.success(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
     }
 }

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

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

package/dist/commands/blueprints/info.js

@@ -1,53 +1,33 @@
-import { Command, Flags } from '@oclif/core';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
+import { Flags } from '@oclif/core';
 import { getStack } from '../../actions/blueprints/stacks.js';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { formatResourceTree, formatStackInfo } from '../../utils/display/blueprints-formatting.js';
 import { niceId } from '../../utils/display/colors.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Info extends Command {
-    static description = 'Show information about a deployed Blueprint Stack';
+export default class InfoCommand extends DeployedBlueprintCommand {
+    static description = 'Show information about a Blueprint deployment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --id ST-a1b2c3',
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        // '<%= config.bin %> <%= command.id %> --id ST-a1b2c3',
     ];
     static flags = {
         id: Flags.string({
             description: 'Stack ID to show info for (defaults to current stack)',
-            required: false,
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { flags } = await this.parse(Info);
-        const { errors, deployedStack, projectId, stackId } = await readBlueprintOnDisk({
-            getStack: true,
-            token,
-        });
-        if (errors.length > 0) {
-            // printErrors(errors)
-            this.warn('Blueprint parse errors:');
-            console.dir(errors, { depth: null });
-            return;
-        }
-        if (!stackId && !flags.id)
-            this.error('No Stack ID provided');
-        if (!projectId)
-            this.error('Missing Project ID for Blueprint');
-        const auth = { token, projectId };
-        let stack = deployedStack;
+        const flags = this.flags;
+        const stackId = flags.id || this.stackId;
+        let stack = this.deployedStack;
         if (flags.id) {
-            const { ok, stack: foundStack, error } = await getStack({ stackId: flags.id, auth });
-            if (!ok)
-                this.error(`Failed to get Stack ${niceId(flags.id)}: ${error}`);
-            stack = foundStack;
-        }
-        else if (!stack) {
-            this.error(`Stack ${niceId(stackId)} not found`);
+            const existingStackResponse = await getStack({ stackId, auth: this.auth });
+            if (!existingStackResponse.ok) {
+                this.error(existingStackResponse.error ??
+                    `Could not retrieve deployment info for ${niceId(stackId)}`);
+            }
+            stack = existingStackResponse.stack;
         }
-        if (!stack)
-            this.error('Stack not found. Is it deployed?');
         this.log(formatStackInfo(stack, true));
         if (stack.resources) {
             this.log('');