@sanity/runtime-cli 11.2.5 → 12.0.1

package/dist/cores/blueprints/doctor.js

@@ -1,23 +1,20 @@
 import { cwd } from 'node:process';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
-import ora from 'ora';
 import { findBlueprintFile, readLocalBlueprint, } from '../../actions/blueprints/blueprint.js';
-import { createStack, getStack } from '../../actions/blueprints/stacks.js';
-import { getProject } from '../../actions/sanity/projects.js';
+import { getStack } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
-import { capitalize, check, indent, niceId, severe, warn } from '../../utils/display/presenters.js';
+import { capitalize, check, filePathRelativeToCwd, indent, niceId, severe, unsure, } from '../../utils/display/presenters.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 const diagLookup = {
     online: 'Online',
     tokenPresent: 'Auth token present',
     tokenValid: 'Auth token valid',
-    configFilePresent: 'Blueprints config file present',
-    configFileValid: 'Blueprints config file valid',
+    configFilePresent: 'Blueprint config file present',
+    configFileValid: 'Blueprint config file valid',
     blueprintPresent: 'Blueprint file present',
     blueprintValid: 'Blueprint file valid',
-    stackReady: 'Deployment "Stack" ready',
-    userHasAccess: 'User has access to "Stack"',
+    stackReady: 'Stack deployment ready',
+    userHasAccess: 'User has access to deployed "Stack"',
 };
 export async function blueprintDoctorCore(options) {
     const { log, token, flags: { verbose: v, path: p }, } = options;
@@ -27,15 +24,12 @@ export async function blueprintDoctorCore(options) {
     const here = cwd();
     const path = p || here;
     if (v)
-        log(`Checking ${path}`);
+        log(`Checking ${filePathRelativeToCwd(path)}`);
     // 3 states: null == unknown, true == good, false == bad
     const diagnostics = {};
     for (const key in diagLookup) {
         diagnostics[key] = null;
     }
-    let spinner;
-    if (!v)
-        spinner = ora('Checking environment').start();
     // ONLINE
     try {
         const res = await fetch(config.apiUrl);
@@ -45,14 +39,12 @@ export async function blueprintDoctorCore(options) {
             diagnostics.online = res.ok;
         }
         else {
-            if (v)
-                yikes(`Failed to ping ${config.apiUrl}: ${res.status} ${res.statusText}`);
+            yikes(`Failed to ping ${config.apiUrl}: ${res.status} ${res.statusText}`);
             diagnostics.online = false;
         }
     }
     catch {
-        if (v)
-            yikes(`Failed to ping ${config.apiUrl}`);
+        yikes(`Failed to ping ${config.apiUrl}`);
     }
     // TOKEN
     if (token) {
@@ -62,8 +54,7 @@ export async function blueprintDoctorCore(options) {
             diagnostics.tokenValid = true;
         }
         else {
-            if (v)
-                yikes(`Token error: ${tokenOrError.error}`);
+            yikes(`Token error: ${tokenOrError.error}`);
             diagnostics.tokenValid = false;
         }
     }
@@ -136,35 +127,34 @@ export async function blueprintDoctorCore(options) {
                 diagnostics.userHasAccess = true;
             }
             else if (stackResponse.response?.status === 404) {
-                if (v)
-                    yikes(`Deployment "Stack" <${stackId}> not found`);
+                yikes(`Deployment "Stack" <${stackId}> not found`);
                 diagnostics.stackReady = false;
             }
             else if (stackResponse.response?.status === 403 || stackResponse.response?.status === 401) {
-                if (v)
-                    yikes(`User does not have access to "Stack" <${stackId}>`);
+                yikes(`User does not have access to "Stack" <${stackId}>`);
                 diagnostics.userHasAccess = false;
             }
             else {
-                if (v)
-                    yikes(`Unknown error with "Stack" <${stackId}>: ${stackResponse.error}`);
+                yikes(`Unknown error with "Stack" <${stackId}>: ${stackResponse.error}`);
             }
         }
         else {
-            if (v)
-                yikes('Unable to check deployment "Stack" status.');
+            if (!diagnostics.online)
+                yikes('Unable to connect to Sanity API.');
+            if (!diagnostics.tokenValid)
+                yikes('Invalid authentication token.');
+            if (!stackId)
+                yikes(`Blueprints configuration is missing a Stack ID`);
+            if (!projectId)
+                yikes(`Blueprints configuration is missing a Project ID`);
         }
     }
