@sanity/runtime-cli 14.13.4 → 15.0.1

package/dist/cores/blueprints/config.js

@@ -1,7 +1,7 @@
 import { patchConfigFile, writeConfigFile, } from '../../actions/blueprints/config.js';
 import { resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
 import { filePathRelativeToCwd, labeledId, warn } from '../../utils/display/presenters.js';
-import { promptForProject, promptForStack } from '../../utils/display/prompt.js';
+import { runScopeAndStackWizard } from '../../utils/display/prompt.js';
 import { styleText } from '../../utils/style-text.js';
 export async function blueprintConfigCore(options) {
     const { bin = 'sanity', blueprint, log, token, flags } = options;
@@ -77,35 +77,29 @@ export async function blueprintConfigCore(options) {
                 }
             }
         }
-        // prompt for values interactively
-        // do not yet offer organization as scope option
-        let updatedProjectId = flagProjectId;
-        if (!updatedProjectId) {
-            const pickedProject = await promptForProject({
-                token,
-                knownProjectId: configScopeId,
-                logger: log,
-            });
-            updatedProjectId = pickedProject.projectId;
-        }
-        if (!updatedProjectId)
-            return { success: false, error: 'Project ID is required.' };
-        let updatedStackId;
-        if (flagStack) {
-            updatedStackId = await resolveStackIdByNameOrId(flagStack, { token, scopeType: 'project', scopeId: updatedProjectId }, log);
-        }
-        if (!updatedStackId) {
-            const pickedStack = await promptForStack({ projectId: updatedProjectId, token, logger: log });
-            updatedStackId = pickedStack.stackId;
-        }
-        if (!updatedStackId)
-            return { success: false, error: 'Stack is required.' };
+        // prompt for values interactively via wizard: org -> scope -> project (if needed) -> stack
+        log('');
+        const knownOrganizationId = configScopeType === 'organization' ? configScopeId : undefined;
+        const knownProjectId = configScopeType === 'project' ? configScopeId : undefined;
+        const wizardResult = await runScopeAndStackWizard({
+            token,
+            knownOrganizationId,
+            knownProjectId,
+            logger: log,
+        });
+        if (!wizardResult.scopeId)
+            return { success: false, error: 'Scope selection is required.' };
         try {
-            // update or create config JSON
-            const newConfig = writeConfigFile(blueprintFilePath, {
-                projectId: updatedProjectId,
-                stackId: updatedStackId,
-            });
+            // update or create config JSON with correct scope fields
+            const configUpdate = { stackId: wizardResult.stackId };
+            if (wizardResult.scopeType === 'organization') {
+                configUpdate.organizationId = wizardResult.scopeId;
+            }
+            else {
+                configUpdate.projectId = wizardResult.scopeId;
+            }
+            const newConfig = writeConfigFile(blueprintFilePath, configUpdate);
+            log('');
             printConfig({ configLabel: hasConfigFile ? 'Updated' : 'New', log, config: newConfig });
             return { success: true, json: { config: newConfig } };
         }

package/dist/cores/blueprints/init.js

@@ -3,18 +3,24 @@ import { join } from 'node:path';
 import { confirm } from '@inquirer/prompts';
 import { findBlueprintFile, readLocalBlueprint, writeBlueprintToDisk, } from '../../actions/blueprints/blueprint.js';
 import { writeConfigFile } from '../../actions/blueprints/config.js';
-import { createEmptyStack } from '../../actions/blueprints/stacks.js';
+import { createEmptyStack, getStack } from '../../actions/blueprints/stacks.js';
 import { writeGitignoreFile } from '../../actions/git.js';
 import { writeOrUpdateNodeDependency } from '../../actions/node.js';
 import { verifyExampleExists, writeExample } from '../../actions/sanity/examples.js';
 import { getProject } from '../../actions/sanity/projects.js';
 import { BLUEPRINT_CONFIG_DIR, BLUEPRINT_CONFIG_FILE } from '../../config.js';
 import { check, filePathRelativeToCwd, labeledId, warn } from '../../utils/display/presenters.js';
-import { promptForBlueprintType, promptForProject, promptForStack, } from '../../utils/display/prompt.js';
+import { promptForBlueprintType, promptForOrganization, promptForProjectInOrg, promptForStack, runScopeAndStackWizard, } from '../../utils/display/prompt.js';
 import { styleText } from '../../utils/style-text.js';
 import { blueprintConfigCore } from './config.js';
