@sanity/runtime-cli 17.8.0 → 17.9.0-blueprinit.g14aaebd

package/dist/cores/blueprinit.d.ts

@@ -0,0 +1,7 @@
+import type { BlueprinitFlags } from './blueprinit/types.js';
+import type { CoreConfig, CoreResult } from './index.js';
+export interface BlueprinitOptions extends CoreConfig {
+    dir?: string;
+    flags?: BlueprinitFlags;
+}
+export declare function blueprinitCore(options: BlueprinitOptions): Promise<CoreResult>;

package/dist/cores/blueprinit.js

@@ -0,0 +1,64 @@
+import { existsSync, statSync } from 'node:fs';
+import { cwd } from 'node:process';
+import { detectStudio } from '../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../actions/blueprints/blueprint.js';
+import { readConfigFile } from '../actions/blueprints/config.js';
+import { validTokenOrErrorMessage } from '../utils/validated-token.js';
+import { adoptFlow } from './blueprinit/adopt.js';
+import { freshFlow } from './blueprinit/fresh.js';
+export async function blueprinitCore(options) {
+    const { bin, log, flags = {}, dir = cwd() } = options;
+    try {
+        // findBlueprintFile answers with any file it is handed, so refuse a file target first.
+        if (existsSync(dir) && !statSync(dir).isDirectory()) {
+            return {
+                success: false,
+                error: `${dir} is not a directory.`,
+                suggestions: ['Pass a directory to initialize, or no argument to use this one.'],
+            };
+        }
+        const existingBlueprint = findBlueprintFile(dir);
+        if (existingBlueprint) {
+            const blueprintConfig = readConfigFile(existingBlueprint.blueprintFilePath);
+            if (!blueprintConfig?.stackId) {
+                return {
+                    success: false,
+                    error: `A Blueprint exists here (${existingBlueprint.fileName}), but it is not connected to a Stack.`,
+                    suggestions: [`Finish setup with: npx ${bin} blueprints init`],
+                };
+            }
+            log(`A blueprint already exists here (${existingBlueprint.fileName}).`);
+            log('');
+            log('Use these instead:');
+            log(`  npx ${bin} blueprints config --edit`);
+            log(`  npx ${bin} blueprints doctor`);
+            return {
+                success: true,
+                json: { alreadyInitialized: true, blueprintFile: existingBlueprint.fileName },
+            };
+        }
+        const tokenCheck = await validTokenOrErrorMessage(log);
+        if (!tokenCheck.ok) {
+            return {
+                success: false,
+                error: 'No Sanity session found.',
+                suggestions: ['Sign in first: npx sanity login', 'Then run init again.'],
+            };
+        }
+        log('Setting up your Sanity workspace.');
+        log('');
+        const flowOptions = {
+            bin,
+            dir,
+            targetProvided: Boolean(options.dir),
+            flags,
+            log,
+            token: tokenCheck.value,
+        };
+        const studio = detectStudio(dir);
+        return studio ? await adoptFlow({ ...flowOptions, studio }) : await freshFlow(flowOptions);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}

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

@@ -2,13 +2,18 @@ import type { ScopeType } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintStacksOptions extends CoreConfig {
     token: string;
-    /** Scope to list Stacks for, resolved by the base command (flags > env > config). */
-    scopeType: ScopeType;
-    scopeId: string;
+    /**
+     * Scope to list Stacks for, resolved by the base command (flags > env > config).
+     * Prompted for when absent.
+     */
+    scopeType?: ScopeType;
+    scopeId?: string;
     /** Locally-configured Stack ID, used only to highlight the current Stack in listings. */
     localStackId?: string;
     flags: {
+        all?: boolean;
         'include-projects'?: boolean;
+        json?: boolean;
         verbose?: boolean;
     };
 }

package/dist/cores/blueprints/stacks.js

@@ -1,39 +1,78 @@
 import { listStacks } from '../../actions/blueprints/stacks.js';
-import { listProjects } from '../../actions/sanity/projects.js';
+import { listOrganizations, listProjects, } from '../../actions/sanity/projects.js';
+import { CI_SETUP_DOCS_URL } from '../../constants.js';
 import { formatStacksListing } from '../../utils/display/blueprints-formatting.js';
 import { capitalize, niceId, warn } from '../../utils/display/presenters.js';
+import { promptForOrganization, promptForProjectInOrg, promptForScope, promptForScopeRecovery, } from '../../utils/display/prompt.js';
+import { isInteractive } from '../../utils/interactive.js';
 import { styleText } from '../../utils/style-text.js';
-/** Max projects to query for stacks during --include-projects */
+/** Max projects to query for stacks within one organization */
 const PROJECT_LIMIT = 50;
+/** Max projects to query for stacks across every organization */
+const ALL_PROJECTS_LIMIT = 200;
+/** Stack listings in flight while querying many scopes */
+const SCOPE_CONCURRENCY = 5;
 export async function blueprintStacksCore(options) {
-    const { log, token, scopeType, scopeId, localStackId: blueprintStackId, flags } = options;
-    const { 'include-projects': includeProjects = false } = flags;
-    if (includeProjects && scopeType === 'organization') {
-        return deepListStacks({ organizationId: scopeId, token, log, blueprintStackId });
-    }
+    const { bin, log, token, localStackId: blueprintStackId, flags } = options;
+    const { all = false, 'include-projects': includeProjects = false, json = false } = flags;
     try {
-        const spinner = log.ora('Fetching Stacks...').start();
-        const { ok, stacks, error } = await listStacks({ token, scopeType, scopeId }, log);
-        if (!ok) {
-            spinner.fail('Failed to list Stacks');
-            const suggestions = [];
-            if (error && /access|permission|forbidden/i.test(error)) {
-                suggestions.push('Verify you have access to this organization or project.', `Try a different scope with --project-id or --organization-id.`);
+        if (all)
+            return await listStacksEverywhere({ token, log, blueprintStackId });
+        let { scopeType, scopeId } = options;
+        let displayName;
+        let promptedForScope = false;
+        let hasAlternativeScope = false;
+        while (true) {
+            if (!scopeType || !scopeId) {
+                if (!isInteractive || json)
+                    return missingScopeResult(bin);
+                const chosen = await chooseScope({ token, log });
+                scopeType = chosen.scopeType;
+                scopeId = chosen.scopeId;
+                displayName = chosen.displayName;
+                hasAlternativeScope = chosen.hasAlternativeScope;
+                promptedForScope = true;
             }
-            return {
-                success: false,
-                error: error || 'Failed to list stacks',
-                suggestions: suggestions.length ? suggestions : undefined,
-            };
-        }
-        spinner.stop().clear();
-        if (!stacks || stacks.length === 0) {
-            log('No stacks found');
-            return { success: true };
+            if (includeProjects && scopeType === 'organization') {
+                return await listStacksAcrossOrganization({
+                    organizationId: scopeId,
+                    token,
+                    log,
+                    blueprintStackId,
+                });
+            }
+            const spinner = log.ora('Fetching Stacks...').start();
+            const result = await listStacks({ token, scopeType, scopeId }, log);
+            if (!result.ok) {
+                if (promptedForScope && hasAlternativeScope && result.response?.status === 403) {
+                    spinner.stop().clear();
+                    log(warn(`Your account can see ${scopeTargetLabel({ scopeType, scopeId, displayName })}, but cannot read its Blueprint Stacks.`));
+                    const recovery = await promptForScopeRecovery();
+                    if (recovery === 'retry') {
+                        scopeType = undefined;
+                        scopeId = undefined;
+                        displayName = undefined;
+                        hasAlternativeScope = false;
+                        continue;
+                    }
+                }
+                else {
+                    spinner.fail('Failed to list Stacks');
+                }
+                return listStacksFailure(result.error, result.response?.status);
+            }
+            spinner.stop().clear();
+            if (result.stacks.length === 0) {
+                log('No stacks found');
+                return { success: true, json: { stacks: [], scopeType, scopeId } };
+            }
+            printStackGroups({
+                groups: [{ scopeType, scopeId, displayName, stacks: result.stacks }],
+                log,
+                blueprintStackId,
+            });
+            return { success: true, json: { stacks: result.stacks, scopeType, scopeId } };
         }
-        log(`${styleText('bold', capitalize(scopeType))} ${niceId(scopeId)} ${styleText('bold', 'Stacks')}:\n`);
-        log(formatStacksListing(stacks, blueprintStackId));
-        return { success: true, json: { stacks, scopeType, scopeId } };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -41,71 +80,229 @@ export async function blueprintStacksCore(options) {
         return { success: false, error: errorMessage };
     }
 }
-async function deepListStacks(options) {
+function listStacksFailure(error, status) {
+    return {
+        success: false,
+        error: error || 'Failed to list stacks',
+        suggestions: status === 403
+            ? [
+                'Ask an administrator to grant you read access to Blueprint Stacks for this organization or project.',
+                'Try a different scope with --project-id or --organization-id.',
+            ]
+            : undefined,
+    };
+}
+function missingScopeResult(bin) {
+    return {
+        success: false,
+        error: 'Missing scope: provide --project-id or --organization-id.',
+        suggestions: [
+            `Run \`${bin} blueprints stacks --all\` to list Stacks for every organization and project.`,
+            'Set SANITY_PROJECT_ID or SANITY_ORGANIZATION_ID when no terminal is available.',
+        ],
+        ref: CI_SETUP_DOCS_URL,
+    };
+}
+/** Organization, then project when the user picks project scope. */
+async function chooseScope(options) {
+    const { token, log } = options;
+    const orgResult = await promptForOrganization({ token, logger: log });
+    if (typeof orgResult === 'symbol')
+        throw new Error('Unexpected back navigation');
+    const scopeType = await promptForScope({
+        hasProjects: orgResult.projects.length > 0,
+        message: 'Which Stacks would you like to list?',
+    });
+    if (typeof scopeType === 'symbol')
+        throw new Error('Unexpected back navigation');
+    if (scopeType === 'organization') {
+        const { id, name } = orgResult.organization;
+        return {
+            scopeType,
+            scopeId: id,
+            displayName: name,
+            hasAlternativeScope: orgResult.wasPrompted || orgResult.projects.length > 0,
+        };
+    }
+    const project = await promptForProjectInOrg({ projects: orgResult.projects, logger: log });
+    if (typeof project === 'symbol')
+        throw new Error('Unexpected back navigation');
+    return {
+        scopeType,
+        scopeId: project.projectId,
+        displayName: project.displayName,
+        // The containing organization is another possible scope even when it has no other projects.
+        hasAlternativeScope: true,
+    };
+}
+async function listStacksAcrossOrganization(options) {
     const { organizationId, token, log, blueprintStackId } = options;
-    const allStacks = [];
     const spinner = log.ora('Fetching Stacks...').start();
-    try {
-        // 1. Org-scoped stacks
-        const orgResult = await listStacks({ token, scopeType: 'organization', scopeId: organizationId }, log);
-        const orgStacks = orgResult.ok ? orgResult.stacks : [];
-        // 2. Get projects in the organization
-        const projectsResult = await listProjects({ token, organizationId, logger: log });
-        if (!projectsResult.ok) {
-            spinner.fail('Failed to list projects');
-            return { success: false, error: projectsResult.error || 'Failed to list projects' };
+    const projectsResult = await listProjects({ token, organizationId, logger: log });
+    if (!projectsResult.ok) {
+        spinner.fail('Failed to list projects');
+        return { success: false, error: projectsResult.error || 'Failed to list projects' };
+    }
+    const projects = projectsResult.projects;
+    const targets = [
+        { scopeType: 'organization', scopeId: organizationId },
+        ...projectTargets(projects.slice(0, PROJECT_LIMIT)),
+    ];
+    const { groups, failures, successfulScopes } = await collectStackGroups({
+        targets,
+        token,
+        log,
+        onProgress: (completed, total) => {
+            spinner.text = `Fetching Stacks... (${completed}/${total})`;
+        },
+    });
+    if (successfulScopes === 0 && failures.length > 0) {
+        spinner.fail('Failed to list Stacks');
+        return listStacksFailure(failures[0].error, failures[0].status);
+    }
+    spinner.stop().clear();
+    const stacks = groups.flatMap((group) => group.stacks);
+    if (stacks.length > 0)
+        printStackGroups({ groups, log, blueprintStackId });
+    else
+        log('No stacks found');
+    const organizationFailure = failures.find(({ target }) => target.scopeType === 'organization');
+    if (organizationFailure) {
+        log(warn(`Could not read organization-scoped Stacks: ${organizationFailure.error}`));
+    }
+    const projectFailures = failures.filter(({ target }) => target.scopeType === 'project');
+    if (projectFailures.length > 0) {
+        const projectCount = targets.filter(({ scopeType }) => scopeType === 'project').length;
+        log(warn(`Could not read Stacks for ${projectFailures.length} of ${projectCount} projects.`));
+        for (const { target, error } of projectFailures) {
+            log.verbose(`Project ${target.scopeId}: ${error}`);
         }
-        const projects = projectsResult.projects;
-        const totalProjects = projects.length;
-        const cappedProjects = projects.slice(0, PROJECT_LIMIT);
-        // 3. Fetch stacks for each project
-        const projectGroups = [];
-        for (let i = 0; i < cappedProjects.length; i++) {
-            const project = cappedProjects[i];
-            spinner.text = `Fetching Stacks... (project ${i + 1}/${cappedProjects.length})`;
-            const result = await listStacks({ token, scopeType: 'project', scopeId: project.id }, log);
-            if (result.ok && result.stacks.length > 0) {
-                projectGroups.push({
-                    projectId: project.id,
-                    displayName: project.displayName,
-                    stacks: result.stacks,
+    }
+    if (projects.length > PROJECT_LIMIT)
+        log(projectLimitWarning(projects.length, PROJECT_LIMIT));
+    return { success: true, json: { stacks, scopeType: 'organization', scopeId: organizationId } };
+}
+/** Every organization and project the token can reach, skipping the scopes it cannot read. */
+async function listStacksEverywhere(options) {
+    const { token, log, blueprintStackId } = options;
+    const spinner = log.ora('Finding organizations and projects...').start();
+    const [orgsResult, projectsResult] = await Promise.all([
+        listOrganizations({ token, logger: log }),
+        listProjects({ token, logger: log }),
+    ]);
+    if (!orgsResult.ok && !projectsResult.ok) {
+        spinner.fail('Failed to list organizations and projects');
+        return {
+            success: false,
+            error: orgsResult.error || projectsResult.error || 'Failed to list organizations',
+        };
+    }
+    const discoveryWarnings = [];
+    if (!orgsResult.ok) {
+        discoveryWarnings.push(`Could not list organizations: ${orgsResult.error || 'unknown error'}`);
+    }
+    if (!projectsResult.ok) {
+        discoveryWarnings.push(`Could not list projects: ${projectsResult.error || 'unknown error'}`);
+    }
+    const organizations = orgsResult.ok ? orgsResult.organizations : [];
+    const projects = projectsResult.ok ? projectsResult.projects : [];
+    const targets = buildScopeTargets(organizations, projects.slice(0, ALL_PROJECTS_LIMIT));
+    spinner.text = 'Fetching Stacks...';
+    const { groups, failures, successfulScopes } = await collectStackGroups({
+        targets,
+        token,
+        log,
+        onProgress: (completed, total) => {
+            spinner.text = `Fetching Stacks... (${completed}/${total})`;
+        },
+    });
+    if (targets.length > 0 && successfulScopes === 0) {
+        spinner.fail('Failed to list Stacks');
+        return listStacksFailure(failures[0]?.error, failures[0]?.status);
+    }
+    spinner.stop().clear();
+    const stacks = groups.flatMap((group) => group.stacks);
+    if (stacks.length > 0)
+        printStackGroups({ groups, log, blueprintStackId });
+    else if (targets.length === 0)
+        log('No organizations or projects found');
+    else
+        log('No stacks found');
+    for (const message of discoveryWarnings)
+        log(warn(message));
+    if (projects.length > ALL_PROJECTS_LIMIT) {
+        log(projectLimitWarning(projects.length, ALL_PROJECTS_LIMIT));
+    }
+    if (failures.length > 0) {
+        log(warn(`Could not read Stacks for ${failures.length} of ${targets.length} scopes.`));
+        for (const { target, error } of failures) {
+            log.verbose(`${capitalize(target.scopeType)} ${target.scopeId}: ${error}`);
+        }
+    }
+    return { success: true, json: { stacks } };
+}
+async function collectStackGroups(options) {
+    const { targets, token, log, onProgress } = options;
+    const groups = [];
+    const failures = [];
+    let completed = 0;
+    let successfulScopes = 0;
+    for (let start = 0; start < targets.length; start += SCOPE_CONCURRENCY) {
+        const batch = await Promise.all(targets.slice(start, start + SCOPE_CONCURRENCY).map(async (target) => {
+            const { scopeType, scopeId } = target;
+            const result = await listStacks({ token, scopeType, scopeId }, log);
+            completed += 1;
+            onProgress?.(completed, targets.length);
+            return { target, result };
+        }));
+        for (const { target, result } of batch) {
+            if (!result.ok) {
+                failures.push({
+                    target,
+                    error: result.error || 'Failed to list stacks',
+                    status: result.response?.status,
                 });
-                allStacks.push(...result.stacks);
             }
-            else if (!result.ok) {
-                throw new Error(result.error);
+            else {
+                successfulScopes += 1;
+                if (result.stacks.length > 0)
+                    groups.push({ ...target, stacks: result.stacks });
             }
         }
-        spinner.stop().clear();
-        // 4. Print results
-        if (orgStacks.length > 0) {
-            log(`${styleText('bold', 'Organization')} ${niceId(organizationId)} ${styleText('bold', 'Stacks')}:\n`);
-            log(formatStacksListing(orgStacks, blueprintStackId));
-            if (projectGroups.length > 0)
-                log(''); // blank line between sections
-        }
-        for (const group of projectGroups) {
-            log(`${styleText('bold', 'Project')} "${group.displayName}" ${niceId(group.projectId)} ${styleText('bold', 'Stacks')}:`);
-            log(formatStacksListing(group.stacks, blueprintStackId));
-            log('');
-        }
-        if (totalProjects > PROJECT_LIMIT) {
-            log(warn(`Organization has ${totalProjects} projects, only checked the first ${PROJECT_LIMIT}.`));
-        }
-        if (orgStacks.length === 0 && allStacks.length === 0) {
-            log('No stacks found');
-            return { success: true };
-        }
-        allStacks.push(...orgStacks);
-        return {
-            success: true,
-            json: { stacks: allStacks, scopeType: 'organization', scopeId: organizationId },
-        };
     }
-    catch (error) {
-        spinner.stop().clear();
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log.error(`Error: ${errorMessage}`);
-        return { success: false, error: errorMessage };
+    return { groups, failures, successfulScopes };
+}
+function buildScopeTargets(organizations, projects) {
+    const organizationIds = new Set(organizations.map(({ id }) => id));
+    const targets = [];
+    for (const { id, name } of organizations) {
+        targets.push({ scopeType: 'organization', scopeId: id, displayName: name });
+        targets.push(...projectTargets(projects.filter((p) => p.organizationId === id)));
     }
+    targets.push(...projectTargets(projects.filter((p) => !organizationIds.has(p.organizationId))));
+    return targets;
+}
+function projectTargets(projects) {
+    return projects.map(({ id, displayName }) => ({
+        scopeType: 'project',
+        scopeId: id,
+        displayName,
+    }));
+}
+function scopeTargetLabel({ scopeType, scopeId, displayName }) {
+    const name = displayName ? ` "${displayName}"` : '';
+    return `${scopeType}${name} ${niceId(scopeId)}`;
+}
+function printStackGroups(options) {
+    const { groups, log, blueprintStackId } = options;
+    groups.forEach((group, index) => {
+        const name = group.displayName ? ` "${group.displayName}"` : '';
+        if (index > 0)
+            log('');
+        log(`${styleText('bold', capitalize(group.scopeType))}${name} ${niceId(group.scopeId)} ${styleText('bold', 'Stacks')}:\n`);
+        log(formatStacksListing(group.stacks, blueprintStackId));
+    });
+}
+function projectLimitWarning(total, limit) {
+    return warn(`Found ${total} projects, only checked the first ${limit}.`);
 }

package/dist/cores/functions/test.d.ts

@@ -1,29 +1,12 @@
 import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import { type FunctionTestFlags } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface FunctionTestOptions extends CoreConfig {
     blueprint: ReadBlueprintResult;
     args: {
         name: string | undefined;
     };
-    flags: {
-        data?: string;
-        event?: string;
-        file?: string;
-        timeout?: number;
-        api?: string;
-        dataset?: string;
-        'project-id'?: string;
-        'organization-id'?: string;
-        'document-id'?: string;
-        'with-user-token'?: boolean;
-        'data-before'?: string;
-        'data-after'?: string;
-        'file-before'?: string;
-        'file-after'?: string;
-        'document-id-before'?: string;
-        'document-id-after'?: string;
-        'media-library-id'?: string;
-    };
+    flags: FunctionTestFlags;
     error: (message: string, options: object) => void;
     helpText: string;
 }