@sanity/runtime-cli 14.13.3 → 15.0.0

package/dist/actions/blueprints/blueprint.js

@@ -87,11 +87,11 @@ export async function loadBlueprintFile(fileInfo) {
                 break;
             }
             default:
-                throw Error(`Unsupported blueprint file extension: ${extension}`);
+                throw Error(`Unsupported Blueprint manifest extension: ${extension}`);
         }
     }
     catch (err) {
-        throw Error(`Unable to parse Blueprint file: ${fileName}\n${err}`);
+        throw Error(`Could not parse Blueprint manifest: ${fileName}\n${err}`);
     }
     // Dynamic modules: extract attached properties, then execute to get raw blueprint
     if (blueprintModule) {
@@ -100,15 +100,15 @@ export async function loadBlueprintFile(fileInfo) {
                 rawBlueprint = blueprintModule();
             }
             catch {
-                throw Error(`Error executing Blueprint file: ${fileName}`);
+                throw Error(`Error executing Blueprint manifest: ${fileName}`);
             }
         }
         else {
-            throw Error(`Blueprint ${fileName} must export a default function`);
+            throw Error(`Blueprint manifest ${fileName} must export a default function.`);
         }
     }
     if (typeof rawBlueprint === 'undefined') {
-        throw Error('Unable to read Blueprint');
+        throw Error('Could not read Blueprint manifest.');
     }
     return { rawBlueprint, module: blueprintModule };
 }
