@sanity/runtime-cli 4.5.0 → 5.0.0

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 (will not delete local files)';
     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('');

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

@@ -1,9 +1,13 @@
 import { Command } from '@oclif/core';
-import type { AuthParams, Stack, StackPayload } from '../../utils/types.js';
-export default class Init extends Command {
+import type { AuthParams, Stack } from '../../utils/types.js';
+export default class InitCommand extends Command {
     static description: string;
     static examples: string[];
+    static args: {
+        dir: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static flags: {
+        dir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'blueprint-type': 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>;
         'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -12,12 +16,17 @@ export default class Init extends Command {
     sanityToken: string | undefined;
     run(): Promise<void>;
     promptForBlueprintType(): Promise<string>;
-    promptForProjectId(): Promise<string>;
+    promptForProject(): Promise<{
+        projectId: string;
+        displayName: string;
+    }>;
     promptForStackId({ projectId }: {
         projectId: string;
     }): Promise<string>;
-    createEmptyStack({ stackPayload, auth, }: {
-        stackPayload: StackPayload;
-        auth: AuthParams;
+    createEmptyStack({ projectId, name, projectBased, }: {
+        projectId: string;
+        name: string;
+        projectBased?: boolean;
     }): Promise<Stack>;
+    createProjectBasedStack(auth: AuthParams): Promise<Stack>;
 }

package/dist/commands/blueprints/init.js

@@ -1,21 +1,34 @@
 import { join } from 'node:path';
 import { cwd } from 'node:process';
-import { Command, Flags } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
-import { listProjects } from '../../actions/blueprints/projects.js';
-import { createStack, listStacks } from '../../actions/blueprints/stacks.js';
-import { bold, dim, niceId, underline } from '../../utils/display/colors.js';
+import { getProject, listProjects } from '../../actions/blueprints/projects.js';
+import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { niceId } from '../../utils/display/colors.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Init extends Command {
+const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
+export default class InitCommand extends Command {
     static description = 'Initialize a new Blueprint';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> [directory]',
         '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts>',
-        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-id <stackId>',
-        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-name <stackName>',
+        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId>',
+        // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
+        // '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-id <stackId>',
+        // '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-name <stackName>',
     ];
+    static args = {
+        dir: Args.string({
+            description: 'Directory to create the Blueprint in',
+        }),
+    };
     static flags = {
+        dir: Flags.string({
+            description: 'Directory to create the Blueprint in',
+        }),
         'blueprint-type': Flags.string({
             description: 'Blueprint manifest type to use for the Blueprint',
             options: ['json', 'js', 'ts'],
@@ -30,52 +43,62 @@ export default class Init extends Command {
             aliases: ['stack', 'stackId'],
             dependsOn: ['project-id'],
             exclusive: ['stack-name'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
         'stack-name': Flags.string({
-            char: 'n',
             description: 'Name to use for a NEW Stack',
             aliases: ['name'],
-            dependsOn: ['project-id'],
             exclusive: ['stack-id'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     sanityToken;
     async run() {
-        const { flags } = await this.parse(Init);
-        const { 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
-        const existingBlueprint = findBlueprintFile();
-        if (existingBlueprint) {
-            this.error(`A blueprint file already exists: ${existingBlueprint.fileName}`);
-        }
+        const { args, flags } = await this.parse(InitCommand);
         const { token, error: tokenErr } = await validTokenOrErrorMessage();
         if (tokenErr)
             this.error(tokenErr.message);
         this.sanityToken = token;
+        const { 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, dir: flagDir, } = flags;
+        const { dir: argDir } = args;
+        const dirProvided = argDir || flagDir;
+        const here = cwd();
+        const dir = argDir || flagDir || here;
+        const existingBlueprint = findBlueprintFile(dir);
+        if (existingBlueprint)
+            this.error('Existing Blueprint found.');
         const blueprintExtension = flagBlueprintType || (await this.promptForBlueprintType());
         if (!blueprintExtension)
             this.error('Blueprint type is required.');
-        const projectId = flagProjectId || (await this.promptForProjectId());
-        if (!projectId)
-            this.error('Project ID is required.');
+        let projectId = flagProjectId;
         let stackId = flagStackId;
-        if (!stackId) {
-            if (flagStackName) {
-                const stack = await this.createEmptyStack({
-                    stackPayload: { name: flagStackName, projectId, document: { resources: [] } },
-                    auth: { token: this.sanityToken, projectId },
-                });
-                stackId = stack.id;
-            }
-            else {
-                stackId = await this.promptForStackId({ projectId });
-            }
+        if (!projectId) {
+            const pickedProject = await this.promptForProject();
+            projectId = pickedProject.projectId;
+        }
+        const auth = { token: this.sanityToken, projectId };
+        if (flagStackName) {
+            // using --stack-name gets around "LAUNCH LIMIT: 1 Stack per Project"
+            const stack = await this.createEmptyStack({
+                projectId,
+                name: flagStackName,
+                projectBased: false,
+            });
+            stackId = stack.id;
+        }
+        // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
+        if (!stackId && LAUNCH_LIMIT_STACK_PER_PROJECT) {
+            const stack = await this.createProjectBasedStack(auth);
+            // stackId = stack.id
         }
         const fileName = `blueprint.${blueprintExtension}`;
-        const filePath = join(cwd(), fileName);
+        const filePath = join(dir, fileName);
+        if (dirProvided)
+            this.log(`New Blueprint created:   ${dirProvided}/`);
         writeBlueprintToDisk({ blueprintFilePath: filePath });
-        this.log(`Created new blueprint: ./${fileName}`);
+        this.log(`Created new blueprint:   ${dirProvided ?? '.'}/${fileName}`);
         writeConfigFile({ blueprintFilePath: filePath, projectId, stackId });
-        this.log('Created new config file: ./.blueprint/config.json');
+        this.log(`Created new config file: ${dirProvided ?? '.'}/.blueprint/config.json`);
         if (blueprintExtension === 'ts') {
             this.log('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx');
         }
@@ -96,7 +119,7 @@ export default class Init extends Command {
         ]);
         return pickedBlueprintsType;
     }
-    async promptForProjectId() {
+    async promptForProject() {
         if (!this.sanityToken)
             this.error('Unable to list projects. Missing API token.');
         const { ok: projectsOk, error: projectsErr, projects, } = await listProjects({ token: this.sanityToken });
@@ -107,17 +130,17 @@ export default class Init extends Command {
         }
         const projectChoices = projects.map(({ displayName, id: projectId }) => ({
             name: `"${displayName}" ${niceId(projectId)}`,
-            value: projectId,
+            value: { projectId, displayName },
         }));
-        const { pickedProjectId } = await inquirer.prompt([
+        const { pickedProject } = await inquirer.prompt([
             {
                 type: 'list',
-                name: 'pickedProjectId',
+                name: 'pickedProject',
                 message: 'Select your Sanity project:',
                 choices: projectChoices,
             },
         ]);
-        return pickedProjectId;
+        return pickedProject;
     }
     async promptForStackId({ projectId }) {
         if (!this.sanityToken)
@@ -125,11 +148,13 @@ export default class Init extends Command {
         const { ok: stacksOk, error: stacksErr, stacks, } = await listStacks({ token: this.sanityToken, projectId });
         if (!stacksOk)
             this.error(stacksErr || 'Failed to list Stacks');
-        const stackChoices = [{ name: bold('✨ Create a new Stack'), value: 'new' }];
+        const stackChoices = [
+            { name: chalk.bold('✨ Create a new Stack'), value: 'new' },
+        ];
         if (stacks.length > 0) {
-            stackChoices.push(new inquirer.Separator(underline('Use an existing Stack:')));
+            stackChoices.push(new inquirer.Separator(chalk.underline('Use an existing Stack:')));
             stackChoices.push(...stacks.map((s) => ({
-                name: `"${s.name}" ${niceId(s.id)} ${dim(`(${s.resources.length} res)`)}`,
+                name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
                 value: s.id,
             })));
         }
@@ -137,7 +162,7 @@ export default class Init extends Command {
             {
                 type: 'list',
                 name: 'pickedStackId',
-                message: 'Select your Blueprint Stack:',
+                message: 'Select an existing deployment or create a new one:',
                 choices: stackChoices,
             },
         ]);
@@ -150,18 +175,45 @@ export default class Init extends Command {
                     validate: (input) => input.length > 0 || 'Stack name is required',
                 },
             ]);
-            const stack = await this.createEmptyStack({
-                stackPayload: { name: stackName, projectId, document: { resources: [] } },
-                auth: { token: this.sanityToken, projectId },
-            });
+            const stack = await this.createEmptyStack({ projectId, name: stackName });
             return stack.id;
         }
         return pickedStackId;
     }
-    async createEmptyStack({ stackPayload, auth, }) {
+    async createEmptyStack({ projectId, name, projectBased = true, }) {
+        if (!this.sanityToken)
+            this.error('Unable to create Stack. Missing API token.');
+        const stackPayload = {
+            name,
+            projectId,
+            useProjectBasedId: projectBased,
+            document: { resources: [] },
+        };
+        const auth = { token: this.sanityToken, projectId };
         const response = await createStack({ stackPayload, auth });
         if (!response.ok)
-            this.error(response.error || 'Failed to create Stack');
+            this.error(response.error || 'Failed to create new Stack');
         return response.stack;
     }
+    // LAUNCH LIMIT: 1 Stack per Project - create exclusive stack for project
+    async createProjectBasedStack(auth) {
+        const { projectId } = auth;
+        // get project
+        const { ok: projectOk, project } = await getProject(auth);
+        if (!projectOk)
+            this.error('Failed to find Project while creating Stack');
+        const projectDisplayName = project.displayName;
+        // check if project has a stack
+        const inferredStackId = `ST-${projectId}`;
+        const { stack: existingStack, ok: stackOk } = await getStack({ stackId: inferredStackId, auth });
+        // if existing stack, return stack
+        if (stackOk && existingStack) {
+            this.log(chalk.red(`Found existing deployment for "${projectDisplayName}" Blueprint`));
+            this.log(chalk.red('Deploying an empty Blueprint will override the existing deployment.'));
+            return existingStack;
+        }
+        // if not, create a stack
+        const stack = await this.createEmptyStack({ projectId, name: projectDisplayName });
+        return stack;
+    }
 }

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

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