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

package/dist/commands/init.js

@@ -0,0 +1,82 @@
+import { resolve } from 'node:path';
+import { Args, Flags } from '@oclif/core';
+import { llmsFlagConfig } from '@sanity-labs/oclif-plugin-skills-flag';
+import { RuntimeCommand } from '../baseCommands.js';
+import { blueprinitCore } from '../cores/blueprinit.js';
+import { playIntro } from '../utils/display/intro.js';
+import { Logger } from '../utils/logger.js';
+export default class InitCommand extends RuntimeCommand {
+    static hidden = true;
+    static summary = 'Experimental blueprints-first project init';
+    static description = `Scaffolds a Blueprint, Studio, and starter function around a Sanity project.
+
+Use a project you already have, or create one with --create-project. A new project has no
+datasets, so the Blueprint creates the dataset rather than attaching it.
+
+Pass a directory to scaffold into it. Without one, an interactive run asks where the files go.
+
+This hidden command is an experiment; its interface and generated files are not stable.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> ./my-workspace',
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --yes',
+        '<%= config.bin %> <%= command.id %> --create-project "My Shop" --yes',
+    ];
+    static args = {
+        directory: Args.string({
+            description: 'Directory to initialize. Interactive runs are asked for one instead.',
+            required: false,
+        }),
+    };
+    static flags = {
+        llms: Flags.boolean(llmsFlagConfig),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts',
+            default: false,
+        }),
+        'organization-id': Flags.string({
+            description: 'Organization to use when the account has several',
+            aliases: ['organization', 'organizationId', 'org'],
+        }),
+        'project-id': Flags.string({
+            description: 'Project to use when the organization has several',
+            aliases: ['project', 'projectId'],
+        }),
+        'create-project': Flags.string({
+            description: 'Create a project with this display name instead of using an existing one',
+            aliases: ['createProject', 'new-project'],
+            exclusive: ['project-id'],
+        }),
+        dataset: Flags.string({
+            description: 'Dataset to attach, or to create alongside a new project',
+        }),
+        'stack-name': Flags.string({
+            description: 'Name for the new organization-scoped Stack, and the hosted Studio slug',
+        }),
+        'studio-name': Flags.string({
+            description: 'Blueprint-local name for the Studio resource and its directory',
+        }),
+    };
+    async run() {
+        await playIntro({ json: this.jsonEnabled() });
+        const result = await blueprinitCore({
+            bin: this.config.bin,
+            dir: this.args.directory ? resolve(this.args.directory) : undefined,
+            log: Logger(this.log.bind(this), this.flags),
+            flags: {
+                yes: this.flags.yes,
+                organizationId: this.flags['organization-id'],
+                projectId: this.flags['project-id'],
+                createProject: this.flags['create-project'],
+                datasetName: this.flags.dataset,
+                stackName: this.flags['stack-name'],
+                studioName: this.flags['studio-name'],
+            },
+        });
+        if (!result.success)
+            this.coreError(result);
+        return result.json;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { DetectedStudio } from '../../actions/blueprinit/studio.js';
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function adoptFlow(options: BlueprinitFlowOptions & {
+    studio: DetectedStudio;
+}): Promise<CoreResult>;

package/dist/cores/blueprinit/adopt.js

@@ -0,0 +1,137 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { corsResourceName, projectBaseName, projectResourceName, } from '../../actions/blueprinit/manifest.js';
+import { getLatestNpmRange } from '../../actions/blueprinit/versions.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 { isInteractive } from '../../utils/interactive.js';
+import { styleText } from '../../utils/style-text.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { chooseNames } from './naming.js';
+import { fileLines, printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, studioResourceName } from './prompts.js';
+import { coreFailure } from './results.js';
+import { findProject } from './selection.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);
+    const names = await chooseNames({
+        flags,
+        log,
+        token,
+        organizationId: match.organization.id,
+        baseName,
+        datasetName,
+        resourceNames: [projectName, datasetName, corsResourceName(studioName), studioName],
+    });
+    if (!names.ok)
+        return coreFailure(names.error);
+    const { stackName, studioOrigin } = names.value;
+    // Started before the preview so the lookup overlaps the time the reader spends on it.
+    const blueprintsVersion = getLatestNpmRange('@sanity/blueprints', log);
+    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
+    const { attaches, creates } = printBlueprintPreview({
+        log,
+        organizationName: match.organization.name,
+        projectId: match.project.id,
+        projectName: match.project.displayName,
+        datasetName,
+        datasetAction: 'attach',
+        studioName,
+        studioOrigin,
+        studioSource: '.',
+        stackName,
+    });
+    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 blueprintsVersion,
+    });
+    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/columns.d.ts

@@ -0,0 +1,26 @@
+import { styleText } from '../../utils/style-text.js';
+type TextStyle = Parameters<typeof styleText>[0];
+/**
+ * One cell in an aligned row.
+ *
+ * `text` is the raw string. It sets the column width and is styled only after padding,
+ * so a colour code can never widen a column.
+ */
+export interface Cell {
+    text: string;
+    style?: TextStyle;
+    /**
+     * Spaces between this column and the next, beyond the padding. Defaults to 1.
+     *
+     * A gap is a property of the column, so one row may set it for every row.
+     */
+    gap?: number;
+}
+/**
+ * Render rows as columns of one shared width, then style each cell.
+ *
+ * The last cell in a row is never padded, so a row that stops early prints no trailing
+ * space. Pass every row that should line up in one call.
+ */
+export declare function renderRows(rows: Cell[][]): string[];
+export {};

package/dist/cores/blueprinit/columns.js

@@ -0,0 +1,27 @@
+import { styleText } from '../../utils/style-text.js';
+const INDENT = '  ';
+/**
+ * Render rows as columns of one shared width, then style each cell.
+ *
+ * The last cell in a row is never padded, so a row that stops early prints no trailing
+ * space. Pass every row that should line up in one call.
+ */
+export function renderRows(rows) {
+    const widths = [];
+    const gaps = [];
+    for (const row of rows) {
+        row.forEach((cell, index) => {
+            widths[index] = Math.max(widths[index] ?? 0, cell.text.length);
+            gaps[index] = Math.max(gaps[index] ?? 1, cell.gap ?? 1);
+        });
+    }
+    return rows.map((row) => {
+        const cells = row.map((cell, index) => {
+            const styled = cell.style ? styleText(cell.style, cell.text) : cell.text;
+            if (index === row.length - 1)
+                return styled;
+            return styled + ' '.repeat(widths[index] - cell.text.length + gaps[index]);
+        });
+        return INDENT + cells.join('');
+    });
+}

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>;
+/** A command to run next, and what it does. */
+export declare function alignSteps(steps: Array<[command: string, description?: string]>): string[];
+export {};

package/dist/cores/blueprinit/finish.js

@@ -0,0 +1,72 @@
+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';
+import { renderRows } from './columns.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'],
+        },
+    };
+}
+/** A command to run next, and what it does. */
+export function alignSteps(steps) {
+    return renderRows(steps.map(([command, description]) => {
+        const cells = [{ text: command, style: 'cyan', gap: 2 }];
+        if (description)
+            cells.push({ text: description, style: 'dim' });
+        return cells;
+    }));
+}

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,219 @@
+import { mkdirSync } from 'node:fs';
+import { corsResourceName, projectBaseName, projectResourceName, STARTER_FUNCTION_NAME, studioSourcePath, } from '../../actions/blueprinit/manifest.js';
+import { getLatestNpmRange } from '../../actions/blueprinit/versions.js';
+import { scaffoldWorkspace } from '../../actions/blueprinit/workspace.js';
+import { createProject } from '../../actions/sanity/create-project.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { styleText } from '../../utils/style-text.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { chooseNames } from './naming.js';
+import { fileLines, printBlueprintPreview } from './preview.js';
+import { chooseProjectSource } from './project-choice.js';
+import { confirmUnlessSkipped, studioResourceName } from './prompts.js';
+import { coreFailure } from './results.js';
+import { chooseDataset, chooseOrganization, chooseProject } from './selection.js';
+import { promptForTargetDirectory, relativeTargetPath, resolveTargetDirectory } from './target.js';
+/**
+ * Registry versions for the files this flow writes.
+ *
+ * Started before the preview so the lookups overlap the time the reader spends on it.
+ * `getLatestNpmRange` answers `latest` rather than rejecting, so nothing awaits an error.
+ */
+function scaffoldVersions(log) {
+    return Promise.all([
+        getLatestNpmRange('@sanity/blueprints', log),
+        getLatestNpmRange('sanity', log),
+        getLatestNpmRange('@sanity/vision', log),
+    ]);
+}
+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 coreFailure(organizationResult.error);
+    const { organization, projects = [] } = organizationResult.value;
+    const sourceResult = await chooseProjectSource({
+        flags,
+        interactive: isInteractive,
+        projects,
+        organizationName: organization.name,
+    });
+    if (!sourceResult.ok)
+        return coreFailure(sourceResult.error);
+    const source = sourceResult.value;
+    // A project this run creates has no ID yet, and no datasets to list or choose.
+    const selected = source.create
+        ? { displayName: source.displayName, projectId: undefined, datasetName: source.datasetName }
+        : await selectExistingProject({ ...options, projects, organizationName: organization.name });
+    if ('error' in selected)
+        return coreFailure(selected.error);
+    const datasetAction = source.create ? 'create' : 'attach';
+    log(check(`Org: ${organization.name} (${organization.id})`));
+    log(check(source.create
+        ? `New project: ${selected.displayName}, dataset: ${selected.datasetName} (both made for you)`
+        : `Project: ${selected.displayName} (${selected.projectId}), dataset: ${selected.datasetName}`));
+    log('');
+    const baseName = projectBaseName(selected.displayName, selected.projectId ?? organization.id);
+    const projectName = projectResourceName(baseName);
+    const studioName = studioResourceName(flags);
+    const studioSource = studioSourcePath(studioName);
+    const target = options.targetProvided
+        ? { ok: true, value: dir }
+        : resolveTargetDirectory(dir, await promptForTargetDirectory(dir, baseName, isInteractive && !flags.yes), bin);
+    if (!target.ok)
+        return coreFailure(target.error);
+    const targetDir = target.value;
+    const names = await chooseNames({
+        flags,
+        log,
+        token,
+        organizationId: organization.id,
+        baseName,
+        datasetName: selected.datasetName,
+        resourceNames: [
+            projectName,
+            selected.datasetName,
+            corsResourceName(studioName),
+            studioName,
+            STARTER_FUNCTION_NAME,
+        ],
+    });
+    if (!names.ok)
+        return coreFailure(names.error);
+    const { stackName, studioOrigin } = names.value;
+    const versions = scaffoldVersions(log);
+    const { attaches, creates } = printBlueprintPreview({
+        log,
+        organizationName: organization.name,
+        projectId: selected.projectId,
+        projectName: selected.displayName,
+        datasetName: selected.datasetName,
+        datasetAction,
+        createsProject: source.create,
+        studioName,
+        studioOrigin,
+        studioSource,
+        stackName,
+        functionName: STARTER_FUNCTION_NAME,
+    });
+    log(styleText('bold', 'Files to write:'));
+    for (const line of fileLines([
+        ['+', 'sanity.blueprint.ts', 'project + dataset, CORS, studio, function'],
+        ['+', `${studioSource}/`, '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 "${selected.displayName}"?`);
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    // Created after the confirmation, so a cancelled run leaves no project behind.
+    let projectId = selected.projectId;
+    if (!projectId) {
+        const created = await createProject({
+            token,
+            organizationId: organization.id,
+            displayName: selected.displayName,
+            logger: log,
+        });
+        if (!created.ok || !created.project?.id) {
+            return {
+                success: false,
+                error: `Could not create project "${selected.displayName}": ${created.error}`,
+                suggestions: ['Nothing was written. Run init again, or pass --project-id to use another.'],
+            };
+        }
+        projectId = created.project.id;
+        log('');
+        log(check(`Project ${styleText('bold', selected.displayName)} created (${projectId})`));
+    }
+    const relativeDir = relativeTargetPath(targetDir);
+    const [blueprintsVersion, sanityVersion, visionVersion] = await versions;
+    mkdirSync(targetDir, { recursive: true });
+    const scaffold = scaffoldWorkspace({
+        dir: targetDir,
+        projectId,
+        displayName: selected.displayName,
+        datasetName: selected.datasetName,
+        datasetAction,
+        stackName,
+        projectName,
+        studioName,
+        studioSlug: stackName,
+        studioOrigin,
+        blueprintsVersion,
+        studioVersions: { sanity: sanityVersion, vision: visionVersion },
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: organization.id,
+        projectId,
+        datasetName: selected.datasetName,
+        stackName,
+        blueprintFilePath: scaffold.blueprintFilePath,
+        files: scaffold.files,
+        nextSteps: [
+            ...alignSteps([
+                ...(relativeDir ? [[`cd ${relativeDir}`]] : []),
+                ['npm install'],
+                // The dataset does not exist until deploy, so a created one is deployed before
+                // `sanity dev` opens a Studio that would query it.
+                ...(datasetAction === 'create'
+                    ? [
+                        [
+                            `npx ${bin} blueprints plan`,
+                            `preview the ${attaches} attaches and ${creates} creates`,
+                        ],
+                        [`npx ${bin} blueprints deploy`, `create ${selected.datasetName} and the rest`],
+                        [`npm run dev -w ${studioSource}`, 'open the Studio and add a post'],
+                    ]
+                    : [
+                        [`npm run dev -w ${studioSource}`, '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 ${projectId} --dataset ${selected.datasetName} --with-user-token`,
+            `  npx ${bin} functions logs ${STARTER_FUNCTION_NAME}`,
+        ],
+    });
+}
+/** The existing-project path: pick a project, then pick one of its datasets. */
+async function selectExistingProject(options) {
+    const { flags, log, token, organizationName } = options;
+    const projectResult = await chooseProject(options.projects ?? [], flags.projectId, organizationName, isInteractive);
+    if (!projectResult.ok)
+        return { error: projectResult.error };
+    const project = projectResult.value;
+    const datasets = await listDatasets({ token, projectId: project.id, logger: log });
+    if (!datasets.ok)
+        return { error: { message: `Could not list datasets: ${datasets.error}` } };
+    const datasetResult = await chooseDataset(datasets.datasets, flags.datasetName, project.displayName, isInteractive);
+    if (!datasetResult.ok)
+        return { error: datasetResult.error };
+    return {
+        displayName: project.displayName,
+        projectId: project.id,
+        datasetName: datasetResult.value.name,
+    };
+}

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

@@ -0,0 +1,27 @@
+import type { Logger } from '../../utils/logger.js';
+import type { Result } from '../../utils/types.js';
+import type { FlowError } from './results.js';
+import type { BlueprinitFlags } from './types.js';
+export interface ChooseNamesOptions {
+    flags: BlueprinitFlags;
+    log: Logger;
+    token: string;
+    organizationId: string;
+    /** The slug form of the project display name, which both defaults are built from. */
+    baseName: string;
+    datasetName: string;
+    /** Every Blueprint-local resource name this flow will write. */
+    resourceNames: string[];
+}
+export interface ChosenNames {
+    stackName: string;
+    studioOrigin: string;
+}
+/**
+ * The two names a flow must settle before it previews anything.
+ *
+ * The Stack name is also the hosted Studio slug, so one answer names both, and the origin
+ * follows from it. Resource names are checked afterwards, because a repeated name writes
+ * a manifest that cannot deploy.
+ */
+export declare function chooseNames(options: ChooseNamesOptions): Promise<Result<ChosenNames, FlowError>>;

package/dist/cores/blueprinit/naming.js

@@ -0,0 +1,43 @@
+import { env } from 'node:process';
+import { defaultStackName, hostedStudioOrigin } from '../../actions/blueprinit/manifest.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { duplicateResourceNames } from './prompts.js';
+import { chooseStackName, takenStackNames } from './stack-name.js';
+/**
+ * The two names a flow must settle before it previews anything.
+ *
+ * The Stack name is also the hosted Studio slug, so one answer names both, and the origin
+ * follows from it. Resource names are checked afterwards, because a repeated name writes
+ * a manifest that cannot deploy.
+ */
+export async function chooseNames(options) {
+    const { flags, log, token, organizationId, baseName, datasetName, resourceNames } = options;
+    const stackNameResult = await chooseStackName({
+        flags,
+        interactive: isInteractive,
+        defaultName: defaultStackName(baseName, datasetName),
+        taken: await takenStackNames({ token, organizationId, log }),
+        log,
+    });
+    if (!stackNameResult.ok) {
+        return {
+            ok: false,
+            error: { message: stackNameResult.error, suggestions: stackNameResult.suggestions },
+        };
+    }
+    const duplicates = duplicateResourceNames(resourceNames);
+    if (duplicates.length > 0) {
+        return {
+            ok: false,
+            error: {
+                message: `Blueprint resource names must be unique. Used twice: ${duplicates.join(', ')}.`,
+                suggestions: ['Pass --studio-name with a different value.'],
+            },
+        };
+    }
+    const stackName = stackNameResult.value;
+    return {
+        ok: true,
+        value: { stackName, studioOrigin: hostedStudioOrigin(stackName, env.SANITY_INTERNAL_ENV) },
+    };
+}