@@ -148,8 +148,9 @@ export function parseBlueprintContent(rawBlueprint, options) {
  */
 export async function loadAndParseBlueprint(blueprintPath, options = { validateResources: true }) {
     const fileInfo = findBlueprintFile(blueprintPath);
-    if (!fileInfo)
-        throw Error('Could not find Blueprint file! Use the `blueprints init` command.');
+    if (!fileInfo) {
+        throw Error('Could not find a Blueprint manifest (sanity.blueprint.ts, .js, or .json). Run `blueprints init` to create one.');
+    }
     const loaded = await loadBlueprintFile(fileInfo);
     const parsed = parseBlueprintContent(loaded.rawBlueprint, options);
     return {
@@ -169,8 +170,9 @@ export async function loadAndParseBlueprint(blueprintPath, options = { validateR
  */
 export async function readLocalBlueprint(logger, validate, blueprintPath) {
     const fileInfo = findBlueprintFile(blueprintPath);
-    if (!fileInfo)
-        throw Error('Could not find Blueprint file! Use the `blueprints init` command.');
+    if (!fileInfo) {
+        throw Error('Could not find a Blueprint manifest (sanity.blueprint.ts, .js, or .json). Run `blueprints init` to create one.');
+    }
     // 1. Load blueprint from disk
     const loaded = await loadBlueprintFile(fileInfo);
     const { rawBlueprint } = loaded;
@@ -226,7 +228,7 @@ export function writeBlueprintToDisk({ blueprintFilePath, jsonContent = JSON_BLU
             break;
         }
         default: {
-            throw Error(`Unsupported blueprint file extension: ${extension}`);
+            throw Error(`Unsupported Blueprint manifest extension: ${extension}`);
         }
     }
     mkdirSync(dir, { recursive: true });
@@ -236,7 +238,7 @@ export function writeBlueprintToDisk({ blueprintFilePath, jsonContent = JSON_BLU
 export function addResourceToBlueprint({ blueprintFilePath, resource, }) {
     const blueprintFile = findBlueprintFile(blueprintFilePath);
     if (!blueprintFile)
-        throw Error('Could not find Blueprint file');
+        throw Error('Could not find a Blueprint manifest.');
     const { blueprintFilePath: foundPath, extension } = blueprintFile;
     // modify .json files directly
     if (extension === '.json') {

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

@@ -6,8 +6,9 @@ export interface GetLogsParams {
     operationId?: string;
     limit?: number;
     before?: string;
+    after?: string;
 }
 export declare function getLogs(params: GetLogsParams, auth: AuthParams, logger: Logger): Promise<ActionResponse & {
     logs: BlueprintLog[];
+    hasMore: boolean;
 }>;
-export declare function getRecentLogs(logs: BlueprintLog[], limit?: number): BlueprintLog[];

package/dist/actions/blueprints/logs.js

@@ -14,19 +14,18 @@ export async function getLogs(params, auth, logger) {
         url.searchParams.append('limit', String(params.limit));
     if (params.before)
         url.searchParams.append('before', params.before);
+    if (params.after)
+        url.searchParams.append('after', params.after);
     const response = await fetchFn(url.toString(), {
         headers: getHeaders(auth),
         method: 'GET',
     });
     const result = await response.json();
+    const hasMore = response.headers.get('X-Has-More') === 'true';
     return {
         ok: response.ok,
         error: response.ok ? null : result.message || 'Unknown error',
         logs: response.ok ? result : [],
+        hasMore: response.ok ? hasMore : false,
     };
 }
-// Get most recent logs, up to a limit
-export function getRecentLogs(logs, limit = 10) {
-    const sortedLogs = [...logs].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-    return sortedLogs.slice(-limit);
-}

package/dist/actions/blueprints/resources.js

@@ -125,6 +125,7 @@ export async function createFunctionResource(options, logger) {
                 src: `functions/${name}`,
                 type: SANITY_FUNCTION_SCHEDULED,
                 event: {
+                    // @ts-expect-error use shorthand
                     expression: '0 0 * * *',
                 },
             };

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

@@ -107,11 +107,13 @@ interface PromoteStackResponse extends ActionResponse {
     stack: Stack & {
         alreadyPromoted: boolean;
     };
+    response?: Response;
 }
-export declare function promoteStack({ stackId, auth, logger, }: {
+export declare function promoteStack({ stackId, auth, logger, name, }: {
     stackId: string;
     auth: AuthParams;
     logger: Logger;
+    name?: string;
 }): Promise<PromoteStackResponse>;
 export declare function destroyStack({ stackId, auth, logger, }: {
     stackId: string;

package/dist/actions/blueprints/stacks.js

@@ -45,6 +45,11 @@ export async function createStack({ stackMutation, auth, logger, }) {
     };
 }
 export async function createEmptyStack({ token, scopeType, scopeId, name, logger, }) {
+    if (!scopeId) {
+        const scopeLabel = scopeType === 'organization' ? 'organization' : 'project';
+        throw new Error(`Cannot create Stack: no ${scopeLabel} ID provided. ` +
+            'Provide --project-id or --organization-id, or select a scope.');
+    }
     const stackMutation = {
         name,
         scopeType,
@@ -57,7 +62,8 @@ export async function createEmptyStack({ token, scopeType, scopeId, name, logger
         logger,
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to create new Stack');
+        const scopeLabel = scopeType === 'organization' ? 'organization' : 'project';
+        throw new Error(response.error || `Failed to create Stack "${name}" for ${scopeLabel} "${scopeId}".`);
     }
     return response.stack;
 }
@@ -105,17 +111,20 @@ export async function resolveStackIdByNameOrId(value, auth, logger) {
         throw new Error(`No stack found with name "${value}"`);
     return match.id;
 }
-export async function promoteStack({ stackId, auth, logger, }) {
+export async function promoteStack({ stackId, auth, logger, name, }) {
     const fetchFn = createTracedFetch(logger);
+    const hasName = typeof name === 'string' && name.length > 0;
     const response = await fetchFn(`${stacksUrl}/${stackId}/promote`, {
         method: 'POST',
         headers: getHeaders(auth),
+        body: hasName ? JSON.stringify({ name }) : undefined,
     });
     const data = await response.json();
     return {
         ok: response.ok,
         error: response.ok ? null : data.message,
         stack: data,
+        response,
     };
 }
 export async function destroyStack({ stackId, auth, logger, }) {

package/dist/actions/functions/test.js

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

package/dist/actions/sanity/access.d.ts

@@ -0,0 +1,38 @@
+import type { Logger } from '../../utils/logger.js';
+import type { ActionResponse, AuthParams, ScopeType } from '../../utils/types.js';
+export declare const accessApiVersion = "v2025-07-11";
+export declare const accessApiPath: string;
+export interface RobotMembership {
+    resourceType: ScopeType;
+    resourceId: string;
+    roleNames: string[];
+}
+export interface CreateRobotInput {
+    label: string;
+    memberships: RobotMembership[];
+}
+export interface RobotResponse {
+    token: string;
+    id: string;
+    tokenId: string;
+    label: string;
+    createdAt: string;
+    expiresAt: string;
+    memberships: Array<RobotMembership & {
+        addedAt: string;
+        lastSeenAt?: string;
+        resourceUserId?: string;
+    }>;
+}
+interface CreateRobotResponse extends ActionResponse {
+    robot: RobotResponse | null;
+}
+/** Create a robot token via the Access API. */
+export declare function createRobotToken({ auth, resourceType, resourceId, body, logger, }: {
+    auth: AuthParams;
+    resourceType: ScopeType;
+    resourceId: string;
+    body: CreateRobotInput;
+    logger: Logger;
+}): Promise<CreateRobotResponse>;
+export {};

package/dist/actions/sanity/access.js

@@ -0,0 +1,23 @@
+import config from '../../config.js';
+import getHeaders from '../../utils/get-headers.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
+const { apiUrl } = config;
+export const accessApiVersion = 'v2025-07-11';
+export const accessApiPath = `${apiUrl}${accessApiVersion}/access`;
+/** Create a robot token via the Access API. */
+export async function createRobotToken({ auth, resourceType, resourceId, body, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const url = `${accessApiPath}/${resourceType}/${encodeURIComponent(resourceId)}/robots`;
+    const response = await fetchFn(url, {
+        method: 'POST',
+        headers: getHeaders(auth),
+        body: JSON.stringify(body),
+    });
+    const raw = await response.json().catch(() => null);
+    const data = (raw && typeof raw === 'object' ? raw : {});
+    if (!response.ok) {
+        const errMessage = data.message || data.error?.message || response.statusText;
+        return { ok: false, error: errMessage, robot: null };
+    }
+    return { ok: true, error: null, robot: raw };
+}

package/dist/actions/sanity/projects.d.ts

@@ -25,7 +25,7 @@ export declare function listProjects({ token, organizationId, logger, }: {
 interface GroupedProjectsByOrganizationResponse extends ActionResponse {
     organizations: GroupedProjects[];
 }
-interface GroupedProjects {
+export interface GroupedProjects {
     organization: {
         id: string;
         name: string;

package/dist/baseCommands.d.ts

@@ -24,10 +24,12 @@ export declare const stackFlagConfig: {
 export declare const projectIdFlagConfig: {
     description: string;
     aliases: string[];
+    exclusive: string[];
 };
 export declare const organizationIdFlagConfig: {
     description: string;
     aliases: string[];
+    exclusive: string[];
 };
 /**
  * Guarantees flags and args.

package/dist/baseCommands.js

@@ -40,6 +40,7 @@ export const baseFlags = {
         description: 'Validate resources',
         default: true,
         allowNo: true,
+        hidden: true,
     }),
     verbose: OclifFlags.boolean({
         description: 'Verbose output',
@@ -53,10 +54,12 @@ export const stackFlagConfig = {
 export const projectIdFlagConfig = {
     description: 'Sanity project ID used to scope Blueprint and Stack',
     aliases: ['project', 'projectId'],
+    exclusive: ['organization-id'],
 };
 export const organizationIdFlagConfig = {
     description: 'Sanity organization ID used to scope Blueprint and Stack',
     aliases: ['organization', 'organizationId', 'org'],
+    exclusive: ['project-id'],
 };
 /**
  * Guarantees flags and args.
@@ -216,7 +219,7 @@ export class ResolvedCommand extends RuntimeCommand {
         let blueprintModule;
         if (needsBlueprint) {
             if (!blueprintFileInfo) {
-                this.error('Could not find Blueprint file! Use the `blueprints init` command.', {
+                this.error('Could not find a Blueprint manifest (sanity.blueprint.ts, .js, or .json).', {
                     suggestions: [
                         `Run \`${this.config.bin} blueprints init\` to create one.`,
                         `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
@@ -229,9 +232,9 @@ export class ResolvedCommand extends RuntimeCommand {
             });
             if (parsed.errors.length > 0) {
                 log(presentBlueprintParserErrors(parsed.errors));
-                this.error('Blueprint file contains errors.', {
+                this.error('Blueprint manifest contains errors.', {
                     suggestions: [
-                        'Fix the Blueprint errors listed above.',
+                        'Fix the manifest errors listed above.',
                         `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
                     ],
                 });
@@ -285,7 +288,7 @@ export class ResolvedCommand extends RuntimeCommand {
         // 5. Scope
         if (needsScope) {
             if (!resolved.scopeType || !resolved.scopeId) {
-                this.error('Missing scope: provide --project-id or --organization-id, or configure a Blueprint.', {
+                this.error('Missing scope: provide --project-id or --organization-id, or run `blueprints init` to create a Blueprint config (.sanity/blueprint.config.json).', {
                     suggestions: [
                         `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
                     ],
@@ -307,7 +310,7 @@ export class ResolvedCommand extends RuntimeCommand {
                 stackId = await resolveStackIdByNameOrId(stackOverride, auth, log);
             }
             if (!stackId) {
-                this.error('Missing Stack: provide --stack, or configure a Blueprint with a Stack.', {
+                this.error(`Missing Stack: provide --stack, or set a Stack in your Blueprint config (\`${this.config.bin} blueprints config --edit\`).`, {
                     suggestions: [
                         `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
                     ],

package/dist/commands/blueprints/add.js

@@ -5,7 +5,7 @@
 import { Args, 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 { warn } from '../../utils/display/presenters.js';
 import { Logger } from '../../utils/logger.js';
 import { INSTALLER_OPTIONS } from '../../utils/types.js';

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

@@ -6,6 +6,8 @@ export default class DeployCommand extends ResolvedCommand<typeof DeployCommand>
     static examples: string[];
     static flags: {
         stack: 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>;
         message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'fn-installer': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/blueprints/deploy.js

@@ -1,5 +1,5 @@
 import { Flags } from '@oclif/core';
-import { ResolvedCommand, stackFlagConfig } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand, stackFlagConfig, } from '../../baseCommands.js';
 import { blueprintDeployCore } from '../../cores/blueprints/deploy.js';
 import { Logger } from '../../utils/logger.js';
 import { INSTALLER_OPTIONS } from '../../utils/types.js';
@@ -20,9 +20,14 @@ Set SANITY_ASSET_TIMEOUT (seconds) to override the 60-second timeout for process
         '<%= config.bin %> <%= command.id %> --message "Enable staging dataset"',
         '<%= config.bin %> <%= command.id %> --no-wait',
         '<%= config.bin %> <%= command.id %> --fn-installer npm',
+        '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --organization-id <orgId> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --new-stack-name <new-name>',
     ];
     static flags = {
         stack: Flags.string({ ...stackFlagConfig }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
+        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
         message: Flags.string({
             description: 'Message describing the deployment (e.g. reason for change)',
             char: 'm',
@@ -39,7 +44,6 @@ Set SANITY_ASSET_TIMEOUT (seconds) to override the 60-second timeout for process
         }),
         'new-stack-name': Flags.string({
             description: 'Set a new name for the Stack',
-            hidden: true,
         }),
     };
     async run() {

package/dist/commands/blueprints/destroy.js

@@ -23,12 +23,10 @@ Use this to clean up test environments or decommission a Stack you no longer nee
         'project-id': Flags.string({
             ...projectIdFlagConfig,
             dependsOn: ['stack', 'force'],
-            exclusive: ['organization-id'],
         }),
         'organization-id': Flags.string({
             ...organizationIdFlagConfig,
             dependsOn: ['stack', 'force'],
-            exclusive: ['project-id'],
         }),
         stack: Flags.string({
             description: 'Stack name or ID to destroy (defaults to the locally configured Stack)',

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

@@ -7,6 +7,7 @@ export default class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
     static flags: {
         stack: 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>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/info.js

@@ -1,5 +1,5 @@
 import { Flags } from '@oclif/core';
-import { projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintInfoCore } from '../../cores/blueprints/info.js';
 import { Logger } from '../../utils/logger.js';
 export default class InfoCommand extends ResolvedCommand {
@@ -14,6 +14,7 @@ Run 'blueprints stacks' to see all available Stacks in your project or organizat
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
         '<%= config.bin %> <%= command.id %> --project-id <id> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --organization-id <orgId> --stack <name-or-id>',
     ];
     static flags = {
         stack: Flags.string({
@@ -21,6 +22,7 @@ Run 'blueprints stacks' to see all available Stacks in your project or organizat
             aliases: ['id'],
         }),
         'project-id': Flags.string({ ...projectIdFlagConfig }),
+        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
     };
     async run() {
         const result = await blueprintInfoCore({

package/dist/commands/blueprints/init.js

@@ -44,11 +44,13 @@ After initialization, use 'blueprints plan' to preview changes, then 'blueprints
             description: 'Existing Stack ID used to scope local Blueprint',
             aliases: ['stackId'],
             exclusive: ['stack-name'],
+            relationships: [{ type: 'some', flags: ['project-id', 'organization-id'] }],
         }),
         'stack-name': Flags.string({
             description: 'Name to use for a new Stack provisioned during initialization',
             aliases: ['name'],
             exclusive: ['stack-id'],
+            relationships: [{ type: 'some', flags: ['project-id', 'organization-id'] }],
         }),
     };
     async run() {

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

@@ -6,7 +6,12 @@ export default class LogsCommand extends ResolvedCommand<typeof LogsCommand> {
     static examples: string[];
     static flags: {
         stack: 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>;
         watch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        since: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        before: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void | Record<string, unknown>>;
 }

package/dist/commands/blueprints/logs.js

@@ -1,5 +1,5 @@
 import { Flags } from '@oclif/core';
-import { ResolvedCommand, stackFlagConfig } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand, stackFlagConfig, } from '../../baseCommands.js';
 import { blueprintLogsCore } from '../../cores/blueprints/logs.js';
 import { Logger } from '../../utils/logger.js';
 export default class LogsCommand extends ResolvedCommand {
@@ -7,20 +7,43 @@ export default class LogsCommand extends ResolvedCommand {
     static summary = "Display logs for the current Blueprint's Stack deployment";
     static description = `Retrieves Stack deployment logs, useful for debugging and monitoring deployment activity.
 
-Use --watch (-w) to stream logs in real-time.
+Use --watch (-w) to tail logs in real-time.
+
+Use --limit, --since, or --before to narrow the result set when not watching.
 
 If you're not seeing expected logs, verify your Stack is deployed with 'blueprints info'.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --watch',
+        '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --limit 500',
+        '<%= config.bin %> <%= command.id %> --since 2026-05-01T00:00:00Z',
+        '<%= config.bin %> <%= command.id %> --before 2026-05-01T00:00:00Z',
     ];
     static flags = {
         stack: Flags.string({ ...stackFlagConfig }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
+        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
         watch: Flags.boolean({
             char: 'w',
-            description: 'Watch for new Stack logs (streaming mode)',
+            description: 'Watch for new Stack logs',
             aliases: ['follow'],
         }),
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of log entries to retrieve (1-500)',
+            min: 1,
+            max: 500,
+            exclusive: ['watch'],
+        }),
+        since: Flags.string({
+            description: 'Only show logs after this ISO 8601 timestamp',
+            exclusive: ['watch'],
+        }),
+        before: Flags.string({
+            description: 'Only show logs before this ISO 8601 timestamp',
+            exclusive: ['watch'],
+        }),
     };
     async run() {
         const result = await blueprintLogsCore({

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

@@ -0,0 +1,14 @@
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class MintDeployTokenCommand extends ResolvedCommand<typeof MintDeployTokenCommand> {
+    static needs: readonly ["scope"];
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        label: 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>;
+        print: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<Record<string, unknown> | undefined>;
+}

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

@@ -0,0 +1,47 @@
+import { Flags } from '@oclif/core';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
+import { blueprintMintDeployTokenCore } from '../../cores/blueprints/mint-deploy-token.js';
+import { Logger } from '../../utils/logger.js';
+export default class MintDeployTokenCommand extends ResolvedCommand {
+    static needs = ['scope'];
+    static summary = 'Create a robot API token for deploying Blueprints from CI/CD';
+    static description = `Mints a long-lived robot token with the role required to plan, deploy, and destroy Blueprints in this project or organization.
+
+By default the command runs interactively and asks how you want to receive the token (clipboard, print, or exit). Use --print to emit only the raw token for shell pipelines, or --json for full API output.
+
+The minted token is also visible in your Sanity Manage UI under Robots, where it can be revoked.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --label "ci-deploy"',
+        '<%= config.bin %> <%= command.id %> --print',
+        'export SANITY_AUTH_TOKEN=$(<%= config.bin %> <%= command.id %> --print)',
+        '<%= config.bin %> <%= command.id %> --json',
+        '<%= config.bin %> <%= command.id %> --project-id <projectId>',
+        '<%= config.bin %> <%= command.id %> --organization-id <orgId>',
+    ];
+    static flags = {
+        label: Flags.string({
+            description: 'Human-readable label for the robot. Defaults to a generated value.',
+        }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
+        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
+        print: Flags.boolean({
+            char: 'P',
+            description: 'Print only the raw token to stdout (suitable for shell substitution)',
+            exclusive: ['json'],
+        }),
+    };
+    async run() {
+        const result = await blueprintMintDeployTokenCore({
+            bin: this.config.bin,
+            log: Logger(this.log.bind(this), this.flags),
+            auth: this.auth,
+            scopeType: this.scopeType,
+            scopeId: this.scopeId,
+            flags: this.flags,
+        });
+        if (!result.success)
+            this.coreError(result);
+        return result.json;
+    }
+}

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

@@ -6,6 +6,8 @@ export default class PlanCommand extends ResolvedCommand<typeof PlanCommand> {
     static examples: string[];
     static flags: {
         stack: 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>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/plan.js

@@ -1,5 +1,5 @@
 import { Flags } from '@oclif/core';
-import { ResolvedCommand, stackFlagConfig } from '../../baseCommands.js';
+import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand, stackFlagConfig, } from '../../baseCommands.js';
 import { blueprintPlanCore } from '../../cores/blueprints/plan.js';
 import { Logger } from '../../utils/logger.js';
 export default class PlanCommand extends ResolvedCommand {
@@ -8,9 +8,15 @@ export default class PlanCommand extends ResolvedCommand {
     static description = `Use this command to preview what changes will be applied to your remote Stack before deploying. This is a safe, read-only operation—no resources are created, modified, or deleted.
 
 Run 'blueprints plan' after making local changes to your Blueprint manifest to verify the expected diff. When ready, run 'blueprints deploy' to apply changes.`;
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --organization-id <orgId> --stack <name-or-id>',
+    ];
     static flags = {
         stack: Flags.string({ ...stackFlagConfig }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
+        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
     };
     async run() {
         const result = await blueprintPlanCore({

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

@@ -3,11 +3,12 @@ export default class PromoteCommand extends ResolvedCommand<typeof PromoteComman
     static needs: readonly ["deployedStack", "blueprint"];
     static summary: string;
     static description: string;
-    static hidden: boolean;
     static examples: string[];
     static flags: {
         stack: 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>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'new-stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }