@sanity/runtime-cli 5.1.0 → 5.2.0

package/dist/cores/blueprints/config.js

@@ -0,0 +1,222 @@
+import chalk from 'chalk';
+import highlight from 'color-json';
+import inquirer from 'inquirer';
+import Spinner from 'yocto-spinner';
+import { writeConfigFile } from '../../actions/blueprints/blueprint.js';
+import { getProject, listProjects } from '../../actions/blueprints/projects.js';
+import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { niceId, warn } from '../../utils/display/colors.js';
+export async function blueprintConfigCore(options) {
+    const { bin = 'sanity', log, token, flags } = options;
+    const { edit: editConfig = false, 'test-config': testConfig = false, 'project-id': flagProjectId, 'stack-id': flagStackId, } = flags;
+    const { blueprint } = options;
+    const { stackId: configStackId, projectId: configProjectId } = blueprint;
+    try {
+        if (!configStackId && !configProjectId) {
+            log(warn('Missing local configuration.'));
+            if (!editConfig) {
+                // blueprint.json exists but no config.json
+                log(`Use \`${bin} blueprints config --edit\` to set a configuration.`);
+                return { success: true }; // not necessarily fatal
+            }
+        }
+        log(chalk.bold('Current configuration:'));
+        log(`  Sanity Project: ${niceId(configProjectId)}`);
+        log(`  Deployment ID:  ${niceId(configStackId)}`);
+        // passing new config without --edit flag is not allowed
+        if ((flagProjectId || flagStackId) && !editConfig) {
+            log('To update the configuration, use the --edit flag.');
+            return { success: true };
+        }
+        // no edit or test: return success
+        if (!editConfig && !testConfig)
+            return { success: true };
+        // testing without editing
+        if (testConfig && !editConfig) {
+            if (configStackId && configProjectId) {
+                const testResult = await testConfigAndReport({
+                    token,
+                    stackId: configStackId,
+                    projectId: configProjectId,
+                });
+                if (!testResult.ok) {
+                    // command should exit with error code 1
+                    return { success: false, error: 'Existing Blueprint deployment not found.' };
+                }
+                return { success: testResult.ok };
+            }
+            return {
+                success: false,
+                error: 'Unable to test the configuration. Both Project and Stack IDs must be set.',
+            };
+        }
+        // editing...
+        if (editConfig) {
+            const updatedProjectId = flagProjectId ||
+                (await promptForProjectId({
+                    token,
+                    knownProjectId: configProjectId,
+                }));
+            if (!updatedProjectId) {
+                return {
+                    success: false,
+                    error: 'Project ID is required.',
+                };
+            }
+            // LAUNCH LIMIT: 1 Stack per Project - configStackId is always inferred from projectId if not set in config.json
+            let updatedStackId = flagStackId ?? configStackId; // ?? (await promptForStackId({projectId: newProjectId, knownStackId: configStackId}))
+            const isProjectBasedId = updatedStackId === `ST-${updatedProjectId}`;
+            log(`\n${chalk.bold('New configuration:')}`);
+            log(`  Sanity Project: ${niceId(updatedProjectId)}`);
+            log(`  Deployment ID:  ${niceId(updatedStackId)}`);
+            if (testConfig) {
+                if (updatedProjectId && updatedStackId) {
+                    const { ok: newConfigOk, error: configError } = await testConfigAndReport({
+                        token,
+                        stackId: updatedStackId,
+                        projectId: updatedProjectId,
+                    });
+                    if (!newConfigOk) {
+                        // is this a projectBasedId stack?
+                        if (isProjectBasedId) {
+                            log(warn('Existing Blueprint deployment not found.'));
+                            const reinitResult = await startReinitializeStack({
+                                token,
+                                projectId: updatedProjectId,
+                                stackId: updatedStackId,
+                            });
+                            if (!reinitResult.ok) {
+                                return { success: false, error: reinitResult.error || 'Failed to reinitialize stack' };
+                            }
+                            log(`New Blueprint deployment created for "${reinitResult.projectDisplayName}"`);
+                            // continuing to save the config
+                        }
+                        else {
+                            return {
+                                success: false,
+                                error: configError || 'Updated configuration has not been saved.',
+                            };
+                        }
+                    }
+                }
+                else {
+                    return {
+                        success: false,
+                        error: 'Unable to test the configuration. Both Project and Stack IDs must be set.',
+                    };
+                }
+            }
+            // LAUNCH LIMIT: 1 Stack per Project - do not set Stack ID if it's project-based
+            if (isProjectBasedId)
+                updatedStackId = undefined;
+            try {
+                // update or create .blueprint/config.json
+                writeConfigFile({ projectId: updatedProjectId, stackId: updatedStackId });
+                log('Configuration updated successfully.');
+                return { success: true };
+            }
+            catch (error) {
+                log('Unable to update config. These values should be set in .blueprint/config.json');
+                log(highlight(JSON.stringify({ metadata: { projectId: updatedProjectId, stackId: updatedStackId } }, null, 2)));
+                return { success: false, error: 'Be sure to update your ./blueprint/config.json' };
+            }
+        }
+        // Default return (shouldn't reach here with proper flow control)
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: 'Unknown error' };
+    }
+}
+async function promptForProjectId({ token, knownProjectId, }) {
+    const { ok, projects, error } = await listProjects({ token });
+    if (!ok) {
+        throw new Error(error ?? 'Unknown error listing projects');
+    }
+    if (projects.length === 0) {
+        throw new Error('No Sanity projects found. Use `npx sanity init` to create one.');
+    }
+    const projectChoices = projects.map(({ displayName, id: projectId }) => ({
+        name: `"${displayName}" ${niceId(projectId)}`,
+        value: projectId,
+    }));
+    const { pickedProjectId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'pickedProjectId',
+            message: 'Select your Sanity project:',
+            choices: projectChoices,
+            default: knownProjectId,
+        },
+    ]);
+    return pickedProjectId;
+}
+async function promptForStackId({ token, projectId, knownStackId, }) {
+    const auth = { token, projectId };
+    // get stacks for selected project
+    const { ok: stacksOk, stacks, error: stacksError } = await listStacks(auth);
+    if (!stacksOk)
+        throw new Error(stacksError ?? 'Unknown error listing stacks');
+    if (stacks.length > 0) {
+        const stackChoices = stacks.map((s) => ({
+            name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
+            value: s.id,
+        }));
+        stackChoices.push({ name: 'Unset Stack association', value: 'unset' });
+        const { pickedStackId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'pickedStackId',
+                message: 'Select a stack:',
+                choices: stackChoices,
+                default: knownStackId,
+            },
+        ]);
+        return pickedStackId === 'unset' ? undefined : pickedStackId;
+    }
+    return undefined;
+}
+async function testConfigAndReport({ token, stackId, projectId, }) {
+    const spinner = Spinner({ text: 'Testing the configuration...' }).start();
+    const { ok, error } = await getStack({
+        stackId,
+        auth: { token, projectId },
+    });
+    if (!ok) {
+        spinner.error('Configuration test failed.');
+    }
+    else {
+        spinner.success('Configuration is valid.');
+    }
+    return { ok, error };
+}
+async function startReinitializeStack({ token, projectId, }) {
+    const auth = { token, projectId };
+    // stack id IS ST-${projectId} – it has already been checked and doesn't exist
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Do you want to create a ${chalk.blue('new')}, empty Blueprint deployment with the ${chalk.blue('existing')} configuration?`,
+        },
+    ]);
+    if (!confirm)
+        return { ok: false, error: 'Reinitialization cancelled.' };
+    const { ok: projectOk, project, error: projectError } = await getProject(auth);
+    if (!projectOk) {
+        return {
+            ok: false,
+            error: projectError || 'Failed to find Project while creating Stack',
+        };
+    }
+    const projectDisplayName = project.displayName;
+    const stackPayload = { name: projectDisplayName, projectId, document: { resources: [] } };
+    const response = await createStack({ stackPayload, auth });
+    if (!response.ok)
+        return { ok: false, error: response.error || 'Failed to create new Stack' };
+    return {
+        ok: true,
+        stackId: response.stack.id,
+        projectDisplayName,
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import type { AuthParams, Stack } from '../../utils/types.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintDeployOptions extends CoreConfig {
+    auth: AuthParams;
+    stackId: string;
+    projectId: string;
+    deployedStack: Stack;
+    blueprint: ReadBlueprintResult;
+    flags: {
+        'no-wait'?: boolean;
+    };
+}
+export declare function blueprintDeployCore(options: BlueprintDeployOptions): Promise<CoreResult>;

package/dist/cores/blueprints/deploy.js

@@ -0,0 +1,81 @@
+import { setTimeout } from 'node:timers/promises';
+import chalk from 'chalk';
+import Spinner from 'yocto-spinner';
+import { stashAsset } from '../../actions/blueprints/assets.js';
+import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
+import { bold, niceId } from '../../utils/display/colors.js';
+import { isLocalFunctionResource } from '../../utils/types.js';
+export async function blueprintDeployCore(options) {
+    const { bin = 'sanity', log, auth, stackId, projectId, deployedStack, blueprint, flags } = options;
+    const noWait = flags['no-wait'] || false;
+    try {
+        const { resources } = blueprint.parsedBlueprint;
+        const validResources = resources?.filter((r) => r.type);
+        const functionResources = validResources?.filter(isLocalFunctionResource);
+        // First stash all function assets
+        if (functionResources?.length) {
+            for (const resource of functionResources) {
+                const fnSpinner = Spinner({ text: `Processing ${resource.name}...` }).start();
+                const result = await stashAsset({ resource, auth });
+                if (result.success && result.assetId) {
+                    const src = resource.src;
+                    resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
+                    fnSpinner.success(`${resource.name} ${niceId(result.assetId)}`);
+                    log(`   Source: ${src}`);
+                }
+                else {
+                    fnSpinner.error(`Failed to process ${resource.name}`);
+                    log(`   Error: ${result.error}`);
+                    return { success: false, error: result.error || 'Failed to process function resource' };
+                }
+            }
+        }
+        const stackPayload = {
+            projectId,
+            name: deployedStack.name,
+            document: { resources: validResources },
+        };
+        const spinner = Spinner({ text: 'Deploying...' }).start();
+        const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackPayload, auth });
+        if (deployOk) {
+            spinner.success(`Deployment "${bold(stack.name)}" ${niceId(stack.id)} started!`);
+            if (!noWait) {
+                const waitSpinner = Spinner({ text: 'Waiting for deployment to complete...' }).start();
+                while (true) {
+                    // TODO: watch logs and print those while polling
+                    const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth });
+                    if (!ok) {
+                        waitSpinner.error('Failed to check deployment status');
+                        return { success: false, error: 'Failed to check deployment status' };
+                    }
+                    const operation = currentStack.recentOperation;
+                    if (!operation) {
+                        waitSpinner.error('No operation found');
+                        return { success: false, error: 'No operation found' };
+                    }
+                    if (operation.status === 'COMPLETED') {
+                        waitSpinner.success('Deployment completed successfully');
+                        break;
+                    }
+                    if (operation.status === 'FAILED') {
+                        waitSpinner.error('Deployment failed');
+                        return { success: false, error: 'Deployment failed' };
+                    }
+                    await setTimeout(1000);
+                }
+            }
+            else {
+                log(`Use \`${bin} blueprints info\` to check status`);
+            }
+            return { success: true };
+        }
+        spinner.error(`${chalk.red('Failed')} to update deployment`);
+        log(`Error: ${deployError || JSON.stringify(stack, null, 2) || 'Unknown error'}`);
+        return { success: false, error: deployError || 'Failed to update deployment' };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Error: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintDestroyOptions extends CoreConfig {
+    token: string;
+    blueprint: ReadBlueprintResult;
+    flags: {
+        force?: boolean;
+        'project-id'?: string;
+        'stack-id'?: string;
+        'no-wait'?: boolean;
+    };
+}
+export declare function blueprintDestroyCore(options: BlueprintDestroyOptions): Promise<CoreResult>;

