@sanity/runtime-cli 13.4.1 → 14.0.1

package/dist/cores/blueprints/doctor.js

@@ -1,202 +1,295 @@
-import { cwd } from 'node:process';
+import { readFileSync } from 'node:fs';
+import { arch, cwd, version as nodeVersion, platform } from 'node:process';
+import * as resolve from 'empathic/resolve';
+import ora from 'ora';
 import { readLocalBlueprint, } from '../../actions/blueprints/blueprint.js';
 import { getStack } from '../../actions/blueprints/stacks.js';
-import config from '../../config.js';
-import { capitalize, check, filePathRelativeToCwd, indent, niceId, severe, unsure, } from '../../utils/display/presenters.js';
+import config, { RUNTIME_CLI_VERSION } from '../../config.js';
+import { check, filePathRelativeToCwd, niceId, severe, unsure, } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
 import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 import { blueprintConfigCore } from './config.js';
 const diagLookup = {
-    online: 'Online',
+    online: 'Host online',
     tokenValid: 'Authenticated',
     blueprintValid: 'Blueprint valid',
     stackReady: 'Stack ready',
     userHasAccess: 'User has access',
 };
+function sourceLabel(source) {
+    switch (source) {
+        case 'env':
+            return 'environment';
+        case 'module':
+            return 'blueprint module';
+        case 'config':
+            return 'config file';
+        case 'inferred':
+            return 'inferred';
+        default:
+            return 'unknown';
+    }
+}
+function renderSection(emit, title, rows) {
+    const pad = Math.max(...rows.map(([l]) => l.length)) + 3;
+    emit(styleText('bold', title));
+    for (const [label, value] of rows) {
+        emit(`  ${styleText('dim', label.padEnd(pad))}${value}`);
+    }
+}
 export async function blueprintDoctorCore(options) {
     const { bin, log, token, validateResources, flags: { verbose: v, path: p, fix }, } = options;
-    const yikes = (s) => {
-        log.error(styleText(['bgRedBright', 'whiteBright', 'bold'], ` ${s} `));
-    };
-    const here = cwd();
-    const path = p || here;
+    const path = p || cwd();
     let tokenOrError;
-    log.verbose(`Checking ${filePathRelativeToCwd(path)}`);
-    // 3 states: null == unknown, true == good, false == bad
     const diagnostics = {};
     for (const key in diagLookup) {
-        diagnostics[key] = null;
+        diagnostics[key] = { status: null };
     }
-    // ONLINE
+    const envRows = [['Directory', p ? filePathRelativeToCwd(path) : path]];
+    const configRows = [];
+    const stackRows = [];
+    const spinner = ora('Running diagnostics...').start();
+    // --- ONLINE ---
     const fetchFn = createTracedFetch(log);
     try {
         const res = await fetchFn(config.apiUrl);
         if (res.ok) {
-            log.verbose(`Successfully pinged ${config.apiUrl}`);
-            diagnostics.online = res.ok;
+            diagnostics.online = { status: true };
         }
         else {
-            yikes(`Failed to ping ${config.apiUrl}: ${res.status} ${res.statusText}`);
-            diagnostics.online = false;
+            diagnostics.online = { status: false, detail: `${res.status} ${res.statusText}` };
         }
     }
-    catch {
-        yikes(`Failed to ping ${config.apiUrl}`);
+    catch (err) {
+        const reason = err instanceof Error ? err.message : 'unknown error';
+        diagnostics.online = { status: false, detail: reason };
     }
-    // TOKEN
+    // --- TOKEN ---
     if (token) {
         tokenOrError = await validTokenOrErrorMessage(log, token);
         if (tokenOrError.ok) {
-            diagnostics.tokenValid = true;
+            diagnostics.tokenValid = { status: true };
         }
         else {
-            yikes(`Token error: ${tokenOrError.error.message}`);
-            diagnostics.tokenValid = false;
+            diagnostics.tokenValid = { status: false, detail: tokenOrError.error.message };
         }
     }
     else {
-        yikes('No authentication token found');
-        diagnostics.tokenValid = false;
+        diagnostics.tokenValid = { status: false, detail: 'no token found' };
     }
-    // BLUEPRINT file
+    // --- BLUEPRINT ---
     let localBlueprint;
     try {
         localBlueprint = await readLocalBlueprint(log, { resources: options.validateResources || false }, path);
-        log.verbose(`Found blueprint file at ${filePathRelativeToCwd(localBlueprint.fileInfo.blueprintFilePath)}`);
+        envRows.push(['Blueprint', filePathRelativeToCwd(localBlueprint.fileInfo.blueprintFilePath)]);
         if (localBlueprint.errors.length === 0) {
-            log.verbose(`Blueprint has no errors`);
-            diagnostics.blueprintValid = true;
+            diagnostics.blueprintValid = { status: true };
         }
         else {
-            log.verbose(`Blueprint errors: \n${localBlueprint.errors.join('\n  ')}`);
-            diagnostics.blueprintValid = false;
+            diagnostics.blueprintValid = {
+                status: false,
+                detail: `${localBlueprint.errors.length} error(s)`,
+            };
         }
     }
     catch {
-        yikes(`Unable to read blueprint`);
-        diagnostics.blueprintValid = false;
+        diagnostics.blueprintValid = { status: false, detail: 'unable to read file' };
     }
+    envRows.push(['API URL', config.apiUrl]);
+    envRows.push(['Runtime', `Node.js ${nodeVersion} (${platform}-${arch})`]);
+    if (RUNTIME_CLI_VERSION) {
+        envRows.push(['Internals', `v${RUNTIME_CLI_VERSION}`]);
+    }
+    const sanityCliPkgPath = resolve.from(path, '@sanity/cli/package.json', true);
+    if (sanityCliPkgPath) {
+        try {
+            const sanityCliPkg = JSON.parse(readFileSync(sanityCliPkgPath, 'utf8'));
+            envRows.push(['Sanity CLI', sanityCliPkg.version]);
+        }
+        catch { }
+    }
+    // --- CONFIGURATION ---
     if (localBlueprint) {
-        const { scopeType, scopeId, stackId, sources } = localBlueprint;
-        const sourceLabel = (source) => {
-            switch (source) {
-                case 'env':
-                    return 'environment';
-                case 'module':
-                    return 'blueprint module';
-                case 'config':
-                    return 'config file';
-                case 'inferred':
-                    return 'inferred';
-                default:
-                    return 'unknown';
-            }
-        };
+        const { scopeType, scopeId, stackId, sources, blueprintConfig } = localBlueprint;
+        if (blueprintConfig && 'configPath' in blueprintConfig && blueprintConfig.configPath) {
+            configRows.push(['Source', filePathRelativeToCwd(blueprintConfig.configPath)]);
+        }
+        else if (!blueprintConfig) {
+            configRows.push(['Source', styleText('dim', 'no config file')]);
+        }
+        if (blueprintConfig?.updatedAt) {
+            configRows.push(['Updated', new Date(blueprintConfig.updatedAt).toLocaleString('sv-SE')]);
+        }
         if (scopeType && scopeId) {
             const scopeSourceKey = scopeType === 'project' ? 'projectId' : 'organizationId';
-            log.verbose(indent(`${capitalize(scopeType)}: ${niceId(scopeId)} (from ${sourceLabel(sources?.[scopeSourceKey])})`));
+            const label = scopeType === 'project' ? 'Project' : 'Organization';
+            configRows.push([
+                label,
+                `${niceId(scopeId)}  ${styleText('dim', sourceLabel(sources?.[scopeSourceKey]))}`,
+            ]);
         }
         if (stackId) {
-            log.verbose(indent(`Deployment: ${niceId(stackId)} (from ${sourceLabel(sources?.stackId)})`));
+            configRows.push([
+                'Stack',
+                `${niceId(stackId)}  ${styleText('dim', sourceLabel(sources?.stackId))}`,
+            ]);
         }
-        // STACK + ACCESS
-        if (diagnostics.online && diagnostics.tokenValid && token && stackId && scopeType && scopeId) {
+        // --- STACK + ACCESS ---
+        if (diagnostics.online.status &&
+            diagnostics.tokenValid.status &&
+            token &&
+            stackId &&
+            scopeType &&
+            scopeId) {
             const stackResponse = await getStack({
                 auth: { token, scopeType, scopeId },
                 stackId,
                 logger: log,
             });
             if (stackResponse.ok) {
-                log.verbose(`Deployment "Stack" ${niceId(stackId)} ready`);
-                diagnostics.stackReady = true;
-                diagnostics.userHasAccess = true;
+                diagnostics.stackReady = { status: true };
+                diagnostics.userHasAccess = { status: true };
+                const stack = stackResponse.stack;
+                if (stack) {
+                    const label = stack.name ? `"${stack.name}" ${niceId(stackId)}` : niceId(stackId);
+                    stackRows.push(['Stack', label]);
+                    if (stack.recentOperation) {
+                        const op = stack.recentOperation;
+                        const time = op.completedAt || op.createdAt;
+                        const timestamp = time
+                            ? `  ${styleText('dim', new Date(time).toLocaleString('sv-SE'))}`
+                            : '';
+                        stackRows.push(['Operation', `${op.status}${timestamp}`]);
+                    }
+                }
             }
             else if (stackResponse.response?.status === 404) {
-                yikes(`Deployment "Stack" <${stackId}> not found`);
-                diagnostics.stackReady = false;
+                diagnostics.stackReady = {
+                    status: false,
+                    detail: `Stack ${niceId(stackId)} not found (404)`,
+                };
             }
             else if (stackResponse.response?.status === 403 || stackResponse.response?.status === 401) {
-                yikes(`User does not have access to "Stack" <${stackId}>`);
-                diagnostics.userHasAccess = false;
+                diagnostics.userHasAccess = {
+                    status: false,
+                    detail: `no access to Stack ${niceId(stackId)} (${stackResponse.response.status})`,
+                };
             }
             else {
-                yikes(`Unknown error with "Stack" <${stackId}>: ${stackResponse.error}`);
+                const statusSuffix = stackResponse.response?.status
+                    ? ` (${stackResponse.response.status})`
+                    : '';
+                diagnostics.stackReady = {
+                    status: null,
+                    detail: (stackResponse.error || 'unknown error') + statusSuffix,
+                };
+                diagnostics.userHasAccess = { status: null, detail: `unknown error${statusSuffix}` };
             }
         }
+        else if (stackId && scopeType && scopeId) {
+            diagnostics.stackReady = { status: null, detail: 'requires online + authenticated' };
+            diagnostics.userHasAccess = { status: null, detail: 'requires online + authenticated' };
+        }
+        else if (!stackId && !scopeType && !scopeId) {
+            diagnostics.stackReady = { status: null, detail: 'missing configuration' };
+            diagnostics.userHasAccess = { status: null, detail: 'missing configuration' };
+        }
         else {
+            const missing = [];
             if (!stackId)
-                yikes(`Blueprints configuration is missing a Stack ID`);
-            if (scopeType === 'project') {
-                if (!scopeId)
-                    yikes(`Blueprints configuration is missing a Project ID`);
-            }
-            else if (scopeType === 'organization') {
-                if (!scopeId)
-                    yikes(`Blueprints configuration is missing an Organization ID`);
-            }
-            else {
-                if (!scopeType)
-                    yikes(`Blueprints configuration is missing a Scope Type`);
-                if (!scopeId)
-                    yikes(`Blueprints configuration is missing a Scope ID`);
+                missing.push('Stack ID');
+            if (!scopeType)
+                missing.push('Scope Type');
+            if (!scopeId) {
+                const scopeLabel = scopeType === 'project'
+                    ? 'Project ID'
+                    : scopeType === 'organization'
+                        ? 'Organization ID'
+                        : 'Scope ID';
+                missing.push(scopeLabel);
             }
+            const detail = `missing ${missing.join(', ')}`;
+            diagnostics.stackReady = { status: null, detail };
+            diagnostics.userHasAccess = { status: null, detail };
         }
     }
-    log('');
+    // --- RENDER REPORT ---
+    spinner.stop();
+    // Environment (verbose)
+    renderSection((msg) => log.verbose(msg), 'Environment', envRows);
+    log.verbose('');
+    // Configuration (verbose)
+    if (configRows.length > 0) {
+        renderSection((msg) => log.verbose(msg), 'Configuration', configRows);
+        log.verbose('');
+    }
+    // Deployment (verbose)
+    if (stackRows.length > 0) {
+        renderSection((msg) => log.verbose(msg), 'Deployment', stackRows);
+        log.verbose('');
+    }
+    // Checks (always visible)
+    const maxLabel = Math.max(...Object.values(diagLookup).map((l) => l.length));
+    log(styleText('bold', 'Checks'));
     let allGood = true;
-    for (const [key, value] of Object.entries(diagnostics)) {
-        switch (value) {
+    for (const [key, entry] of Object.entries(diagnostics)) {
+        const label = diagLookup[key].padEnd(maxLabel);
+        const detail = entry.detail ? `  ${styleText('dim', entry.detail)}` : '';
+        switch (entry.status) {
             case true:
-                log(check(diagLookup[key]));
+                log(`  ${check(label)}${detail}`);
                 break;
             case false:
                 allGood = false;
-                log(severe(diagLookup[key]));
+                log(`  ${severe(label)}${detail}`);
                 break;
             case null:
                 allGood = false;
-                log(unsure(diagLookup[key]));
+                log(`  ${unsure(label)}${detail}`);
                 break;
-            default:
-                allGood = false;
-                log(severe(`${key} is ${value}`));
         }
     }
+    // Result
+    const flatDiagnostics = {};
+    for (const [key, entry] of Object.entries(diagnostics)) {
+        flatDiagnostics[key] = entry.status;
+    }
+    log('');
     const errorMessage = 'One or more checks failed';
     if (allGood) {
         log(styleText(['bold', 'green'], 'All checks passed'));
         if (fix)
             log(styleText(['bold', 'yellow'], 'Nothing to fix; --fix flag is ignored'));
-        return { success: true, data: { diagnostics } };
+        return { success: true, data: { diagnostics: flatDiagnostics } };
     }
-    else if (fix) {
+    if (fix) {
         if (p) {
             return {
                 success: false,
                 error: `${errorMessage}. --fix cannot be used with --path`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         if (!tokenOrError) {
             return {
                 success: false,
                 error: `${errorMessage}. Unable to fix: Missing authentication token`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         if (tokenOrError?.ok === false) {
             return {
                 success: false,
                 error: `${errorMessage}. Unable to fix: ${tokenOrError.error.message}`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         if (!localBlueprint) {
             return {
                 success: false,
                 error: `${errorMessage}. Unable to fix: Blueprint is missing or invalid`,
-                data: { diagnostics },
+                data: { diagnostics: flatDiagnostics },
             };
         }
         return blueprintConfigCore({
@@ -208,5 +301,6 @@ export async function blueprintDoctorCore(options) {
             flags: { edit: true, verbose: v },
         });
     }
-    return { success: false, error: errorMessage, data: { diagnostics } };
+    log(styleText('dim', `  Run \`${bin} blueprints doctor --fix\` to resolve configuration issues.`));
+    return { success: false, error: errorMessage, data: { diagnostics: flatDiagnostics } };
 }

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

@@ -1,11 +1,9 @@
-import type { AuthParams, Stack } from '../../utils/types.js';
+import type { 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;
         verbose?: boolean;
     };
 }

package/dist/cores/blueprints/info.js

@@ -1,26 +1,11 @@
-import { getStack } from '../../actions/blueprints/stacks.js';
 import { formatDeployedResourceTree, formatStackInfo, } from '../../utils/display/blueprints-formatting.js';
-import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintInfoCore(options) {
-    const { log, auth, stackId, flags, deployedStack } = options;
-    const { id: flagStackId, verbose = false } = flags;
+    const { log, deployedStack, flags } = options;
+    const { verbose = false } = flags;
     try {
-        const targetStackId = flagStackId || stackId;
-        let stack = deployedStack;
-        if (flagStackId) {
-            const existingStackResponse = await getStack({ stackId: targetStackId, auth, logger: log });
-            if (!existingStackResponse.ok) {
-                log.error(`Could not retrieve Stack deployment info for ${niceId(targetStackId)}`);
-                return {
-                    success: false,
-                    error: existingStackResponse.error || 'Failed to retrieve Stack deployment',
-                };
-            }
-            stack = existingStackResponse.stack;
-        }
-        log(formatStackInfo(stack, true));
-        if (stack.resources)
-            log(formatDeployedResourceTree(stack.resources, verbose));
+        log(formatStackInfo(deployedStack, true));
+        if (deployedStack.resources)
+            log(formatDeployedResourceTree(deployedStack.resources, verbose));
         return { success: true };
     }
     catch (error) {

package/dist/cores/blueprints/init.js

@@ -66,7 +66,7 @@ export async function blueprintInitCore(options) {
                     edit: true,
                     'project-id': flagProjectId,
                     'organization-id': flagOrganizationId,
-                    'stack-id': flagStackId,
+                    stack: flagStackId,
                     verbose: v,
                 },
             });

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

@@ -4,6 +4,7 @@ export interface BlueprintPlanOptions extends CoreConfig {
     blueprint: ReadBlueprintResult;
     token?: string;
     flags: {
+        stack?: string;
         verbose?: boolean;
     };
 }

package/dist/cores/blueprints/plan.js

@@ -1,25 +1,30 @@
-import { getStack } from '../../actions/blueprints/stacks.js';
+import { getStack, resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
 import { formatResourceTree, stackDeployDiff } from '../../utils/display/blueprints-formatting.js';
 import { styleText } from '../../utils/style-text.js';
 export async function blueprintPlanCore(options) {
     const { bin = 'sanity', log, blueprint, token, flags } = options;
     const { verbose: _verbose = false } = flags;
-    const { scopeType, scopeId, stackId, parsedBlueprint, fileInfo } = blueprint;
+    const { scopeType, scopeId, stackId: blueprintStackId, parsedBlueprint, fileInfo } = blueprint;
     log(`${styleText(['bold', 'blueBright'], 'Blueprint Stack deployment plan')} ${styleText('dim', `(${fileInfo.fileName})`)}`);
     log(formatResourceTree(parsedBlueprint.resources));
-    if (token && scopeType && scopeId && stackId) {
-        const stackResponse = await getStack({
-            auth: { token, scopeType, scopeId },
-            stackId,
-            logger: log,
-        });
-        if (!stackResponse.ok) {
-            log(styleText('dim', 'Unable to retrieve live Stack deployment for comparison'));
-        }
-        else {
-            const diff = stackDeployDiff(parsedBlueprint, stackResponse.stack);
-            if (diff)
-                log(diff);
+    if (token && scopeType && scopeId) {
+        const stackId = flags.stack
+            ? await resolveStackIdByNameOrId(flags.stack, { token, scopeType, scopeId }, log)
+            : blueprintStackId;
+        if (stackId) {
+            const stackResponse = await getStack({
+                auth: { token, scopeType, scopeId },
+                stackId,
+                logger: log,
+            });
+            if (!stackResponse.ok) {
+                log(styleText('dim', 'Unable to retrieve live Stack deployment for comparison'));
+            }
+            else {
+                const diff = stackDeployDiff(parsedBlueprint, stackResponse.stack);
+                if (diff)
+                    log(diff);
+            }
         }
     }
     log(`\n  Run "${styleText(['bold', 'magenta'], `${bin} blueprints deploy`)}" to deploy these Stack changes`);

package/dist/cores/index.d.ts

@@ -50,4 +50,5 @@ type InitBlueprintConfigParams = CoreConfig & ({
 export declare function initBlueprintConfig({ bin, log, token, validateResources, validateToken, blueprintPath, }: InitBlueprintConfigParams): Promise<Result<BlueprintConfig>>;
 export declare function initDeployedBlueprintConfig(config: Partial<BlueprintConfig> & Pick<BlueprintConfig, 'bin' | 'log' | 'token' | 'validateResources'> & {
     validateToken?: boolean;
+    stackOverride?: string;
 }): Promise<Result<DeployedBlueprintConfig>>;

package/dist/cores/index.js

@@ -1,5 +1,5 @@
 import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
-import { getStack } from '../actions/blueprints/stacks.js';
+import { getStack, resolveStackIdByNameOrId } from '../actions/blueprints/stacks.js';
 import { presentBlueprintParserErrors } from '../utils/display/errors.js';
 import { niceId } from '../utils/display/presenters.js';
 import { validTokenOrErrorMessage } from '../utils/validated-token.js';
@@ -41,15 +41,20 @@ export async function initDeployedBlueprintConfig(config) {
         config.blueprint = blueprintResult.value.blueprint;
         config.token = blueprintResult.value.token;
     }
-    const { scopeType, scopeId, stackId } = config.blueprint;
-    if (!(scopeType && scopeId && stackId)) {
+    const { scopeType, scopeId, stackId: blueprintStackId } = config.blueprint;
+    if (!scopeType || !scopeId) {
         config.log(`Incomplete configuration. Run \`${config.bin} blueprints doctor\` for diagnostics.`);
-        if (!scopeType || !scopeId)
-            return { ok: false, error: 'Missing scope configuration for Blueprint' };
-        if (!stackId)
-            return { ok: false, error: 'Missing Stack deployment configuration for Blueprint' };
+        return { ok: false, error: 'Missing scope configuration for Blueprint' };
     }
     const auth = { token: config.token, scopeType, scopeId };
+    let stackId = blueprintStackId;
+    if (config.stackOverride) {
+        stackId = await resolveStackIdByNameOrId(config.stackOverride, auth, config.log);
+    }
+    if (!stackId) {
+        config.log(`Incomplete configuration. Run \`${config.bin} blueprints doctor\` for diagnostics.`);
+        return { ok: false, error: 'Missing Stack deployment configuration for Blueprint' };
+    }
     const stackResponse = await getStack({ stackId, auth, logger: config.log });
     if (!stackResponse.ok) {
         config.log(`Could not retrieve Stack deployment info for ${niceId(stackId)}.`);