-    if (spinner)
-        spinner.stop();
-    if (v)
-        log('');
+    log('');
     let allGood = true;
     for (const [key, value] of Object.entries(diagnostics)) {
         switch (value) {
             case true:
-                if (v)
-                    log(check(diagLookup[key]));
+                log(check(diagLookup[key]));
                 break;
             case false:
                 allGood = false;
@@ -172,7 +162,7 @@ export async function blueprintDoctorCore(options) {
                 break;
             case null:
                 allGood = false;
-                log(warn(diagLookup[key]));
+                log(unsure(diagLookup[key]));
                 break;
             default:
                 allGood = false;
@@ -187,41 +177,3 @@ export async function blueprintDoctorCore(options) {
         return { success: false, error: 'One or more checks failed', data: { diagnostics } };
     }
 }
-// copied from old config --edit --test flow
-async function _startReinitializeStack({ token, projectId, }) {
-    const auth = { token, scopeType: 'project', scopeId: projectId };
-    // stack id IS ST-${projectId} – it has already been checked and doesn't exist
-    const { confirm } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'confirm',
-            message: `Do you want to create a ${chalk.blue('new')}, empty Blueprint deployment with the ${chalk.blue('existing')} configuration?`,
-        },
-    ]);
-    if (!confirm)
-        return { ok: false, error: 'Reinitialization cancelled' };
-    const { ok: projectOk, project, error: projectError } = await getProject(auth);
-    if (!projectOk) {
-        return {
-            ok: false,
-            error: projectError || 'Failed to find Project while creating Stack',
-        };
-    }
-    const projectDisplayName = project.displayName;
-    const response = await createStack({
-        stackMutation: {
-            name: projectDisplayName,
-            scopeType: 'project',
-            scopeId: projectId,
-            document: { resources: [] },
-        },
-        auth,
-    });
-    if (!response.ok)
-        return { ok: false, error: response.error || 'Failed to create new Stack' };
-    return {
-        ok: true,
-        stackId: response.stack.id,
-        projectDisplayName,
-    };
-}

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

@@ -6,6 +6,7 @@ export interface BlueprintInfoOptions extends CoreConfig {
     deployedStack: Stack;
     flags: {
         id?: string;
+        verbose?: boolean;
     };
 }
 export declare function blueprintInfoCore(options: BlueprintInfoOptions): Promise<CoreResult>;

package/dist/cores/blueprints/info.js

