@sanity/runtime-cli 14.13.3 → 15.0.0

package/dist/commands/blueprints/promote.js

@@ -1,5 +1,5 @@
 import { Flags } from '@oclif/core';
-import { ResolvedCommand } from '../../baseCommands.js';
+import { projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintPromoteCore } from '../../cores/blueprints/promote.js';
 import { Logger } from '../../utils/logger.js';
 export default class PromoteCommand extends ResolvedCommand {
@@ -8,20 +8,25 @@ export default class PromoteCommand extends ResolvedCommand {
     static description = `Promotes a deployed Stack to organization scope, enabling management of org-level resources. Promotion cannot be reversed.
 
 Your local Blueprint configuration will be updated to reflect the new scope.`;
-    static hidden = true;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --project-id <projectId> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --new-stack-name <new-name>',
     ];
     static flags = {
         stack: Flags.string({
             description: 'Stack name or ID to promote',
             aliases: ['id'],
         }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
         force: Flags.boolean({
             description: 'Skip confirmation prompt',
             default: false,
         }),
+        'new-stack-name': Flags.string({
+            description: 'Set a new name for the Stack while promoting',
+        }),
     };
     async run() {
         const result = await blueprintPromoteCore({

package/dist/commands/blueprints/stacks.js

@@ -21,7 +21,7 @@ Use --include-projects with --organization-id to also list Stacks from all proje
             ...projectIdFlagConfig,
             exclusive: ['organization-id', 'include-projects'],
         }),
-        'organization-id': Flags.string({ ...organizationIdFlagConfig, exclusive: ['project-id'] }),
+        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
         'include-projects': Flags.boolean({
             description: 'Include Stacks from all projects within the organization. Requires --organization-id.',
             dependsOn: ['organization-id'],

package/dist/commands/functions/add.js

@@ -1,7 +1,7 @@
 import { Flags } from '@oclif/core';
 import { ResolvedCommand } from '../../baseCommands.js';
 import { FUNCTION_TYPES } from '../../constants.js';
-import { functionAddCore } from '../../cores/functions/index.js';
+import { functionAddCore } from '../../cores/functions/add.js';
 import { Logger } from '../../utils/logger.js';
 import { INSTALLER_OPTIONS } from '../../utils/types.js';
 export default class AddCommand extends ResolvedCommand {

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;
@@ -12,10 +12,10 @@ export async function blueprintConfigCore(options) {
     const hasConfigFile = !!blueprintConfig;
     if (!configStackId && !configScopeType && !configScopeId) {
         if (hasConfigFile) {
-            log(warn('Incomplete configuration.'));
+            log(warn('Blueprint config (.sanity/blueprint.config.json) is incomplete.'));
         }
         else {
-            log('No configuration file found.');
+            log('No Blueprint config found at .sanity/blueprint.config.json.');
         }
         if (!editConfig) {
             log(`Run \`npx ${bin} blueprints doctor\` for diagnostics.`);
@@ -26,7 +26,7 @@ export async function blueprintConfigCore(options) {
         printConfig({ configLabel: 'Current', log, config: blueprintConfig });
     // passing new config without --edit flag is not allowed
     if (providedConfigFlag && !editConfig) {
-        log('To update the configuration, use the --edit flag.');
+        log('To update the Blueprint config, use the --edit flag.');
         return { success: true, json: blueprintConfig ? { config: blueprintConfig } : undefined };
     }
     if (!editConfig) {
@@ -70,44 +70,44 @@ export async function blueprintConfigCore(options) {
                     return { success: true, json: { config: newConfig } };
                 }
                 catch {
-                    return { success: false, error: 'Unable to update configuration.' };
+                    return {
+                        success: false,
+                        error: 'Could not update Blueprint config (.sanity/blueprint.config.json).',
+                    };
                 }
             }
         }
-        // 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 } };
         }
         catch {
-            return { success: false, error: 'Unable to update configuration!' };
+            return {
+                success: false,
+                error: 'Could not update Blueprint config (.sanity/blueprint.config.json).',
+            };
         }
     }
 }

package/dist/cores/blueprints/doctor.js

@@ -15,7 +15,7 @@ import { blueprintConfigCore } from './config.js';
 const diagLookup = {
     online: 'Host online',
     tokenValid: 'Authenticated',
-    blueprintValid: 'Blueprint valid',
+    blueprintValid: 'Manifest valid',
     stackReady: 'Stack ready',
     userHasAccess: 'User has access',
 };
@@ -24,9 +24,9 @@ function sourceLabel(source) {
         case 'env':
             return 'environment';
         case 'module':
-            return 'blueprint module';
+            return 'manifest module';
         case 'config':
-            return 'config file';
+            return '.sanity/blueprint.config.json';
         case 'inferred':
             return 'inferred';
         default:
@@ -91,7 +91,7 @@ export async function blueprintDoctorCore(options) {
             blueprintConfig,
             ...resolved,
         };
-        envRows.push(['Blueprint', filePathRelativeToCwd(blueprint.fileInfo.blueprintFilePath)]);
+        envRows.push(['Manifest', filePathRelativeToCwd(blueprint.fileInfo.blueprintFilePath)]);
         if (blueprint.errors.length === 0) {
             diagnostics.blueprintValid = { status: true };
         }
@@ -129,7 +129,7 @@ export async function blueprintDoctorCore(options) {
             configRows.push(['Source', filePathRelativeToCwd(blueprintConfig.configPath)]);
         }
         else if (!blueprintConfig) {
-            configRows.push(['Source', styleText('dim', 'no config file')]);
+            configRows.push(['Source', styleText('dim', 'no .sanity/blueprint.config.json')]);
         }
         if (blueprintConfig?.updatedAt) {
             configRows.push(['Updated', new Date(blueprintConfig.updatedAt).toLocaleString('sv-SE')]);
@@ -315,8 +315,8 @@ export async function blueprintDoctorCore(options) {
         if (!localBlueprint) {
             return {
                 success: false,
-                error: `${errorMessage}. Unable to fix: Blueprint is missing or invalid`,
-                suggestions: [`Run \`npx ${bin} blueprints init\` to create a new Blueprint.`],
+                error: `${errorMessage}. Unable to fix: Blueprint manifest is missing or invalid`,
+                suggestions: [`Run \`npx ${bin} blueprints init\` to create a new Blueprint manifest.`],
                 data: { diagnostics: flatDiagnostics },
             };
         }

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,15 @@
+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 defaultLabel(scopeType: ScopeType): string;
+export declare function blueprintMintDeployTokenCore(options: BlueprintMintDeployTokenOptions): Promise<CoreResult>;

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

@@ -0,0 +1,111 @@
+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',
+};
+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');
+        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;
+}