-const SCOPE_PROJECT = 'project';
-const SCOPE_ORGANIZATION = 'organization';
+/** Derive scope type and ID from mutually exclusive flag values. */
+function resolveScopeFromFlags(projectId, organizationId) {
+    if (projectId)
+        return { scopeType: 'project', scopeId: projectId };
+    if (organizationId)
+        return { scopeType: 'organization', scopeId: organizationId };
+    return undefined;
+}
 export async function blueprintInitCore(options) {
     const { bin = 'sanity', log, token, knownProjectId, args, flags, validateResources } = options;
     const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'stack-name': flagStackName, verbose = false, } = flags;
@@ -87,23 +93,15 @@ async function handleExistingBlueprint(options) {
             error: 'Flag --example cannot be used with an existing Blueprint.',
         };
     }
-    // existing blueprint file, user wants to configure a stack
-    // --stack-name means they want a new stack created
+    // --stack-name with a scope flag means create a new stack before configuring
     let resolvedStackId = flagStackId;
     if (!resolvedStackId && flagStackName) {
-        const scopeId = flagProjectId || flagOrganizationId;
-        let scopeType;
-        if (flagProjectId)
-            scopeType = SCOPE_PROJECT;
-        else if (flagOrganizationId)
-            scopeType = SCOPE_ORGANIZATION;
-        if (scopeType && scopeId) {
-            // have what we need to create a new stack
-            log(`\nCreating new Stack "${flagStackName}" scoped to ${labeledId(scopeType, scopeId)}`);
+        const scope = resolveScopeFromFlags(flagProjectId, flagOrganizationId);
+        if (scope) {
+            log(`\nCreating new Stack "${flagStackName}" scoped to ${labeledId(scope.scopeType, scope.scopeId)}`);
             const stack = await createEmptyStack({
                 token,
-                scopeType,
-                scopeId,
+                ...scope,
                 name: flagStackName,
                 logger: log,
             });
@@ -168,8 +166,11 @@ export function validateFlags(flags) {
     if (stackId && stackName) {
         return { success: false, error: 'Cannot specify both --stack-id and --stack-name' };
     }
-    if (organizationId && projectId) {
-        return { success: false, error: 'Cannot specify both --organization-id and --project-id' };
+    if ((stackId || stackName) && !organizationId && !projectId) {
+        return {
+            success: false,
+            error: `${stackId ? '--stack-id' : '--stack-name'} requires --project-id or --organization-id`,
+        };
     }
     return null;
 }
@@ -184,10 +185,20 @@ async function handleExampleInitialization(options) {
     if (!exampleExists) {
         return { success: false, error: `Blueprint example "${exampleName}" does not exist.` };
     }
-    const resolvedProjectId = projectId || (await promptForProject({ token, logger: log })).projectId;
+    let resolvedProjectId = projectId;
+    if (!resolvedProjectId) {
+        // examples are project-scoped; use the composable prompts to pick an org then a project
+        const orgResult = await promptForOrganization({ token, logger: log });
+        if (typeof orgResult === 'symbol')
+            throw new Error('Unexpected back navigation');
+        const picked = await promptForProjectInOrg({ projects: orgResult.projects, logger: log });
+        if (typeof picked === 'symbol')
+            throw new Error('Unexpected back navigation');
+        resolvedProjectId = picked.projectId;
+    }
     const stack = await createEmptyStack({
         token,
-        scopeType: SCOPE_PROJECT,
+        scopeType: 'project',
         scopeId: resolvedProjectId,
         name: `example-${exampleName}`,
         logger: log,
@@ -225,69 +236,81 @@ async function handleExampleInitialization(options) {
 }
 export async function resolveScopeAndStack(params) {
     const { projectId, organizationId, stackId, stackName, knownProjectId, log, token } = params;
-    let scopeType = SCOPE_PROJECT;
-    let scopeId;
-    if (projectId) {
-        scopeType = SCOPE_PROJECT;
-        scopeId = projectId;
-    }
-    else if (organizationId) {
-        scopeType = SCOPE_ORGANIZATION;
-        scopeId = organizationId;
+    const flagScope = resolveScopeFromFlags(projectId, organizationId);
+    // --- Branch 1: Scope provided via flags ---
+    if (flagScope) {
+        const { scopeType, scopeId } = flagScope;
+        let resolvedStackId = stackId;
+        // --stack-name: create a new stack
+        if (!resolvedStackId && stackName) {
+            log(`\nCreating new Stack "${stackName}" scoped to ${labeledId(scopeType, scopeId)}`);
+            const stack = await createEmptyStack({
+                token,
+                scopeType,
+                scopeId,
+                name: stackName,
+                logger: log,
+            });
+            resolvedStackId = stack.id;
+        }
+        // --stack-id: validate it exists
+        if (resolvedStackId && resolvedStackId === stackId) {
+            const spinner = log.ora('Validating Stack...').start();
+            const { ok, error } = await getStack({
+                stackId: resolvedStackId,
+                auth: { token, scopeType, scopeId },
+                logger: log,
+            });
+            spinner.stop();
+            if (!ok) {
+                throw new Error(error || `Stack "${resolvedStackId}" not found for ${scopeType} "${scopeId}".`);
+            }
+        }
+        // No stack flag: prompt for stack selection
+        if (!resolvedStackId) {
+            log('\nBlueprints are deployed to a "Stack".');
+            const stackResult = await promptForStack({ scopeType, scopeId, token, logger: log });
+            if (typeof stackResult === 'symbol')
+                throw new Error('Unexpected back navigation');
+            resolvedStackId = stackResult.stackId;
+        }
+        return { scopeType, scopeId, stackId: resolvedStackId };
     }
-    let resolvedStackId = stackId;
-    if (!resolvedStackId && stackName && scopeType && scopeId) {
-        // sending stackName will assume you want to create a new stack
-        // essentially the only way to create an org-scoped stack
-        log(`\nCreating new Stack "${stackName}" scoped to ${labeledId(scopeType, scopeId)}`);
-        const stack = await createEmptyStack({
+    // --- Branch 2: No scope flags -- interactive resolution ---
+    log('\nBlueprints are scoped to an organization or project.');
+    log(styleText('dim', 'Scope determines which resources your Blueprint can manage.\n' +
+        'Organization scope covers all projects; project scope is limited to one.'));
+    // Offer the CLI's configured project as a shortcut
+    if (knownProjectId) {
+        const { ok, project } = await getProject({
             token,
-            scopeType,
-            scopeId,
-            name: stackName,
+            scopeId: knownProjectId,
+            scopeType: 'project',
             logger: log,
         });
-        resolvedStackId = stack.id;
-    }
-    if (!scopeId) {
-        log('\nBlueprints are associated with a Sanity project.');
-        // If we have a CLI project ID, offer it as a suggestion
-        if (knownProjectId) {
-            const { ok, project } = await getProject({
-                token,
-                scopeId: knownProjectId,
-                scopeType: 'project',
-                logger: log,
+        if (ok && project) {
+            const useCliProject = await confirm({
+                message: `The CLI is configured to use "${project.displayName}" (${knownProjectId}). Use this for the blueprint?`,
+                default: true,
             });
-            if (ok && project) {
-                const useCliProject = await confirm({
-                    message: `The CLI is configured to use "${project.displayName}" (${knownProjectId}). Use this for the blueprint?`,
-                    default: true,
+            if (useCliProject) {
+                // Scope locked to project; just need a stack
+                log('\nBlueprints are deployed to a "Stack".');
+                const stackResult = await promptForStack({
+                    scopeType: 'project',
+                    scopeId: knownProjectId,
+                    token,
+                    logger: log,
                 });
-                if (useCliProject) {
-                    scopeType = SCOPE_PROJECT;
-                    scopeId = knownProjectId;
-                }
+                if (typeof stackResult === 'symbol')
+                    throw new Error('Unexpected back navigation');
+                return { scopeType: 'project', scopeId: knownProjectId, stackId: stackResult.stackId };
             }
         }
-        // If still no scope (no knownProjectId, lookup failed, or user declined), prompt for selection
-        if (!scopeId) {
-            log('Select a project:');
-            const pickedProject = await promptForProject({ token, logger: log });
-            scopeType = SCOPE_PROJECT;
-            scopeId = pickedProject.projectId;
-        }
     }
-    if (!resolvedStackId) {
-        log('\nBlueprints are deployed to a "Stack".');
-        const { stackId } = await promptForStack({ projectId: scopeId, token, logger: log });
-        resolvedStackId = stackId;
-    }
-    return {
-        scopeType,
-        scopeId,
-        stackId: resolvedStackId,
-    };
+    // Full wizard: org -> scope -> project (if needed) -> stack
+    const wizard = await runScopeAndStackWizard({ token, logger: log });
+    return { scopeType: wizard.scopeType, scopeId: wizard.scopeId, stackId: wizard.stackId };
 }
 export async function determineBlueprintExtension(params) {
     const { requestedType, blueprintDir, log } = params;
@@ -329,7 +352,7 @@ export async function createBlueprintFiles(params) {
     log(check(`${styleText('bold', 'Created Blueprint:')}   ${displayPath}/${blueprintFileName}`));
     writeConfigFile(blueprintFilePath, {
         stackId,
-        ...(scopeType === SCOPE_ORGANIZATION ? { organizationId: scopeId } : { projectId: scopeId }),
+        ...(scopeType === 'organization' ? { organizationId: scopeId } : { projectId: scopeId }),
     });
     log(check(`${styleText('bold', 'Added configuration:')} ${displayPath}/${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`));
     const gitignoreResult = writeGitignoreFile(blueprintFilePath);

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

@@ -7,6 +7,9 @@ export interface BlueprintLogsOptions extends CoreConfig {
     flags: {
         watch?: boolean;
         verbose?: boolean;
+        limit?: number;
+        since?: string;
+        before?: string;
     };
 }
 export declare function blueprintLogsCore(options: BlueprintLogsOptions): Promise<CoreResult>;

package/dist/cores/blueprints/logs.js

@@ -1,16 +1,18 @@
-import { getLogs, getRecentLogs } from '../../actions/blueprints/logs.js';
+import { getLogs } from '../../actions/blueprints/logs.js';
 import { setupLogPolling } from '../../actions/blueprints/logs-polling.js';
 import { formatTitle } from '../../utils/display/blueprints-formatting.js';
 import { formatLogEntry, formatLogs } from '../../utils/display/logs-formatting.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
+/** Number of recent logs to show before entering watch mode */
+const WATCH_PREFETCH_LIMIT = 10;
 export async function blueprintLogsCore(options) {
     const { log, auth, stackId, deployedStack, flags } = options;
-    const { watch = false, verbose = false } = flags;
+    const { watch = false, verbose = false, limit, since, before } = flags;
     const spinner = log.ora(`Fetching recent logs for Stack deployment ${niceId(stackId)}`).start();
     try {
         if (watch) {
-            const { ok, logs, error } = await getLogs({ stackId }, auth, log);
+            const { ok, logs, error } = await getLogs({ stackId, limit: WATCH_PREFETCH_LIMIT }, auth, log);
             if (!ok) {
                 spinner.fail(`${styleText('red', 'Failed')} to retrieve logs`);
                 log.error(`Error: ${error || 'Unknown error'}`);
@@ -20,9 +22,10 @@ export async function blueprintLogsCore(options) {
             log(`${formatTitle('Blueprint', deployedStack.name)} ${niceId(stackId)} logs`);
             if (logs.length > 0) {
                 log('\nMost recent logs:');
-                const recentLogs = getRecentLogs(logs);
+                // API returns newest first; display in chronological order
+                const orderedLogs = [...logs].reverse();
                 let previousLog;
-                for (const logEntry of recentLogs) {
+                for (const logEntry of orderedLogs) {
                     log(formatLogEntry(logEntry, verbose, previousLog));
                     previousLog = logEntry;
                 }
@@ -39,14 +42,14 @@ export async function blueprintLogsCore(options) {
                 showBanner: true,
                 verbose,
             });
-            // Return a special key for polling mode
+            // Return a never-resolving promise so the polling loop keeps running
             return {
                 success: true,
                 streaming: new Promise(() => { }),
             };
         }
-        // Regular non-streaming logs
-        const { ok, logs, error } = await getLogs({ stackId }, auth, log);
+        // One-shot fetch (no watch)
+        const { ok, logs, error, hasMore } = await getLogs({ stackId, limit, before, after: since }, auth, log);
         if (!ok) {
             spinner.fail(`${styleText('red', 'Failed')} to retrieve Stack deployment logs`);
             log.error(`Error: ${error || 'Unknown error'}`);
@@ -59,7 +62,10 @@ export async function blueprintLogsCore(options) {
         spinner.succeed(`${formatTitle('Blueprint', deployedStack.name)} Logs`);
         log(`Found ${styleText('bold', logs.length.toString())} log entries for Stack deployment ${niceId(stackId)}\n`);
         log(formatLogs(logs, verbose));
-        return { success: true, json: { logs } };
+        if (hasMore) {
+            log(`\n${styleText('dim', 'More logs available. Narrow the range with --before <timestamp> or raise --limit (max 500).')}`);
+        }
+        return { success: true, json: { logs, hasMore } };
     }
     catch (err) {
         spinner.fail('Failed to retrieve Stack deployment logs');

package/dist/cores/blueprints/mint-deploy-token.d.ts

@@ -0,0 +1,16 @@
+import type { AuthParams, ScopeType } from '../../utils/types.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintMintDeployTokenOptions extends CoreConfig {
+    auth: AuthParams;
+    scopeType: ScopeType;
+    scopeId: string;
+    flags: {
+        label?: string;
+        print?: boolean;
+        json?: boolean;
+        verbose?: boolean;
+    };
+}
+export declare function isRoleUnavailableError(error: string): boolean;
+export declare function defaultLabel(scopeType: ScopeType): string;
+export declare function blueprintMintDeployTokenCore(options: BlueprintMintDeployTokenOptions): Promise<CoreResult>;

package/dist/cores/blueprints/mint-deploy-token.js

@@ -0,0 +1,123 @@
+import { hostname } from 'node:os';
+import { confirm, input, select } from '@inquirer/prompts';
+import { createRobotToken } from '../../actions/sanity/access.js';
+import { ClipboardUnavailableError, write as clipboardWrite } from '../../utils/clipboard.js';
+import { styleText } from '../../utils/style-text.js';
+const ROLE_BY_SCOPE = {
+    project: 'blueprints-deployer',
+    organization: 'blueprints-deployer-robot',
+};
+// Matches Access API's "Role not found: <name>" 404 message.
+export function isRoleUnavailableError(error) {
+    return /^\s*role not found\b/i.test(error);
+}
+export function defaultLabel(scopeType) {
+    const date = new Date().toISOString().slice(0, 10);
+    let host = 'unknown-host';
+    try {
+        host = hostname();
+    }
+    catch { }
+    return `blueprints-deployer @ ${host} ${date} (${scopeType})`;
+}
+export async function blueprintMintDeployTokenCore(options) {
+    const { log, auth, scopeType, scopeId, flags } = options;
+    const label = flags.label ?? defaultLabel(scopeType);
+    const roleName = ROLE_BY_SCOPE[scopeType];
+    const spinner = log.ora('Minting deploy token...').start();
+    const { ok, error, robot } = await createRobotToken({
+        auth,
+        resourceType: scopeType,
+        resourceId: scopeId,
+        body: {
+            label,
+            memberships: [{ resourceType: scopeType, resourceId: scopeId, roleNames: [roleName] }],
+        },
+        logger: log,
+    });
+    if (!ok || !robot) {
+        spinner.fail('Failed to mint deploy token');
+        if (error && isRoleUnavailableError(error)) {
+            return {
+                success: false,
+                error: `The "${roleName}" role is not available in this ${scopeType}.`,
+                code: 'ROLE_UNAVAILABLE',
+                suggestions: [],
+            };
+        }
+        const suggestions = [];
+        if (error && /access|permission|forbidden|role/i.test(error)) {
+            suggestions.push(scopeType === 'organization'
+                ? 'Verify you have organization admin access.'
+                : 'Verify you have project admin access.');
+        }
+        return { success: false, error: error || 'Failed to mint deploy token', suggestions };
+    }
+    spinner.stop().clear();
+    if (flags.print) {
+        log(robot.token);
+        return { success: true, json: serializeRobot(robot) };
+    }
+    if (flags.json) {
+        return { success: true, json: serializeRobot(robot) };
+    }
+    log(styleText('green', `Minted "${robot.label}" (${robot.id})`));
+    if (robot.expiresAt) {
+        log(styleText('dim', `Expires: ${robot.expiresAt}`));
+    }
+    const action = await select({
+        message: 'What would you like to do with the token?',
+        choices: [
+            { name: 'Copy to clipboard', value: 'copy' },
+            { name: 'Print to terminal', value: 'print' },
+            { name: 'Exit (token will be lost)', value: 'exit' },
+        ],
+        default: 'copy',
+    });
+    if (action === 'copy') {
+        try {
+            await clipboardWrite(robot.token);
+            log(styleText('green', 'Token copied to clipboard.'));
+        }
+        catch (err) {
+            const msg = err instanceof ClipboardUnavailableError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            log.warn(styleText('yellow', `Could not copy to clipboard: ${msg}`));
+            const printInstead = await confirm({
+                message: 'Print the token to the terminal instead?',
+                default: false,
+            });
+            if (printInstead) {
+                await printAndConfirm(log, robot.token);
+            }
+            else {
+                log(styleText('yellow', 'Token discarded. You can mint a new one anytime.'));
+            }
+        }
+    }
+    else if (action === 'print') {
+        await printAndConfirm(log, robot.token);
+    }
+    else {
+        log(styleText('yellow', 'Token discarded. You can mint a new one anytime.'));
+    }
+    return { success: true, json: serializeRobot(robot) };
+}
+/**
+ * Show the token inside an inquirer prompt and rely on `clearPromptOnDone`
+ * so inquirer wipes the entire rendered block (token included) on Enter.
+ */
+async function printAndConfirm(log, token) {
+    await input({
+        message: `\n${token}\n\nPress Enter once you have copied the token (it will be erased):`,
+        default: '',
+        theme: { prefix: '' },
+    }, { clearPromptOnDone: true });
+    log(styleText('dim', 'Token erased.'));
+}
+function serializeRobot(robot) {
+    return robot;
+}

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

@@ -3,6 +3,7 @@ export interface BlueprintPromoteOptions extends DeployedBlueprintConfig {
     flags: {
         force?: boolean;
         verbose?: boolean;
+        'new-stack-name'?: string;
     };
 }
 export declare function blueprintPromoteCore(options: BlueprintPromoteOptions): Promise<CoreResult>;

package/dist/cores/blueprints/promote.js

@@ -4,10 +4,23 @@ import { promoteStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintPromoteCore(options) {
     const { bin = 'sanity', log, stackId, auth, flags, deployedStack, blueprint } = options;
+    const newStackName = flags['new-stack-name'];
+    if (newStackName && deployedStack.scopeType === 'organization') {
+        return {
+            success: false,
+            error: '--new-stack-name can only be used when promoting a project-scoped Stack to organization scope.',
+            suggestions: [
+                `Stack "${deployedStack.name}" ${niceId(deployedStack.id)} is already org-scoped.`,
+            ],
+        };
+    }
     let message = `"${deployedStack.name}" ${niceId(deployedStack.id)}`;
     if (deployedStack.scopeType === 'organization') {
         message = `Stack ${message} is already org-scoped. Promote again?`;
     }
+    else if (newStackName) {
+        message = `Promote Stack ${message} from project to organization scope and rename to "${newStackName}"? You will need admin access to your organization.`;
+    }
     else {
         message = `Promote Stack ${message} from project to organization scope? You will need admin access to your organization.`;
     }
@@ -19,10 +32,18 @@ export async function blueprintPromoteCore(options) {
     }
     try {
         const spinner = log.ora('Promoting Stack...').start();
-        const { ok, error, stack } = await promoteStack({ stackId, auth, logger: log });
+        const { ok, error, stack, response } = await promoteStack({
+            stackId,
+            auth,
+            logger: log,
+            name: newStackName,
+        });
         if (!ok) {
             spinner.fail('Failed to promote Stack');
             const suggestions = [];
+            if (response?.status === 409) {
+                suggestions.push('A Stack with this name already exists in the target organization. Use --new-stack-name <name> to rename while promoting.');
+            }
             if (error && /access|permission|forbidden/i.test(error)) {
                 suggestions.push('Verify you have organization admin access.');
             }

package/dist/cores/functions/add.js

@@ -5,9 +5,7 @@ import { checkbox, confirm, input, select } from '@inquirer/prompts';
 import { highlight } from 'cardinal';
 import { createFunctionResource } from '../../actions/blueprints/resources.js';
 import { verifyExampleExists, writeExample } from '../../actions/sanity/examples.js';
-import { EVENT_DOCUMENT_CREATE, EVENT_DOCUMENT_DELETE, EVENT_DOCUMENT_UPDATE, EVENT_MEDIA_LIBRARY_ASSET_CREATE, EVENT_MEDIA_LIBRARY_ASSET_DELETE, EVENT_MEDIA_LIBRARY_ASSET_UPDATE, EVENT_SYNC_TAG_INVALIDATE, 
-// EVENT_SCHEDULED,
-FUNCTION_TYPES, LABEL_DOCUMENT_CREATE, LABEL_DOCUMENT_DELETE, LABEL_DOCUMENT_UPDATE, LABEL_MEDIA_LIBRARY_ASSET_CREATE, LABEL_MEDIA_LIBRARY_ASSET_DELETE, LABEL_MEDIA_LIBRARY_ASSET_UPDATE, LABEL_SCHEDULED, LABEL_SYNC_TAG_INVALIDATE, MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
+import { EVENT_DOCUMENT_CREATE, EVENT_DOCUMENT_DELETE, EVENT_DOCUMENT_UPDATE, EVENT_MEDIA_LIBRARY_ASSET_CREATE, EVENT_MEDIA_LIBRARY_ASSET_DELETE, EVENT_MEDIA_LIBRARY_ASSET_UPDATE, EVENT_SCHEDULED, EVENT_SYNC_TAG_INVALIDATE, FUNCTION_TYPES, LABEL_DOCUMENT_CREATE, LABEL_DOCUMENT_DELETE, LABEL_DOCUMENT_UPDATE, LABEL_MEDIA_LIBRARY_ASSET_CREATE, LABEL_MEDIA_LIBRARY_ASSET_DELETE, LABEL_MEDIA_LIBRARY_ASSET_UPDATE, LABEL_SCHEDULED, LABEL_SYNC_TAG_INVALIDATE, MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
 import { check, indent, warn } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
 import { validateFunctionName } from '../../utils/validate/resource.js';
@@ -152,7 +150,8 @@ export async function functionAddCore(options) {
         if (fnTypes.length === 0) {
             throw new Error('At least one function type must be provided.');
         }
-        if (!fnTypes.every((evt) => FUNCTION_TYPES.includes(evt))) {
+        const validTypes = new Set(FUNCTION_TYPES);
+        if (!fnTypes.every((evt) => validTypes.has(evt))) {
             throw new Error(`Invalid function type. Must be one of: ${FUNCTION_TYPES.join(', ').trim()}`);
         }
         const eventSources = new Set(fnTypes.map((t) => t.substring(0, t.lastIndexOf('-'))));
@@ -241,8 +240,8 @@ async function promptForFunctionType() {
             { name: LABEL_MEDIA_LIBRARY_ASSET_CREATE, value: EVENT_MEDIA_LIBRARY_ASSET_CREATE },
             { name: LABEL_MEDIA_LIBRARY_ASSET_UPDATE, value: EVENT_MEDIA_LIBRARY_ASSET_UPDATE },
             { name: LABEL_MEDIA_LIBRARY_ASSET_DELETE, value: EVENT_MEDIA_LIBRARY_ASSET_DELETE },
+            { name: LABEL_SCHEDULED, value: EVENT_SCHEDULED },
             { name: LABEL_SYNC_TAG_INVALIDATE, value: EVENT_SYNC_TAG_INVALIDATE },
-            // {name: LABEL_SCHEDULED, value: EVENT_SCHEDULED},
         ],
         validate(choices) {
             if (choices.length === 0) {

package/dist/cores/index.d.ts

@@ -1,8 +1,6 @@
 import { type ReadBlueprintResult } from '../actions/blueprints/blueprint.js';
 import type { Logger } from '../utils/logger.js';
 import type { AuthParams, Result, ScopeType, Stack } from '../utils/types.js';
-export * as blueprintsCores from './blueprints/index.js';
-export * as functionsCores from './functions/index.js';
 export interface CoreConfig {
     /** The CLI binary name. */
     bin: string;
@@ -67,3 +65,4 @@ export declare function initDeployedBlueprintConfig(config: Partial<BlueprintCon
     validateToken?: boolean;
     stackOverride?: string;
 }): Promise<Result<DeployedBlueprintConfig>>;
+export {};

package/dist/cores/index.js

@@ -2,8 +2,6 @@ import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
 import { getStack, resolveStackIdByNameOrId } from '../actions/blueprints/stacks.js';
 import { presentBlueprintParserErrors } from '../utils/display/errors.js';
 import { validTokenOrErrorMessage } from '../utils/validated-token.js';
-export * as blueprintsCores from './blueprints/index.js';
-export * as functionsCores from './functions/index.js';
 export async function initBlueprintConfig({ bin, log, token, validateResources = false, validateToken = true, blueprintPath, }) {
     let checkedToken = token;
     if (!token || (token && validateToken)) {