@sanity/runtime-cli 17.7.1 → 17.8.0-blueprinit.g0993fa5

package/dist/cores/blueprinit/adopt.js

@@ -0,0 +1,154 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { env } from 'node:process';
+import { defaultStackName, hostedStudioOrigin, projectBaseName, projectResourceName, } from '../../actions/blueprinit/manifest.js';
+import { adoptWorkspace } from '../../actions/blueprinit/workspace.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { getLatestNpmRange } from '../../utils/external/npmjs.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { styleText } from '../../utils/style-text.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { blueprintPreviewCounts, fileLines, printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, duplicateResourceNames, studioResourceName } from './prompts.js';
+import { findProject } from './selection.js';
+import { chooseStackName, takenStackNames } from './stack-name.js';
+export async function adoptFlow(options) {
+    const { bin, dir, flags, log, studio, token } = options;
+    if (flags.projectId && studio.projectId && flags.projectId !== studio.projectId) {
+        return { success: false, error: `The Studio uses project "${studio.projectId}".` };
+    }
+    if (flags.datasetName && studio.dataset && flags.datasetName !== studio.dataset) {
+        return { success: false, error: `The Studio uses dataset "${studio.dataset}".` };
+    }
+    const projectId = studio.projectId ?? flags.projectId;
+    const datasetName = studio.dataset ?? flags.datasetName;
+    if (!projectId || !datasetName) {
+        return {
+            success: false,
+            error: `Found ${studio.configFile}, but could not read a projectId and dataset from it.`,
+            suggestions: ['Use literal values in the Studio config or pass --project-id and --dataset.'],
+        };
+    }
+    log(check(`Studio detected (${studio.configFile})`));
+    const grouped = await groupProjectsByOrganization({ token, logger: log });
+    if (!grouped.ok) {
+        return { success: false, error: `Could not list organizations: ${grouped.error}` };
+    }
+    const match = findProject(grouped.organizations, projectId);
+    if (!match) {
+        return {
+            success: false,
+            error: `Project "${projectId}" from ${studio.configFile} was not found in your account.`,
+        };
+    }
+    if (flags.organizationId && flags.organizationId !== match.organization.id) {
+        return {
+            success: false,
+            error: `Project "${studio.projectId}" belongs to organization "${match.organization.id}".`,
+        };
+    }
+    const datasets = await listDatasets({ token, projectId: match.project.id, logger: log });
+    if (!datasets.ok) {
+        return { success: false, error: `Could not list datasets: ${datasets.error}` };
+    }
+    if (!datasets.datasets.some(({ name }) => name === datasetName)) {
+        return {
+            success: false,
+            error: `Dataset "${datasetName}" was not found in project ${match.project.displayName}.`,
+        };
+    }
+    log(check(`Matches project ${match.project.displayName} (${match.project.id}), dataset ${datasetName}`));
+    log('');
+    const baseName = projectBaseName(match.project.displayName, match.project.id);
+    const projectName = projectResourceName(baseName);
+    const studioName = studioResourceName(flags);
+    // The Stack name is the hosted Studio slug, so one answer names both.
+    const stackNameResult = await chooseStackName({
+        flags,
+        interactive: isInteractive,
+        defaultName: defaultStackName(baseName, datasetName),
+        taken: await takenStackNames({ token, organizationId: match.organization.id, log }),
+        log,
+    });
+    if (!stackNameResult.ok) {
+        return {
+            success: false,
+            error: stackNameResult.error,
+            suggestions: stackNameResult.suggestions,
+        };
+    }
+    const stackName = stackNameResult.value;
+    const duplicates = duplicateResourceNames([
+        projectName,
+        datasetName,
+        `${studioName}-cors`,
+        studioName,
+    ]);
+    if (duplicates.length > 0) {
+        return {
+            success: false,
+            error: `Blueprint resource names must be unique. Used twice: ${duplicates.join(', ')}.`,
+            suggestions: ['Pass --studio-name with a different value.'],
+        };
+    }
+    const studioOrigin = hostedStudioOrigin(stackName, env.SANITY_INTERNAL_ENV);
+    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
+    const previewOptions = {
+        log,
+        organizationName: match.organization.name,
+        projectId: match.project.id,
+        projectName: match.project.displayName,
+        datasetName,
+        studioName,
+        studioOrigin,
+        studioSource: '.',
+        stackName,
+    };
+    printBlueprintPreview(previewOptions);
+    const { attaches, creates } = blueprintPreviewCounts(previewOptions);
+    log(styleText('bold', 'Changes:'));
+    for (const line of fileLines([
+        ['+', 'sanity.blueprint.ts', "attach project + dataset; add CORS and Studio at '.'"],
+        ['+', '.sanity/blueprint.config.json', `org scope, stack ${stackName}`],
+        [marker('.gitignore'), '.gitignore'],
+        [marker('package.json'), 'package.json'],
+    ])) {
+        log(line);
+    }
+    log('');
+    const confirmed = await confirmUnlessSkipped(flags, isInteractive, 'Adopt this Studio into the Blueprint?');
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    const adoption = adoptWorkspace({
+        dir,
+        projectId: match.project.id,
+        displayName: match.project.displayName,
+        datasetName,
+        stackName,
+        projectName,
+        studioName,
+        studioSlug: stackName,
+        studioOrigin,
+        blueprintsVersion: await getLatestNpmRange('@sanity/blueprints', log),
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: match.organization.id,
+        projectId: match.project.id,
+        datasetName,
+        stackName,
+        blueprintFilePath: adoption.blueprintFilePath,
+        files: adoption.files,
+        nextSteps: [
+            ...alignSteps([
+                [`npx ${bin} blueprints plan`, `preview the ${attaches} attaches and ${creates} creates`],
+                [`npx ${bin} blueprints deploy`, 'attach and create them'],
+                [`npx ${bin} blueprints info`, 'review what the Stack owns'],
+            ]),
+            '',
+            `Your Studio is hosted at ${studioOrigin} after deploy.`,
+        ],
+    });
+}

package/dist/cores/blueprinit/finish.d.ts

@@ -0,0 +1,15 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+interface FinishOptions extends BlueprinitFlowOptions {
+    organizationId: string;
+    projectId: string;
+    datasetName: string;
+    stackName: string;
+    blueprintFilePath: string;
+    files: string[];
+    nextSteps: string[];
+}
+export declare function createStackAndFinish(options: FinishOptions): Promise<CoreResult>;
+/** Pads on the raw command, then styles, so colour codes never widen a column. */
+export declare function alignSteps(steps: Array<[command: string, description?: string]>): string[];
+export {};

package/dist/cores/blueprinit/finish.js

@@ -0,0 +1,73 @@
+import { writeConfigFile } from '../../actions/blueprints/config.js';
+import { createEmptyStack } from '../../actions/blueprints/stacks.js';
+import { check } from '../../utils/display/presenters.js';
+import { styleText } from '../../utils/style-text.js';
+export async function createStackAndFinish(options) {
+    let stack;
+    try {
+        stack = await createEmptyStack({
+            token: options.token,
+            scopeType: 'organization',
+            scopeId: options.organizationId,
+            name: options.stackName,
+            logger: options.log,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Local files were written, but Stack creation failed: ${message}`,
+            suggestions: [
+                'Resolve the Stack error, then finish setup with:',
+                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-name ${options.stackName}`,
+            ],
+        };
+    }
+    try {
+        writeConfigFile(options.blueprintFilePath, {
+            organizationId: options.organizationId,
+            stackId: stack.id,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Stack ${stack.id} was created, but the local Blueprint config could not be written: ${message}`,
+            suggestions: [
+                'Finish setup with:',
+                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-id ${stack.id}`,
+            ],
+        };
+    }
+    options.log('');
+    options.log(check(`Stack ${styleText('bold', stack.name)} created ${styleText('dim', '(org scope, nothing deployed yet)')}`));
+    options.log('');
+    options.log('');
+    options.log(styleText('bold', 'Next steps:'));
+    for (const step of options.nextSteps)
+        options.log(step);
+    return {
+        success: true,
+        json: {
+            organizationId: options.organizationId,
+            projectId: options.projectId,
+            dataset: options.datasetName,
+            stackId: stack.id,
+            stackName: stack.name,
+            files: [...options.files, '.sanity/blueprint.config.json'],
+        },
+    };
+}
+/** Pads on the raw command, then styles, so colour codes never widen a column. */
+export function alignSteps(steps) {
+    const width = Math.max(...steps.map(([command]) => command.length));
+    return steps.map(([command, description]) => {
+        const styled = `  ${styleText('cyan', command)}`;
+        if (!description)
+            return styled;
+        const gap = ' '.repeat(width - command.length + 2);
+        return `${styled}${gap}${styleText('dim', description)}`;
+    });
+}

package/dist/cores/blueprinit/fresh.d.ts

@@ -0,0 +1,3 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function freshFlow(options: BlueprinitFlowOptions): Promise<CoreResult>;

package/dist/cores/blueprinit/fresh.js

@@ -0,0 +1,173 @@
+import { mkdirSync } from 'node:fs';
+import { env } from 'node:process';
+import { defaultStackName, hostedStudioOrigin, projectBaseName, projectResourceName, STARTER_FUNCTION_NAME, } from '../../actions/blueprinit/manifest.js';
+import { scaffoldWorkspace } from '../../actions/blueprinit/workspace.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { getLatestNpmRange } from '../../utils/external/npmjs.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { styleText } from '../../utils/style-text.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { blueprintPreviewCounts, fileLines, printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, duplicateResourceNames, studioResourceName } from './prompts.js';
+import { chooseDataset, chooseOrganization, chooseProject } from './selection.js';
+import { chooseStackName, takenStackNames } from './stack-name.js';
+import { promptForTargetDirectory, relativeTargetPath, resolveTargetDirectory } from './target.js';
+export async function freshFlow(options) {
+    const { bin, dir, flags, log, token } = options;
+    const grouped = await groupProjectsByOrganization({ token, logger: log });
+    if (!grouped.ok) {
+        return { success: false, error: `Could not list organizations: ${grouped.error}` };
+    }
+    const organizationResult = await chooseOrganization(grouped.organizations, flags.organizationId, isInteractive);
+    if (!organizationResult.ok) {
+        return {
+            success: false,
+            error: organizationResult.error.message,
+            suggestions: organizationResult.error.suggestions,
+        };
+    }
+    const { organization, projects = [] } = organizationResult.value;
+    const projectResult = await chooseProject(projects, flags.projectId, organization.name, isInteractive);
+    if (!projectResult.ok) {
+        return {
+            success: false,
+            error: projectResult.error.message,
+            suggestions: projectResult.error.suggestions,
+        };
+    }
+    const project = projectResult.value;
+    const datasets = await listDatasets({ token, projectId: project.id, logger: log });
+    if (!datasets.ok) {
+        return { success: false, error: `Could not list datasets: ${datasets.error}` };
+    }
+    const datasetResult = await chooseDataset(datasets.datasets, flags.datasetName, project.displayName, isInteractive);
+    if (!datasetResult.ok) {
+        return {
+            success: false,
+            error: datasetResult.error.message,
+            suggestions: datasetResult.error.suggestions,
+        };
+    }
+    const dataset = datasetResult.value;
+    log(check(`Org: ${organization.name} (${organization.id})`));
+    log(check(`Project: ${project.displayName} (${project.id}), dataset: ${dataset.name}`));
+    log('');
+    const baseName = projectBaseName(project.displayName, project.id);
+    const projectName = projectResourceName(baseName);
+    const studioName = studioResourceName(flags);
+    const target = options.targetProvided
+        ? { ok: true, value: dir }
+        : resolveTargetDirectory(dir, await promptForTargetDirectory(dir, baseName, isInteractive && !flags.yes), bin);
+    if (!target.ok) {
+        return { success: false, error: target.error.message, suggestions: target.error.suggestions };
+    }
+    const targetDir = target.value;
+    // The Stack name is the hosted Studio slug, so one answer names both.
+    const stackNameResult = await chooseStackName({
+        flags,
+        interactive: isInteractive,
+        defaultName: defaultStackName(baseName, dataset.name),
+        taken: await takenStackNames({ token, organizationId: organization.id, log }),
+        log,
+    });
+    if (!stackNameResult.ok) {
+        return {
+            success: false,
+            error: stackNameResult.error,
+            suggestions: stackNameResult.suggestions,
+        };
+    }
+    const stackName = stackNameResult.value;
+    const duplicates = duplicateResourceNames([
+        projectName,
+        dataset.name,
+        `${studioName}-cors`,
+        studioName,
+        STARTER_FUNCTION_NAME,
+    ]);
+    if (duplicates.length > 0) {
+        return {
+            success: false,
+            error: `Blueprint resource names must be unique. Used twice: ${duplicates.join(', ')}.`,
+            suggestions: ['Pass --studio-name with a different value.'],
+        };
+    }
+    const studioOrigin = hostedStudioOrigin(stackName, env.SANITY_INTERNAL_ENV);
+    const previewOptions = {
+        log,
+        organizationName: organization.name,
+        projectId: project.id,
+        projectName: project.displayName,
+        datasetName: dataset.name,
+        studioName,
+        studioOrigin,
+        studioSource: `studios/${studioName}`,
+        stackName,
+        functionName: STARTER_FUNCTION_NAME,
+    };
+    printBlueprintPreview(previewOptions);
+    const { attaches, creates } = blueprintPreviewCounts(previewOptions);
+    log(styleText('bold', 'Files to write:'));
+    for (const line of fileLines([
+        ['+', 'sanity.blueprint.ts', 'project + dataset (attached), CORS, studio, function'],
+        ['+', `studios/${studioName}/`, 'Studio with a "post" type'],
+        ['+', `functions/${STARTER_FUNCTION_NAME}/`, 'sets a post slug from its title'],
+        ['+', '.sanity/blueprint.config.json', `org scope, stack ${stackName}`],
+        ['+', '.gitignore'],
+        ['+', 'package.json'],
+    ])) {
+        log(line);
+    }
+    log('');
+    const confirmed = await confirmUnlessSkipped(flags, isInteractive, `Create this Blueprint workspace for "${project.displayName}"?`);
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    const relativeDir = relativeTargetPath(targetDir);
+    const [blueprintsVersion, sanityVersion, visionVersion] = await Promise.all([
+        getLatestNpmRange('@sanity/blueprints', log),
+        getLatestNpmRange('sanity', log),
+        getLatestNpmRange('@sanity/vision', log),
+    ]);
+    mkdirSync(targetDir, { recursive: true });
+    const scaffold = scaffoldWorkspace({
+        dir: targetDir,
+        projectId: project.id,
+        displayName: project.displayName,
+        datasetName: dataset.name,
+        stackName,
+        projectName,
+        studioName,
+        studioSlug: stackName,
+        studioOrigin,
+        blueprintsVersion,
+        studioVersions: { sanity: sanityVersion, vision: visionVersion },
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: organization.id,
+        projectId: project.id,
+        datasetName: dataset.name,
+        stackName,
+        blueprintFilePath: scaffold.blueprintFilePath,
+        files: scaffold.files,
+        nextSteps: [
+            ...alignSteps([
+                ...(relativeDir ? [[`cd ${relativeDir}`]] : []),
+                ['npm install'],
+                [`npm run dev -w studios/${studioName}`, 'open the Studio and add a post'],
+                [`npx ${bin} blueprints plan`, `preview the ${attaches} attaches and ${creates} creates`],
+                [`npx ${bin} blueprints deploy`, 'attach and create them'],
+                [`npx ${bin} blueprints info`, 'review what the Stack owns'],
+            ]),
+            '',
+            `Your Studio is hosted at ${studioOrigin} after deploy.`,
+            '',
+            `${STARTER_FUNCTION_NAME} fills in a post's slug. Try it on a post you added, then follow the deployed one:`,
+            `  npx ${bin} functions test ${STARTER_FUNCTION_NAME} --document-id <id>` +
+                ` --project-id ${project.id} --dataset ${dataset.name} --with-user-token`,
+            `  npx ${bin} functions logs ${STARTER_FUNCTION_NAME}`,
+        ],
+    });
+}

package/dist/cores/blueprinit/preview.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '../../utils/logger.js';
+interface BlueprintPreviewOptions {
+    log: Logger;
+    organizationName: string;
+    projectId: string;
+    projectName: string;
+    datasetName: string;
+    studioName: string;
+    studioOrigin: string;
+    studioSource: string;
+    stackName: string;
+    functionName?: string;
+}
+/** The counts `blueprints plan` will report for this Blueprint. */
+export declare function blueprintPreviewCounts(options: BlueprintPreviewOptions): {
+    attaches: number;
+    creates: number;
+};
+export declare function printBlueprintPreview(options: BlueprintPreviewOptions): void;
+/** A local change: a marker, the path, and what the file is for. */
+export type FileLine = [marker: '+' | '~', path: string, description?: string];
+/** Pads on the raw path, then styles, so colour codes never widen a column. */
+export declare function fileLines(lines: FileLine[]): string[];
+export {};

package/dist/cores/blueprinit/preview.js

@@ -0,0 +1,97 @@
+import { styleText } from '../../utils/style-text.js';
+/** The icon and colour `blueprints plan` uses for the same action. */
+const ACTION_STYLE = {
+    attach: { icon: '←', color: 'blue' },
+    create: { icon: '+', color: 'green' },
+};
+const RETAIN = 'on deploy; retain on Stack removal';
+function previewResources(options) {
+    const resources = [
+        {
+            action: 'attach',
+            kind: 'Project',
+            name: `${options.projectName} (${options.projectId})`,
+            detail: RETAIN,
+        },
+        { action: 'attach', kind: 'Dataset', name: options.datasetName, detail: RETAIN },
+        {
+            action: 'create',
+            kind: 'CORS Origin',
+            name: `${options.studioName}-cors`,
+            detail: `for ${options.studioOrigin} on deploy`,
+        },
+        {
+            action: 'create',
+            kind: 'Studio',
+            name: options.studioName,
+            // The origin is on the CORS line directly above, so it is not repeated here.
+            detail: `from ${options.studioSource} on deploy`,
+        },
+    ];
+    if (options.functionName) {
+        resources.push({
+            action: 'create',
+            kind: 'Function',
+            name: options.functionName,
+            detail: 'on deploy',
+        });
+    }
+    return resources;
+}
+/** The counts `blueprints plan` will report for this Blueprint. */
+export function blueprintPreviewCounts(options) {
+    const resources = previewResources(options);
+    return {
+        attaches: resources.filter(({ action }) => action === 'attach').length,
+        creates: resources.filter(({ action }) => action === 'create').length,
+    };
+}
+/** Pads on the raw text, then styles, so colour codes never widen a column. */
+function actionLine(resource, pad) {
+    const { icon, color } = ACTION_STYLE[resource.action];
+    const gap = ' '.repeat(pad.name - resource.name.length + 2);
+    return [
+        `  ${styleText(['bold', color], icon)} `,
+        `${styleText(color, resource.action.padEnd(pad.action))} `,
+        `${resource.kind.padEnd(pad.kind)} `,
+        `${styleText('bold', resource.name)}${gap}`,
+        styleText('dim', resource.detail),
+    ].join('');
+}
+function columnWidths(resources) {
+    return {
+        action: Math.max(...resources.map(({ action }) => action.length)),
+        kind: Math.max(...resources.map(({ kind }) => kind.length)),
+        name: Math.max(...resources.map(({ name }) => name.length)),
+    };
+}
+export function printBlueprintPreview(options) {
+    const resources = previewResources(options);
+    const stack = {
+        action: 'create',
+        kind: 'Stack',
+        name: options.stackName,
+        detail: `in ${options.organizationName} (empty, organization scope)`,
+    };
+    // One set of widths across both blocks, so the two read as one table.
+    const pad = columnWidths([...resources, stack]);
+    options.log(styleText('bold', 'Blueprint plan:'));
+    for (const resource of resources)
+        options.log(actionLine(resource, pad));
+    options.log('');
+    options.log(styleText('bold', 'One remote change now:'));
+    options.log(actionLine(stack, pad));
+    options.log('');
+}
+/** Pads on the raw path, then styles, so colour codes never widen a column. */
+export function fileLines(lines) {
+    const width = Math.max(...lines.map(([, path]) => path.length));
+    return lines.map(([marker, path, description]) => {
+        const color = marker === '+' ? 'green' : 'yellow';
+        const head = `  ${styleText(['bold', color], marker)} ${styleText('bold', path)}`;
+        if (!description)
+            return head;
+        const gap = ' '.repeat(width - path.length + 3);
+        return `${head}${gap}${styleText('dim', description)}`;
+    });
+}

package/dist/cores/blueprinit/prompts.d.ts

@@ -0,0 +1,15 @@
+import { DEFAULT_STUDIO_NAME } from '../../actions/blueprinit/manifest.js';
+import type { BlueprinitFlags } from './types.js';
+export { DEFAULT_STUDIO_NAME };
+/**
+ * Resource names must be unique within a Blueprint, so report every name used twice.
+ *
+ * The generated names cannot collide with each other, because each one carries its
+ * resource type. A dataset name or a `--studio-name` value can still land on one.
+ */
+export declare function duplicateResourceNames(names: string[]): string[];
+export declare function confirmUnlessSkipped(flags: BlueprinitFlags, interactive: boolean, message: string): Promise<boolean>;
+/** The new Stack's name, which is also the hosted Studio slug. */
+export declare function promptForStackName(flags: BlueprinitFlags, interactive: boolean, defaultName: string): Promise<string>;
+/** The Blueprint-local Studio name, which is also its directory under `studios/`. */
+export declare function studioResourceName(flags: BlueprinitFlags): string;

package/dist/cores/blueprinit/prompts.js

@@ -0,0 +1,43 @@
+import { confirm, input } from '@inquirer/prompts';
+import { DEFAULT_STUDIO_NAME, slugify } from '../../actions/blueprinit/manifest.js';
+export { DEFAULT_STUDIO_NAME };
+/**
+ * Resource names must be unique within a Blueprint, so report every name used twice.
+ *
+ * The generated names cannot collide with each other, because each one carries its
+ * resource type. A dataset name or a `--studio-name` value can still land on one.
+ */
+export function duplicateResourceNames(names) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const name of names) {
+        if (seen.has(name))
+            duplicates.add(name);
+        else
+            seen.add(name);
+    }
+    return [...duplicates];
+}
+export async function confirmUnlessSkipped(flags, interactive, message) {
+    if (flags.yes || !interactive)
+        return true;
+    return await confirm({ message, default: true });
+}
+/** The new Stack's name, which is also the hosted Studio slug. */
+export async function promptForStackName(flags, interactive, defaultName) {
+    if (flags.stackName)
+        return slugify(flags.stackName) || defaultName;
+    if (flags.yes || !interactive)
+        return defaultName;
+    const answer = await input({
+        message: 'Name your Stack and hosted Studio?',
+        default: defaultName,
+    });
+    return slugify(answer) || defaultName;
+}
+/** The Blueprint-local Studio name, which is also its directory under `studios/`. */
+export function studioResourceName(flags) {
+    if (!flags.studioName)
+        return DEFAULT_STUDIO_NAME;
+    return slugify(flags.studioName) || DEFAULT_STUDIO_NAME;
+}

package/dist/cores/blueprinit/selection.d.ts

@@ -0,0 +1,15 @@
+import type { Dataset } from '../../actions/sanity/datasets.js';
+import type { GroupedProjects, Project } from '../../actions/sanity/projects.js';
+import type { Result } from '../../utils/types.js';
+interface SelectionError {
+    message: string;
+    suggestions?: string[];
+}
+export declare function chooseOrganization(groups: GroupedProjects[], organizationId: string | undefined, interactive: boolean): Promise<Result<GroupedProjects, SelectionError>>;
+export declare function chooseProject(projects: Project[], projectId: string | undefined, organizationName: string, interactive: boolean): Promise<Result<Project, SelectionError>>;
+export declare function chooseDataset(datasets: Dataset[], datasetName: string | undefined, projectName: string, interactive: boolean): Promise<Result<Dataset, SelectionError>>;
+export declare function findProject(groups: GroupedProjects[], projectId: string): {
+    organization: GroupedProjects['organization'];
+    project: Project;
+} | undefined;
+export {};