package/dist/cores/blueprints/destroy.js

@@ -0,0 +1,106 @@
+import { setTimeout } from 'node:timers/promises';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import Spinner from 'yocto-spinner';
+import { destroyStack, getStack } from '../../actions/blueprints/stacks.js';
+import { niceId } from '../../utils/display/colors.js';
+export async function blueprintDestroyCore(options) {
+    const { bin = 'sanity', log, token, blueprint, flags } = options;
+    const { force = false, 'project-id': flagProjectId, 'stack-id': flagStackId, 'no-wait': noWait = false, } = flags;
+    // 3-flag combo: just destroy it
+    if (flagProjectId && flagStackId && force) {
+        const { ok, error, stack } = await destroyStack({
+            stackId: flagStackId,
+            auth: { token, projectId: flagProjectId },
+        });
+        if (!ok)
+            return { success: false, error: error || 'Failed to destroy deployment' };
+        log(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
+        return { success: true };
+    }
+    const { projectId, stackId } = blueprint;
+    if (!projectId)
+        return { success: false, error: 'Project ID is required' };
+    const auth = { token, projectId };
+    let stack;
+    try {
+        if (flagStackId) {
+            const flagStack = await getStack({ stackId: flagStackId, auth });
+            if (!flagStack.ok)
+                return { success: false, error: flagStack.error || 'Failed to get stack' };
+            stack = flagStack.stack;
+        }
+        else if (stackId) {
+            const blueprintStack = await getStack({ stackId, auth });
+            if (!blueprintStack.ok)
+                return { success: false, error: blueprintStack.error || 'Failed to get stack' };
+            stack = blueprintStack.stack;
+        }
+        if (!stack)
+            return { success: false, error: 'Deployment not found' };
+        const destroySpinner = Spinner({
+            text: `Destroying ${chalk.bold(stack.name)} ${niceId(stack.id)}...`,
+            color: 'red',
+        });
+        if (!force) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Are you sure you want to destroy stack "${stack.name}" ${niceId(stack.id)}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                log('Deployment destruction cancelled');
+                return { success: true };
+            }
+            destroySpinner.start();
+            // 5 second countdown
+            let i = 5;
+            while (i >= 0) {
+                destroySpinner.text = `Destroying deployment in ${chalk.bold((i--).toString())} seconds...`;
+                await setTimeout(1000);
+            }
+            destroySpinner.text = 'Destroying deployment 💥';
+            await setTimeout(500);
+        }
+        else {
+            destroySpinner.start();
+        }
+        const { ok, error } = await destroyStack({ stackId: stack.id, auth });
+        if (!ok) {
+            destroySpinner.error('Failed to destroy deployment');
+            return { success: false, error: error || 'Failed to destroy deployment' };
+        }
+        if (noWait) {
+            destroySpinner.success(`Deployment "${stack.name}" ${niceId(stack.id)} destroy started!`);
+            log(`Use \`${bin} blueprints info\` to check status`);
+            return { success: true };
+        }
+        destroySpinner.stop().clear();
+        const waitSpinner = Spinner({ text: 'Waiting for destruction to complete...' }).start();
+        while (true) {
+            const { ok: pollOk, stack: currentStack } = await getStack({ stackId: stack.id, auth });
+            const operation = currentStack?.recentOperation;
+            if (!pollOk || !operation || operation?.status === 'COMPLETED') {
+                // Operation is also marked destroyed when stack is deleted
+                // It's possible that the operation is "gone" or available and "COMPLETED"
+                waitSpinner.success(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
+                break;
+            }
+            if (operation.status === 'FAILED') {
+                waitSpinner.error('Destruction failed');
+                log(`Run \`${bin} blueprints logs\` for more details`);
+                return { success: false, error: 'Destruction failed' };
+            }
+            await setTimeout(1000);
+        }
+        return { success: true };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Error: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}

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

@@ -0,0 +1,18 @@
+export { blueprintAddCore } from './add.js';
+export type { BlueprintAddOptions } from './add.js';
+export { blueprintConfigCore } from './config.js';
+export type { BlueprintConfigOptions } from './config.js';
+export { blueprintDeployCore } from './deploy.js';
+export type { BlueprintDeployOptions } from './deploy.js';
+export { blueprintDestroyCore } from './destroy.js';
+export type { BlueprintDestroyOptions } from './destroy.js';
+export { blueprintInfoCore } from './info.js';
+export type { BlueprintInfoOptions } from './info.js';
+export { blueprintInitCore } from './init.js';
+export type { BlueprintInitOptions } from './init.js';
+export { blueprintLogsCore } from './logs.js';
+export type { BlueprintLogsOptions } from './logs.js';
+export { blueprintPlanCore } from './plan.js';
+export type { BlueprintPlanOptions } from './plan.js';
+export { blueprintStacksCore } from './stacks.js';
+export type { BlueprintStacksOptions } from './stacks.js';

package/dist/cores/blueprints/index.js

@@ -0,0 +1,9 @@
+export { blueprintAddCore } from './add.js';
+export { blueprintConfigCore } from './config.js';
+export { blueprintDeployCore } from './deploy.js';
+export { blueprintDestroyCore } from './destroy.js';
+export { blueprintInfoCore } from './info.js';
+export { blueprintInitCore } from './init.js';
+export { blueprintLogsCore } from './logs.js';
+export { blueprintPlanCore } from './plan.js';
+export { blueprintStacksCore } from './stacks.js';

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

@@ -0,0 +1,11 @@
+import type { AuthParams, Stack } from '../../utils/types.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintInfoOptions extends CoreConfig {
+    auth: AuthParams;
+    stackId: string;
+    deployedStack: Stack;
+    flags: {
+        id?: string;
+    };
+}
+export declare function blueprintInfoCore(options: BlueprintInfoOptions): Promise<CoreResult>;

package/dist/cores/blueprints/info.js

@@ -0,0 +1,33 @@
+import { getStack } from '../../actions/blueprints/stacks.js';
+import { formatResourceTree, formatStackInfo } from '../../utils/display/blueprints-formatting.js';
+import { niceId } from '../../utils/display/colors.js';
+export async function blueprintInfoCore(options) {
+    const { log, auth, stackId, flags, deployedStack } = options;
+    try {
+        const targetStackId = flags.id || stackId;
+        let stack = deployedStack;
+        if (flags.id) {
+            const existingStackResponse = await getStack({ stackId: targetStackId, auth });
+            if (!existingStackResponse.ok) {
+                log(`Could not retrieve deployment info for ${niceId(targetStackId)}`);
+                return {
+                    success: false,
+                    error: existingStackResponse.error || 'Failed to retrieve stack',
+                };
+            }
+            stack = existingStackResponse.stack;
+        }
+        log(formatStackInfo(stack, true));
+        if (stack.resources)
+            log(formatResourceTree(stack.resources));
+        return { success: true };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Error: ${errorMessage}`);
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintInitOptions extends CoreConfig {
+    token: string;
+    args: {
+        dir?: string;
+    };
+    flags: {
+        dir?: string;
+        'blueprint-type'?: string;
+        'project-id'?: string;
+        'stack-id'?: string;
+        'stack-name'?: string;
+    };
+}
+export declare function blueprintInitCore(options: BlueprintInitOptions): Promise<CoreResult>;