@@ -3,16 +3,17 @@ import { formatResourceTree, formatStackInfo } from '../../utils/display/bluepri
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintInfoCore(options) {
     const { log, auth, stackId, flags, deployedStack } = options;
+    const { id: flagStackId, verbose: _verbose = false } = flags;
     try {
-        const targetStackId = flags.id || stackId;
+        const targetStackId = flagStackId || stackId;
         let stack = deployedStack;
-        if (flags.id) {
+        if (flagStackId) {
             const existingStackResponse = await getStack({ stackId: targetStackId, auth });
             if (!existingStackResponse.ok) {
-                log(`Could not retrieve deployment info for ${niceId(targetStackId)}`);
+                log(`Could not retrieve Stack deployment info for ${niceId(targetStackId)}`);
                 return {
                     success: false,
-                    error: existingStackResponse.error || 'Failed to retrieve stack',
+                    error: existingStackResponse.error || 'Failed to retrieve Stack deployment',
                 };
             }
             stack = existingStackResponse.stack;

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

@@ -13,6 +13,7 @@ export interface BlueprintInitOptions extends CoreConfig {
         'organization-id'?: string;
         'stack-id'?: string;
         'stack-name'?: string;
+        verbose?: boolean;
     };
 }
 export declare function blueprintInitCore(options: BlueprintInitOptions): Promise<CoreResult>;
@@ -33,7 +34,6 @@ export declare function resolveScopeAndStack(params: {
     stackId: string | undefined;
     stackName: string | undefined;
     token: string;
-    log: (message: string) => void;
 }): Promise<ResolvedScope>;
 export declare function determineBlueprintExtension(params: {
     requestedType: string | undefined;

package/dist/cores/blueprints/init.js

@@ -1,38 +1,58 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { confirm } from '@inquirer/prompts';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { findBlueprintFile, writeBlueprintToDisk } from '../../actions/blueprints/blueprint.js';
+import { findBlueprintFile, readLocalBlueprint, writeBlueprintToDisk, } from '../../actions/blueprints/blueprint.js';
 import { writeConfigFile } from '../../actions/blueprints/config.js';
-import { createEmptyStack, getStack } from '../../actions/blueprints/stacks.js';
+import { createEmptyStack } 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_FILE, BLUEPRINT_DIR } from '../../config.js';
-import { check, warn } from '../../utils/display/presenters.js';
-import { promptForProject } from '../../utils/display/prompt.js';
+import { BLUEPRINT_CONFIG_DIR, BLUEPRINT_CONFIG_FILE } from '../../config.js';
+import { check, filePathRelativeToCwd, warn } from '../../utils/display/presenters.js';
+import { promptForBlueprintType, promptForProject, promptForStack, } from '../../utils/display/prompt.js';
+import { blueprintConfigCore } from './config.js';
 const SCOPE_PROJECT = 'project';
 const SCOPE_ORGANIZATION = 'organization';
 export async function blueprintInitCore(options) {
     const { bin = 'sanity', log, token, args, flags } = options;
+    const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'stack-name': flagStackName, verbose: v = false, } = flags;
+    const { dir: argDir } = args;
+    const userProvidedDirName = argDir || flagDir;
+    const blueprintDir = userProvidedDirName || '.';
+    const validationError = validateFlags({
+        stackId: flagStackId,
+        stackName: flagStackName,
+        organizationId: flagOrganizationId,
+        projectId: flagProjectId,
+    });
+    if (validationError)
+        return validationError;
     try {
-        const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
-        const { dir: argDir } = args;
-        const userProvidedDirName = argDir || flagDir;
-        const blueprintDir = userProvidedDirName || '.';
-        const existingBlueprint = findBlueprintFile(blueprintDir);
-        if (existingBlueprint) {
-            return { success: false, error: 'Existing Blueprint found.' };
+        const existingBlueprintFile = findBlueprintFile(blueprintDir);
+        if (existingBlueprintFile) {
+            log(warn(`Existing Blueprint found: ${filePathRelativeToCwd(existingBlueprintFile.blueprintFilePath)}`));
+            const overwrite = await confirm({
+                message: 'Would you like to re-configure deployment for this Blueprint?',
+                default: true,
+            });
+            if (!overwrite)
+                return { success: false, error: 'Initialization cancelled.' };
+            const existingBlueprint = await readLocalBlueprint(existingBlueprintFile.blueprintFilePath);
+            return blueprintConfigCore({
+                blueprint: existingBlueprint,
+                bin,
+                log,
+                token,
+                flags: {
+                    edit: true,
+                    'project-id': flagProjectId,
+                    'organization-id': flagOrganizationId,
+                    'stack-id': flagStackId,
+                    verbose: v,
+                },
+            });
         }
-        const validationError = validateFlags({
-            stackId: flagStackId,
-            stackName: flagStackName,
-            organizationId: flagOrganizationId,
-            projectId: flagProjectId,
-        });
-        if (validationError)
-            return validationError;
         if (flagExample) {
             return handleExampleInitialization({
                 exampleName: flagExample,
@@ -49,7 +69,6 @@ export async function blueprintInitCore(options) {
             stackId: flagStackId,
             stackName: flagStackName,
             token,
-            log,
         });
         const blueprintExtension = await determineBlueprintExtension({
             requestedType: flagBlueprintType,
@@ -95,7 +114,6 @@ async function handleExampleInitialization(options) {
         scopeType: SCOPE_PROJECT,
         scopeId: resolvedProjectId,
         name: `example-${exampleName}`,
-        projectBased: false,
     });
     const exampleDir = userProvidedDirName || join(blueprintDir, exampleName);
     if (existsSync(exampleDir)) {
@@ -119,7 +137,7 @@ async function handleExampleInitialization(options) {
     }
     const { blueprintFilePath } = discoveredBlueprint;
     writeConfigFile({ blueprintFilePath, projectId: resolvedProjectId, stackId: stack.id });
-    log(check(`${chalk.bold('Configured:')} ${exampleDir}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
+    log(check(`${chalk.bold('Configured:')} ${exampleDir}/${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`));
     log(`\n  Run "${chalk.bold.magenta(`cd ${exampleDir} && npm i`)}" and check out the README`);
     if (instructions) {
         log('');
@@ -128,7 +146,7 @@ async function handleExampleInitialization(options) {
     return { success: true };
 }
 export async function resolveScopeAndStack(params) {
-    const { projectId, organizationId, stackId, stackName, token, log } = params;
+    const { projectId, organizationId, stackId, stackName, token } = params;
     let scopeType = SCOPE_PROJECT;
     let scopeId;
     if (projectId) {
@@ -147,7 +165,6 @@ export async function resolveScopeAndStack(params) {
             scopeType,
             scopeId,
             name: stackName,
-            projectBased: false,
         });
         resolvedStackId = stack.id;
     }
@@ -157,7 +174,8 @@ export async function resolveScopeAndStack(params) {
         scopeId = pickedProject.projectId;
     }
     if (!resolvedStackId) {
-        await getOrCreateProjectBasedStack({ token, projectId: scopeId, log });
+        const { stackId } = await promptForStack({ projectId: scopeId, token });
+        resolvedStackId = stackId;
     }
     return {
         scopeType,
@@ -167,7 +185,9 @@ export async function resolveScopeAndStack(params) {
 }
 export async function determineBlueprintExtension(params) {
     const { requestedType, blueprintDir } = params;
-    const extension = requestedType || (await promptForBlueprintType());
+    let extension = requestedType;
+    if (!extension)
+        extension = await promptForBlueprintType();
     if (extension === 'js') {
         const packageJsonPath = join(blueprintDir, 'package.json');
         const packageExists = existsSync(packageJsonPath);
@@ -202,7 +222,7 @@ export async function createBlueprintFiles(params) {
         stackId,
         ...(scopeType === SCOPE_ORGANIZATION ? { organizationId: scopeId } : { projectId: scopeId }),
     });
-    log(check(`${chalk.bold('Added configuration:')} ${displayPath}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
+    log(check(`${chalk.bold('Added configuration:')} ${displayPath}/${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`));
     writeGitignoreFile(blueprintFilePath);
     log(check(`${chalk.bold('Added .gitignore:')}    ${displayPath}/.gitignore`));
     if (blueprintExtension !== 'json') {
@@ -224,51 +244,3 @@ export async function createBlueprintFiles(params) {
     log(`\n  Run "${chalk.bold.magenta(nextStepParts.join(' && '))}" to get started`);
     return { success: true };
 }
-async function promptForBlueprintType() {
-    const { pickedBlueprintsType } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'pickedBlueprintsType',
-            message: 'Choose a Blueprint file type:',
-            choices: [
-                { name: 'TypeScript', value: 'ts' },
-                { name: 'JavaScript', value: 'js' },
-                { name: 'JSON', value: 'json' },
-            ],
-            default: 'ts',
-        },
-    ]);
-    return pickedBlueprintsType;
-}
-// LAUNCH LIMIT: 1 Stack per Project - create exclusive stack for project
-async function getOrCreateProjectBasedStack(params) {
-    const { projectId, token, log } = params;
-    const { ok: projectOk, project } = await getProject({
-        token,
-        scopeType: SCOPE_PROJECT,
-        scopeId: projectId,
-    });
-    if (!projectOk) {
-        throw new Error('Failed to find Project while creating Stack');
-    }
-    // check if project has a stack
-    const { stack: existingStack, ok: stackOk } = await getStack({
-        auth: { token, scopeType: SCOPE_PROJECT, scopeId: projectId },
-        stackId: `ST-${projectId}`,
-    });
-    // if existing stack, return stack
-    if (stackOk && existingStack) {
-        log(warn(`"${project.displayName}" has an existing deployment.`));
-        log(warn(`Deploying an empty Blueprint ${chalk.bold.red('will override the existing deployment!')}`));
-        log('');
-        return existingStack;
-    }
-    // if not, create a stack
-    const stack = await createEmptyStack({
-        token,
-        scopeType: SCOPE_PROJECT,
-        scopeId: projectId,
-        name: project.displayName,
-    });
-    return stack;
-}

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

@@ -6,6 +6,7 @@ export interface BlueprintLogsOptions extends CoreConfig {
     deployedStack: Stack;
     flags: {
         watch?: boolean;
+        verbose?: boolean;
     };
 }
 export declare function blueprintLogsCore(options: BlueprintLogsOptions): Promise<CoreResult>;

package/dist/cores/blueprints/logs.js

@@ -7,8 +7,8 @@ import { formatLogEntry, formatLogsByDay, organizeLogsByDay, } from '../../utils
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintLogsCore(options) {
     const { log, auth, stackId, deployedStack, flags } = options;
-    const { watch = false } = flags;
-    const spinner = ora(`Fetching recent logs for deployment ${niceId(stackId)}`).start();
+    const { watch = false, verbose: _verbose = false } = flags;
+    const spinner = ora(`Fetching recent logs for Stack deployment ${niceId(stackId)}`).start();
     try {
         if (watch) {
             const { ok, logs, error } = await getLogs(stackId, auth);
@@ -27,7 +27,7 @@ export async function blueprintLogsCore(options) {
                 }
             }
             else {
-                log(`No recent logs found for deployment ${niceId(stackId)}`);
+                log(`No recent logs found for Stack deployment ${niceId(stackId)}`);
             }
             // Set up streaming log display
             await setupLogStreaming({
@@ -45,23 +45,23 @@ export async function blueprintLogsCore(options) {
         // Regular non-streaming logs
         const { ok, logs, error } = await getLogs(stackId, auth);
         if (!ok) {
-            spinner.fail(`${chalk.red('Failed')} to retrieve logs`);
+            spinner.fail(`${chalk.red('Failed')} to retrieve Stack deployment logs`);
             log(`Error: ${error || 'Unknown error'}`);
             return { success: false, error: error || 'Failed to retrieve logs' };
         }
         if (logs.length === 0) {
-            spinner.info(`No logs found for deployment ${stackId}`);
+            spinner.info(`No logs found for Stack deployment ${stackId}`);
             return { success: true };
         }
         spinner.succeed(`${formatTitle('Blueprint', deployedStack.name)} Logs`);
-        log(`Found ${chalk.bold(logs.length.toString())} log entries for deployment ${niceId(stackId)}\n`);
+        log(`Found ${chalk.bold(logs.length.toString())} log entries for Stack deployment ${niceId(stackId)}\n`);
         // Organize and format logs by day
         const logsByDay = organizeLogsByDay(logs);
         log(formatLogsByDay(logsByDay));
         return { success: true };
     }
     catch (err) {
-        spinner.fail('Failed to retrieve logs');
+        spinner.fail('Failed to retrieve Stack deployment logs');
         const errorMessage = err instanceof Error ? err.message : String(err);
         log(`Error: ${errorMessage}`);
         return { success: false, error: errorMessage };

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

@@ -3,5 +3,8 @@ import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintPlanOptions extends CoreConfig {
     blueprint: ReadBlueprintResult;
     token?: string;
+    flags: {
+        verbose?: boolean;
+    };
 }
 export declare function blueprintPlanCore(options: BlueprintPlanOptions): Promise<CoreResult>;

package/dist/cores/blueprints/plan.js

@@ -2,9 +2,10 @@ import chalk from 'chalk';
 import { getStack } from '../../actions/blueprints/stacks.js';
 import { formatResourceTree, stackDeployDiff } from '../../utils/display/blueprints-formatting.js';
 export async function blueprintPlanCore(options) {
-    const { bin = 'sanity', log, blueprint, token } = options;
+    const { bin = 'sanity', log, blueprint, token, flags } = options;
+    const { verbose: _verbose = false } = flags;
     const { scopeType, scopeId, stackId, parsedBlueprint, fileInfo } = blueprint;
-    log(`${chalk.bold.blueBright('Blueprint Deployment Plan')} ${chalk.dim(`(${fileInfo.fileName})`)}`);
+    log(`${chalk.bold.blueBright('Blueprint Stack deployment plan')} ${chalk.dim(`(${fileInfo.fileName})`)}`);
     log(formatResourceTree(parsedBlueprint.resources));
     if (token && scopeType && scopeId && stackId) {
         const stackResponse = await getStack({
@@ -12,7 +13,7 @@ export async function blueprintPlanCore(options) {
             stackId,
         });
         if (!stackResponse.ok) {
-            log(chalk.dim('Unable to retrieve live deployment for comparison'));
+            log(chalk.dim('Unable to retrieve live Stack deployment for comparison'));
         }
         else {
             const diff = stackDeployDiff(parsedBlueprint, stackResponse.stack);
@@ -20,6 +21,6 @@ export async function blueprintPlanCore(options) {
                 log(diff);
         }
     }
-    log(`\n  Run "${chalk.bold.magenta(`${bin} blueprints deploy`)}" to deploy these changes`);
+    log(`\n  Run "${chalk.bold.magenta(`${bin} blueprints deploy`)}" to deploy these Stack changes`);
     return { success: true };
 }

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

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

package/dist/cores/blueprints/stacks.js

@@ -5,8 +5,7 @@ import { capitalize, niceId } from '../../utils/display/presenters.js';
 export async function blueprintStacksCore(options) {
     const { log, token, blueprint, flags } = options;
     const { scopeType: blueprintScopeType, scopeId: blueprintScopeId, stackId: blueprintStackId, } = blueprint;
-    const flagProjectId = flags['project-id'];
-    const flagOrganizationId = flags['organization-id'];
+    const { 'project-id': flagProjectId, 'organization-id': flagOrganizationId, verbose: _verbose = false, } = flags;
     if (flagOrganizationId && flagProjectId) {
         log('Cannot specify both --organization-id and --project-id');
         return { success: false, error: 'Cannot specify both --organization-id and --project-id' };