@sanity/runtime-cli 10.11.3 → 11.0.2

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

@@ -0,0 +1,16 @@
+import { BlueprintCommand } from '../../baseCommands.js';
+export default class AddCommand extends BlueprintCommand<typeof AddCommand> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        example: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        language: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        javascript: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        helpers: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        installer: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        install: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/functions/add.js

@@ -0,0 +1,65 @@
+import { Flags } from '@oclif/core';
+import { BlueprintCommand } from '../../baseCommands.js';
+import { functionAddCore } from '../../cores/functions/index.js';
+export default class AddCommand extends BlueprintCommand {
+    static description = 'Add a Function to your Blueprint';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --helpers',
+        '<%= config.bin %> <%= command.id %> --name my-function',
+        '<%= config.bin %> <%= command.id %> --name my-function --type document-create',
+        '<%= config.bin %> <%= command.id %> --name my-function --type document-create --type document-update --lang js',
+    ];
+    static flags = {
+        example: Flags.string({
+            description: 'Example to use for the Function',
+            aliases: ['recipe'],
+            exclusive: ['name', 'fn-type', 'language', 'javascript', 'fn-helpers', 'fn-installer'],
+        }),
+        name: Flags.string({
+            description: 'Name of the Function to add',
+            char: 'n',
+        }),
+        type: Flags.string({
+            description: 'Document change event(s) that should trigger the function; you can specify multiple events by specifying this flag multiple times',
+            options: ['document-create', 'document-delete', 'document-update', 'document-publish'],
+            multiple: true,
+            multipleNonGreedy: true,
+            dependsOn: ['name'],
+        }),
+        language: Flags.string({
+            description: 'Language of the new Function',
+            aliases: ['lang'],
+            options: ['ts', 'js'],
+            default: 'ts',
+        }),
+        javascript: Flags.boolean({
+            description: 'Use JavaScript instead of TypeScript',
+            aliases: ['js'],
+            exclusive: ['language'],
+        }),
+        helpers: Flags.boolean({
+            description: 'Add helpers to the new Function',
+            allowNo: true,
+        }),
+        installer: Flags.string({
+            description: 'How to install the @sanity/functions helpers',
+            options: ['skip', 'npm', 'pnpm', 'yarn'],
+        }),
+        install: Flags.boolean({
+            description: 'Shortcut for --fn-installer npm',
+            char: 'i',
+            exclusive: ['fn-installer'],
+        }),
+    };
+    async run() {
+        const { success, error } = await functionAddCore({
+            bin: this.config.bin,
+            log: (msg) => this.log(msg),
+            blueprint: this.blueprint,
+            flags: this.flags,
+        });
+        if (!success)
+            this.error(error);
+    }
+}

package/dist/commands/functions/env/add.js

@@ -19,7 +19,8 @@ export default class EnvAddCommand extends DeployedBlueprintCommand {
             auth: this.auth,
             blueprint: this.blueprint,
             deployedStack: this.deployedStack,
-            projectId: this.projectId,
+            scopeType: this.scopeType,
+            scopeId: this.scopeId,
             token: this.sanityToken,
             stackId: this.stackId,
         });

package/dist/commands/functions/env/list.js

@@ -15,7 +15,8 @@ export default class EnvListCommand extends DeployedBlueprintCommand {
             auth: this.auth,
             blueprint: this.blueprint,
             deployedStack: this.deployedStack,
-            projectId: this.projectId,
+            scopeType: this.scopeType,
+            scopeId: this.scopeId,
             token: this.sanityToken,
             stackId: this.stackId,
         });

package/dist/commands/functions/env/remove.js

@@ -16,7 +16,8 @@ export default class EnvRemoveCommand extends DeployedBlueprintCommand {
             auth: this.auth,
             blueprint: this.blueprint,
             deployedStack: this.deployedStack,
-            projectId: this.projectId,
+            scopeType: this.scopeType,
+            scopeId: this.scopeId,
             token: this.sanityToken,
             stackId: this.stackId,
         });

package/dist/commands/functions/logs.js

@@ -56,7 +56,8 @@ export default class LogsCommand extends DeployedBlueprintCommand {
             auth: this.auth,
             blueprint: this.blueprint,
             deployedStack: this.deployedStack,
-            projectId: this.projectId,
+            scopeType: this.scopeType,
+            scopeId: this.scopeId,
             token: this.sanityToken,
             stackId: this.stackId,
         });

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

@@ -17,6 +17,7 @@ export default class TestCommand extends BlueprintCommand<typeof TestCommand> {
         api: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         dataset: 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>;
+        'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'document-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'document-id-before': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'document-id-after': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/functions/test.js

@@ -102,6 +102,11 @@ export default class TestCommand extends BlueprintCommand {
             aliases: ['project', 'projectId'],
             required: false,
         }),
+        'organization-id': Flags.string({
+            description: 'Sanity Organization ID to use',
+            aliases: ['organization', 'organizationId', 'org'],
+            required: false,
+        }),
         'document-id': Flags.string({
             description: 'Document to fetch and send to function',
             aliases: ['doc', 'documentId'],

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

@@ -7,6 +7,7 @@ export interface BlueprintConfigOptions extends CoreConfig {
         'test-config'?: boolean;
         edit?: boolean;
         'project-id'?: string;
+        'organization-id'?: string;
         'stack-id'?: string;
     };
 }

package/dist/cores/blueprints/config.js

@@ -1,32 +1,28 @@
 import { highlight } from 'cardinal';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
-import ora from 'ora';
 import { writeConfigFile } from '../../actions/blueprints/config.js';
-import { createStack, getStack } from '../../actions/blueprints/stacks.js';
-import { getProject } from '../../actions/sanity/projects.js';
 import { BLUEPRINT_CONFIG_FILE, BLUEPRINT_DIR } from '../../config.js';
-import { niceId, warn } from '../../utils/display/presenters.js';
+import { capitalize, niceId, warn } from '../../utils/display/presenters.js';
 import { promptForProject } from '../../utils/display/prompt.js';
 export async function blueprintConfigCore(options) {
     const { bin = 'sanity', log, token, flags } = options;
-    const { edit: editConfig = false, 'test-config': testConfig = false, 'project-id': flagProjectId, 'stack-id': flagStackId, } = flags;
+    const { edit: editConfig = false, 'test-config': testConfig = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, } = flags;
     const { blueprint } = options;
-    const { stackId: configStackId, projectId: configProjectId } = blueprint;
+    const { stackId: configStackId, scopeType: configScopeType, scopeId: configScopeId } = blueprint;
     try {
-        if (!configStackId && !configProjectId) {
-            log(warn('Missing local configuration.'));
+        if (!configStackId && !configScopeType && !configScopeId) {
+            log(warn('Incomplete configuration.'));
             if (!editConfig) {
                 // blueprint.json exists but no config JSON
-                log(`Use \`${bin} blueprints config --edit\` to set a configuration.`);
+                log(`Run \`${bin} blueprints doctor\` for diagnostics.`);
                 return { success: true }; // not necessarily fatal
             }
         }
         log(chalk.bold('Current configuration:'));
-        log(`  Sanity Project: ${niceId(configProjectId)}`);
-        log(`  Deployment ID:  ${niceId(configStackId)}`);
+        log(`  Blueprint scoped to: ${chalk.blue(capitalize(configScopeType || 'unknown'))} ${niceId(configScopeId || 'unknown')}`);
+        log(`  Deployment ID:  ${niceId(configStackId || 'unknown')}`);
         // passing new config without --edit flag is not allowed
-        if ((flagProjectId || flagStackId) && !editConfig) {
+        if ((flagProjectId || flagOrganizationId || flagStackId) && !editConfig) {
             log('To update the configuration, use the --edit flag.');
             return { success: true };
         }
@@ -37,100 +33,51 @@ export async function blueprintConfigCore(options) {
         if (testConfig) {
             log(warn(`The "test" flag is deprecated. Use "${bin} blueprints doctor" instead.`));
         }
-        // testing without editing
-        if (testConfig && !editConfig) {
-            if (configStackId && configProjectId) {
-                const testResult = await testConfigAndReport({
-                    token,
-                    stackId: configStackId,
-                    projectId: configProjectId,
-                });
-                if (!testResult.ok) {
-                    // command should exit with error code 1
-                    return { success: false, error: 'Existing Blueprint deployment not found.' };
-                }
-                return { success: testResult.ok };
-            }
-            return {
-                success: false,
-                error: 'Unable to test the configuration. Both Project and Stack IDs must be set.',
-            };
-        }
         // editing...
         if (editConfig) {
-            const updatedProjectId = flagProjectId ||
-                (await promptForProject({
-                    token,
-                    knownProjectId: configProjectId,
-                })).projectId;
-            if (!updatedProjectId) {
-                return {
-                    success: false,
-                    error: 'Project ID is required.',
-                };
-            }
-            // LAUNCH LIMIT: 1 Stack per Project - configStackId is always inferred from projectId if not set in config JSON
-            let updatedStackId = flagStackId ?? // flag first
-                configStackId ?? // existing config second
-                `ST-${updatedProjectId}`; //?? LAUNCH LIMIT: 1 Stack per Project - project-based third
-            // (await promptForStackId({projectId: updatedProjectId, knownStackId: configStackId})) // prompt for stackId
-            const isProjectBasedId = updatedStackId === `ST-${updatedProjectId}`;
-            log(`\n${chalk.bold('New configuration:')}`);
-            log(`  Sanity Project: ${niceId(updatedProjectId)}`);
-            log(`  Deployment ID:  ${niceId(updatedStackId)}`);
-            if (testConfig) {
-                if (updatedProjectId && updatedStackId) {
-                    const { ok: newConfigOk, error: configError } = await testConfigAndReport({
+            if (configScopeType === 'project') {
+                // maintain original project-based flow
+                const updatedProjectId = flagProjectId ||
+                    (await promptForProject({
                         token,
-                        stackId: updatedStackId,
-                        projectId: updatedProjectId,
-                    });
-                    if (!newConfigOk) {
-                        // is this a projectBasedId stack?
-                        if (isProjectBasedId) {
-                            log(warn('Existing Blueprint deployment not found.'));
-                            const reinitResult = await startReinitializeStack({
-                                token,
-                                projectId: updatedProjectId,
-                                stackId: updatedStackId,
-                            });
-                            if (!reinitResult.ok) {
-                                return { success: false, error: reinitResult.error || 'Failed to reinitialize stack' };
-                            }
-                            log(`New Blueprint deployment created for "${reinitResult.projectDisplayName}"`);
-                            // continuing to save the config
-                        }
-                        else {
-                            return {
-                                success: false,
-                                error: configError || 'Updated configuration has not been saved.',
-                            };
-                        }
-                    }
+                        knownProjectId: configScopeId,
+                    })).projectId;
+                if (!updatedProjectId) {
+                    return {
+                        success: false,
+                        error: 'Project ID is required.',
+                    };
                 }
-                else {
+                // LAUNCH LIMIT: 1 Stack per Project - configStackId is always inferred from projectId if not set in config JSON
+                let updatedStackId = flagStackId ?? // flag first
+                    configStackId ?? // existing config second
+                    `ST-${updatedProjectId}`; //?? LAUNCH LIMIT: 1 Stack per Project - project-based third
+                // (await promptForStackId({projectId: updatedProjectId, knownStackId: configStackId})) // prompt for stackId
+                const isProjectBasedId = updatedStackId === `ST-${updatedProjectId}`;
+                log(`\n${chalk.bold('New configuration:')}`);
+                log(`  Blueprint scoped to: ${chalk.blue(capitalize(configScopeType))} ${niceId(updatedProjectId)}`);
+                log(`  Deployment ID:  ${niceId(updatedStackId)}`);
+                // LAUNCH LIMIT: 1 Stack per Project - do not set Stack ID if it's project-based
+                if (isProjectBasedId)
+                    updatedStackId = undefined;
+                try {
+                    // update or create config JSON
+                    writeConfigFile({ projectId: updatedProjectId, stackId: updatedStackId });
+                    log('Configuration updated successfully.');
+                    return { success: true };
+                }
+                catch {
+                    log(`Unable to update config. These values should be set in ${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`);
+                    log(highlight(JSON.stringify({ metadata: { projectId: updatedProjectId, stackId: updatedStackId } }, null, 2)));
                     return {
                         success: false,
-                        error: 'Unable to test the configuration. Both Project and Stack IDs must be set.',
+                        error: `Be sure to update your ${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`,
                     };
                 }
             }
-            // LAUNCH LIMIT: 1 Stack per Project - do not set Stack ID if it's project-based
-            if (isProjectBasedId)
-                updatedStackId = undefined;
-            try {
-                // update or create config JSON
-                writeConfigFile({ projectId: updatedProjectId, stackId: updatedStackId });
-                log('Configuration updated successfully.');
-                return { success: true };
-            }
-            catch {
-                log(`Unable to update config. These values should be set in ${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`);
-                log(highlight(JSON.stringify({ metadata: { projectId: updatedProjectId, stackId: updatedStackId } }, null, 2)));
-                return {
-                    success: false,
-                    error: `Be sure to update your ${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`,
-                };
+            else {
+                log(warn('Only project-based Blueprints are currently supported.'));
+                return { success: false, error: 'Only project-based Blueprints are supported.' };
             }
         }
         // Default return (shouldn't reach here with proper flow control)
@@ -140,54 +87,3 @@ export async function blueprintConfigCore(options) {
         return { success: false, error: 'Unknown error' };
     }
 }
-async function testConfigAndReport({ token, stackId, projectId, }) {
-    const spinner = ora('Testing the configuration...').start();
-    const { ok, error } = await getStack({
-        stackId,
-        auth: { token, scopeType: 'project', scopeId: projectId },
-    });
-    if (!ok) {
-        spinner.fail('Configuration test failed.');
-    }
-    else {
-        spinner.succeed('Configuration is valid.');
-    }
-    return { ok, error };
-}
-async function startReinitializeStack({ token, projectId, }) {
-    const auth = { token, scopeType: 'project', scopeId: projectId };
-    // stack id IS ST-${projectId} – it has already been checked and doesn't exist
-    const { confirm } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'confirm',
-            message: `Do you want to create a ${chalk.blue('new')}, empty Blueprint deployment with the ${chalk.blue('existing')} configuration?`,
-        },
-    ]);
-    if (!confirm)
-        return { ok: false, error: 'Reinitialization cancelled.' };
-    const { ok: projectOk, project, error: projectError } = await getProject(auth);
-    if (!projectOk) {
-        return {
-            ok: false,
-            error: projectError || 'Failed to find Project while creating Stack',
-        };
-    }
-    const projectDisplayName = project.displayName;
-    const response = await createStack({
-        stackMutation: {
-            name: projectDisplayName,
-            scopeType: 'project',
-            scopeId: projectId,
-            document: { resources: [] },
-        },
-        auth,
-    });
-    if (!response.ok)
-        return { ok: false, error: response.error || 'Failed to create new Stack' };
-    return {
-        ok: true,
-        stackId: response.stack.id,
-        projectDisplayName,
-    };
-}

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

@@ -1,10 +1,11 @@
 import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
-import type { AuthParams, Stack } from '../../utils/types.js';
+import type { AuthParams, ScopeType, Stack } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintDeployOptions extends CoreConfig {
     auth: AuthParams;
     stackId: string;
-    projectId: string;
+    scopeType: ScopeType;
+    scopeId: string;
     deployedStack: Stack;
     blueprint: ReadBlueprintResult;
     flags: {

package/dist/cores/blueprints/deploy.js

@@ -7,7 +7,7 @@ import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { isLocalFunctionResource } from '../../utils/types.js';
 export async function blueprintDeployCore(options) {
-    const { bin = 'sanity', log, auth, stackId, projectId, deployedStack, blueprint, flags } = options;
+    const { bin = 'sanity', log, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
     const { verbose } = flags;
     const noWait = flags['no-wait'] || false;
     log(`Deploying "${deployedStack.name}" ${niceId(deployedStack.id)}...`);
@@ -51,8 +51,8 @@ export async function blueprintDeployCore(options) {
         const { ok: deployOk, stack, error: deployError, } = await updateStack({
             stackId,
             stackMutation: {
-                scopeType: 'project',
-                scopeId: projectId,
+                scopeType,
+                scopeId,
                 name: deployedStack.name,
                 document: { resources: validResources },
             },

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

@@ -6,6 +6,7 @@ export interface BlueprintDestroyOptions extends CoreConfig {
     flags: {
         force?: boolean;
         'project-id'?: string;
+        'organization-id'?: string;
         'stack-id'?: string;
         'no-wait'?: boolean;
     };

package/dist/cores/blueprints/destroy.js

@@ -7,22 +7,35 @@ import { destroyStack, getStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintDestroyCore(options) {
     const { log, token, blueprint, flags } = options;
-    const { force = false, 'project-id': flagProjectId, 'stack-id': flagStackId, 'no-wait': noWait = false, } = flags;
+    const { force = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'no-wait': noWait = false, } = flags;
     // 3-flag combo: just destroy it
-    if (flagProjectId && flagStackId && force) {
+    if ((flagProjectId || flagOrganizationId) && flagStackId && force) {
+        let scopeType;
+        let scopeId;
+        if (flagOrganizationId) {
+            scopeType = 'organization';
+            scopeId = flagOrganizationId;
+        }
+        else if (flagProjectId) {
+            scopeType = 'project';
+            scopeId = flagProjectId;
+        }
+        else {
+            return { success: false, error: 'Unable to determine scope for Blueprint Destroy' };
+        }
         const { ok, error, stack } = await destroyStack({
             stackId: flagStackId,
-            auth: { token, scopeType: 'project', scopeId: flagProjectId },
+            auth: { token, scopeType, scopeId },
         });
         if (!ok)
             return { success: false, error: error || 'Failed to destroy deployment' };
         log(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
         return { success: true };
     }
-    const { projectId, stackId } = blueprint;
-    if (!projectId)
-        return { success: false, error: 'Project ID is required' };
-    const auth = { token, scopeType: 'project', scopeId: projectId };
+    const { scopeType, scopeId, stackId } = blueprint;
+    if (!scopeType || !scopeId)
+        return { success: false, error: 'Scope is required' };
+    const auth = { token, scopeType, scopeId };
     let stack;
     try {
         if (flagStackId) {

package/dist/cores/blueprints/doctor.js

@@ -1,10 +1,12 @@
 import { cwd } from 'node:process';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
 import ora from 'ora';
 import { findBlueprintFile, readLocalBlueprint, } from '../../actions/blueprints/blueprint.js';
-import { getStack } from '../../actions/blueprints/stacks.js';
+import { createStack, getStack } from '../../actions/blueprints/stacks.js';
+import { getProject } from '../../actions/sanity/projects.js';
 import config from '../../config.js';
-import { check, indent, niceId, severe, warn } from '../../utils/display/presenters.js';
+import { capitalize, check, indent, niceId, severe, warn } from '../../utils/display/presenters.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 const diagLookup = {
     online: 'Online',
@@ -107,9 +109,8 @@ export async function blueprintDoctorCore(options) {
             if (scopeType && scopeId && stackId) {
                 diagnostics.configFileValid = true;
                 if (v) {
-                    const capitalizedScopeType = scopeType.charAt(0).toUpperCase() + scopeType.slice(1);
                     const configOutput = [
-                        `${capitalizedScopeType}: ${niceId(scopeId)}`,
+                        `${capitalize(scopeType)}: ${niceId(scopeId)}`,
                         `Deployment: ${niceId(stackId)}`,
                     ].join('\n');
                     log(indent(configOutput));
@@ -186,3 +187,41 @@ export async function blueprintDoctorCore(options) {
         return { success: false, error: 'One or more checks failed', data: { diagnostics } };
     }
 }
+// copied from old config --edit --test flow
+async function _startReinitializeStack({ token, projectId, }) {
+    const auth = { token, scopeType: 'project', scopeId: projectId };
+    // stack id IS ST-${projectId} – it has already been checked and doesn't exist
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Do you want to create a ${chalk.blue('new')}, empty Blueprint deployment with the ${chalk.blue('existing')} configuration?`,
+        },
+    ]);
+    if (!confirm)
+        return { ok: false, error: 'Reinitialization cancelled' };
+    const { ok: projectOk, project, error: projectError } = await getProject(auth);
+    if (!projectOk) {
+        return {
+            ok: false,
+            error: projectError || 'Failed to find Project while creating Stack',
+        };
+    }
+    const projectDisplayName = project.displayName;
+    const response = await createStack({
+        stackMutation: {
+            name: projectDisplayName,
+            scopeType: 'project',
+            scopeId: projectId,
+            document: { resources: [] },
+        },
+        auth,
+    });
+    if (!response.ok)
+        return { ok: false, error: response.error || 'Failed to create new Stack' };
+    return {
+        ok: true,
+        stackId: response.stack.id,
+        projectDisplayName,
+    };
+}

package/dist/cores/blueprints/index.d.ts

@@ -1,5 +1,3 @@
-export type { BlueprintAddOptions } from './add.js';
-export { blueprintAddCore } from './add.js';
 export type { BlueprintConfigOptions } from './config.js';
 export { blueprintConfigCore } from './config.js';
 export type { BlueprintDeployOptions } from './deploy.js';

package/dist/cores/blueprints/index.js

@@ -1,4 +1,3 @@
-export { blueprintAddCore } from './add.js';
 export { blueprintConfigCore } from './config.js';
 export { blueprintDeployCore } from './deploy.js';
 export { blueprintDestroyCore } from './destroy.js';

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

@@ -9,6 +9,7 @@ export interface BlueprintInitOptions extends CoreConfig {
         example?: string;
         'blueprint-type'?: string;
         'project-id'?: string;
+        'organization-id'?: string;
         'stack-id'?: string;
         'stack-name'?: string;
     };

package/dist/cores/blueprints/init.js

@@ -16,7 +16,9 @@ const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
 export async function blueprintInitCore(options) {
     const { bin = 'sanity', log, token, args, flags } = options;
     try {
-        const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
+        const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 
+        // 'organization-id': flagOrganizationId,
+        'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
         const { dir: argDir } = args;
         const providedDir = argDir || flagDir;
         const blueprintDir = providedDir || '.';

package/dist/cores/blueprints/plan.js

@@ -3,12 +3,12 @@ import { getStack } from '../../actions/blueprints/stacks.js';
 import { formatResourceTree, stackDeployDiff } from '../../utils/display/blueprints-formatting.js';
 export async function blueprintPlanCore(options) {
     const { bin = 'sanity', log, blueprint, token } = options;
-    const { projectId, stackId, parsedBlueprint, fileInfo } = blueprint;
+    const { scopeType, scopeId, stackId, parsedBlueprint, fileInfo } = blueprint;
     log(`${chalk.bold.blueBright('Blueprint Deployment Plan')} ${chalk.dim(`(${fileInfo.fileName})`)}`);
     log(formatResourceTree(parsedBlueprint.resources));
-    if (token && projectId && stackId) {
+    if (token && scopeType && scopeId && stackId) {
         const stackResponse = await getStack({
-            auth: { token, scopeType: 'project', scopeId: projectId },
+            auth: { token, scopeType, scopeId },
             stackId,
         });
         if (!stackResponse.ok) {

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

@@ -5,6 +5,7 @@ export interface BlueprintStacksOptions extends CoreConfig {
     blueprint: ReadBlueprintResult;
     flags: {
         'project-id'?: string;
+        'organization-id'?: string;
     };
 }
 export declare function blueprintStacksCore(options: BlueprintStacksOptions): Promise<CoreResult>;