@sanity/runtime-cli 17.3.0-blueprinit.gb1c5e1e → 17.3.1

package/dist/actions/blueprinit/workspace.js

@@ -1,142 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, posix } from 'node:path';
-import { renderBlueprint, STARTER_FUNCTION_NAME } from './manifest.js';
-import { FUNCTION_SET_SLUG, functionPackageJson, renderStudioConfig, STUDIO_POST_TYPE, STUDIO_SCHEMA_TYPES, studioPackageJson, } from './templates.js';
-const GITIGNORE_ENTRY = '# Sanity Blueprints\n.sanity/';
-const DEFAULT_GITIGNORE = `node_modules
-.env
-
-${GITIGNORE_ENTRY}
-`;
-export function scaffoldWorkspace(options) {
-    const { dir, studioName } = options;
-    assertTargetsAvailable(dir, [
-        posix.join('studios', studioName),
-        posix.join('functions', STARTER_FUNCTION_NAME),
-    ]);
-    const packageJson = preparePackageJson(options, ['studios/*', 'functions/*']);
-    const files = [];
-    const write = createWriter(dir, files);
-    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({
-        ...manifestOptions(options),
-        studioSrc: `./studios/${studioName}`,
-        withFunction: true,
-    }));
-    write(posix.join('studios', studioName, 'package.json'), formatJson(studioPackageJson(studioName)));
-    write(posix.join('studios', studioName, 'sanity.config.ts'), renderStudioConfig(options));
-    write(posix.join('studios', studioName, 'schemaTypes', 'index.ts'), STUDIO_SCHEMA_TYPES);
-    write(posix.join('studios', studioName, 'schemaTypes', 'post.ts'), STUDIO_POST_TYPE);
-    write(posix.join('studios', studioName, 'static', '.gitkeep'), '');
-    write(posix.join('functions', STARTER_FUNCTION_NAME, 'package.json'), formatJson(functionPackageJson(STARTER_FUNCTION_NAME)));
-    write(posix.join('functions', STARTER_FUNCTION_NAME, 'index.ts'), FUNCTION_SET_SLUG);
-    writePreparedRootFiles(dir, packageJson, files);
-    return { blueprintFilePath, files };
-}
-export function adoptWorkspace(options) {
-    const { dir } = options;
-    const packageJson = preparePackageJson(options, []);
-    const files = [];
-    const write = createWriter(dir, files);
-    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({ ...manifestOptions(options), studioSrc: '.', withFunction: false }));
-    writePreparedRootFiles(dir, packageJson, files);
-    return { blueprintFilePath, files };
-}
-function manifestOptions(options) {
-    return {
-        projectName: options.stackName,
-        displayName: options.displayName,
-        projectId: options.projectId,
-        datasetName: options.datasetName,
-        studioName: options.studioName,
-    };
-}
-function assertTargetsAvailable(dir, paths) {
-    const conflicts = paths.filter((path) => existsSync(join(dir, path)));
-    if (conflicts.length > 0) {
-        throw new Error(`Refusing to overwrite existing paths: ${conflicts.join(', ')}`);
-    }
-}
-function createWriter(dir, files) {
-    return (relativePath, content) => {
-        const filePath = join(dir, relativePath);
-        mkdirSync(dirname(filePath), { recursive: true });
-        writeFileSync(filePath, content);
-        files.push(relativePath);
-        return filePath;
-    };
-}
-function writePreparedRootFiles(dir, packageJson, files) {
-    if (writeGitignore(dir))
-        files.push('.gitignore');
-    writeFileSync(join(dir, 'package.json'), formatJson(packageJson));
-    files.push('package.json');
-}
-function writeGitignore(dir) {
-    const filePath = join(dir, '.gitignore');
-    if (!existsSync(filePath)) {
-        writeFileSync(filePath, DEFAULT_GITIGNORE);
-        return true;
-    }
-    const existing = readFileSync(filePath, 'utf8');
-    if (existing.split(/\r?\n/).some((line) => line.trim() === '.sanity/'))
-        return false;
-    writeFileSync(filePath, `${existing.trimEnd()}\n\n${GITIGNORE_ENTRY}\n`);
-    return true;
-}
-function preparePackageJson(options, requiredWorkspaces) {
-    const filePath = join(options.dir, 'package.json');
-    const parsed = existsSync(filePath)
-        ? JSON.parse(readFileSync(filePath, 'utf8'))
-        : {
-            name: options.stackName,
-            version: '0.1.0',
-            private: true,
-            type: 'module',
-        };
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error('The existing package.json must contain a JSON object.');
-    }
-    const packageJson = parsed;
-    addWorkspaces(packageJson, requiredWorkspaces);
-    addBlueprintsDependency(packageJson, options.blueprintsVersion);
-    return packageJson;
-}
-function addWorkspaces(packageJson, required) {
-    if (required.length === 0)
-        return;
-    if (!packageJson.workspaces) {
-        packageJson.workspaces = required;
-        return;
-    }
-    if (Array.isArray(packageJson.workspaces)) {
-        packageJson.workspaces = [...new Set([...packageJson.workspaces, ...required])];
-        return;
-    }
-    if (!packageJson.workspaces || typeof packageJson.workspaces !== 'object') {
-        throw new Error('Cannot add generated packages to the existing package.json workspaces.');
-    }
-    const workspaces = packageJson.workspaces;
-    if (Array.isArray(workspaces.packages)) {
-        workspaces.packages = [...new Set([...workspaces.packages, ...required])];
-        return;
-    }
-    throw new Error('Cannot add generated packages to the existing package.json workspaces.');
-}
-function addBlueprintsDependency(packageJson, blueprintsVersion) {
-    const dependencies = recordOrEmpty(packageJson.dependencies);
-    const devDependencies = recordOrEmpty(packageJson.devDependencies);
-    if (dependencies['@sanity/blueprints'] || devDependencies['@sanity/blueprints'])
-        return;
-    packageJson.devDependencies = {
-        ...devDependencies,
-        '@sanity/blueprints': blueprintsVersion,
-    };
-}
-function recordOrEmpty(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function formatJson(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}

package/dist/actions/sanity/datasets.d.ts

@@ -1,15 +0,0 @@
-import type { Logger } from '../../utils/logger.js';
-import type { ActionResponse } from '../../utils/types.js';
-export interface Dataset {
-    name: string;
-    aclMode: string;
-}
-interface ListDatasetsResponse extends ActionResponse {
-    datasets: Dataset[];
-}
-export declare function listDatasets({ token, projectId, logger, }: {
-    token: string;
-    projectId: string;
-    logger: Logger;
-}): Promise<ListDatasetsResponse>;
-export {};

package/dist/actions/sanity/datasets.js

@@ -1,26 +0,0 @@
-import { createTracedFetch } from '../../utils/traced-fetch.js';
-import { projectsApiPath } from './projects.js';
-export async function listDatasets({ token, projectId, logger, }) {
-    const fetchFn = createTracedFetch(logger);
-    const url = `${projectsApiPath}/${encodeURIComponent(projectId)}/datasets`;
-    const response = await fetchFn(url, {
-        method: 'GET',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-        },
-    });
-    const body = await response.json();
-    if (!response.ok) {
-        return {
-            ok: false,
-            error: body.error?.message ?? response.statusText,
-            datasets: [],
-        };
-    }
-    return {
-        ok: true,
-        error: null,
-        datasets: body,
-    };
-}

package/dist/commands/blueprinit.d.ts

@@ -1,14 +0,0 @@
-import { RuntimeCommand } from '../baseCommands.js';
-export default class BlueprinitCommand extends RuntimeCommand<typeof BlueprinitCommand> {
-    static hidden: boolean;
-    static summary: string;
-    static description: string;
-    static examples: string[];
-    static flags: {
-        llms: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<Record<string, unknown> | undefined>;
-}

package/dist/commands/blueprinit.js

@@ -1,46 +0,0 @@
-import { 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 { Logger } from '../utils/logger.js';
-export default class BlueprinitCommand extends RuntimeCommand {
-    static hidden = true;
-    static summary = 'Experimental blueprints-first project init';
-    static description = `Scaffolds a Blueprint, Studio, and starter function around an existing Sanity project.
-
-This hidden command is an experiment; its interface and generated files are not stable.`;
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --yes',
-    ];
-    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'],
-        }),
-    };
-    async run() {
-        const result = await blueprinitCore({
-            bin: this.config.bin,
-            log: Logger(this.log.bind(this), this.flags),
-            flags: {
-                yes: this.flags.yes,
-                organizationId: this.flags['organization-id'],
-                projectId: this.flags['project-id'],
-            },
-        });
-        if (!result.success)
-            this.coreError(result);
-        return result.json;
-    }
-}

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

@@ -1,6 +0,0 @@
-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

@@ -1,90 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { slugify } 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 { getLatestNpmVersion } from '../../utils/external/npmjs.js';
-import { isInteractive } from '../../utils/interactive.js';
-import { createStackAndFinish } from './finish.js';
-import { confirmUnlessSkipped, promptForStudioName } from './prompts.js';
-import { findProject } from './selection.js';
-export async function adoptFlow(options) {
-    const { bin, dir, flags, log, studio, token } = options;
-    if (!studio.projectId || !studio.dataset) {
-        return {
-            success: false,
-            error: `Found ${studio.configFile}, but could not read a projectId and dataset from it.`,
-            suggestions: ['Use literal projectId and dataset values in the Studio config.'],
-        };
-    }
-    if (flags.projectId && flags.projectId !== studio.projectId) {
-        return { success: false, error: `The Studio uses project "${studio.projectId}".` };
-    }
-    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, studio.projectId);
-    if (!match) {
-        return {
-            success: false,
-            error: `Project "${studio.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 === studio.dataset)) {
-        return {
-            success: false,
-            error: `Dataset "${studio.dataset}" was not found in project ${match.project.displayName}.`,
-        };
-    }
-    log(check(`Matches project ${match.project.displayName} (${match.project.id}), dataset ${studio.dataset}`));
-    log('');
-    const confirmed = await confirmUnlessSkipped(flags, isInteractive, 'Adopt this Studio into a Blueprint?');
-    if (!confirmed)
-        return { success: false, error: 'Initialization cancelled.' };
-    const studioName = await promptForStudioName(flags, isInteractive);
-    const stackName = slugify(match.project.displayName) || match.project.id;
-    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
-    log('Changes:');
-    log("  + sanity.blueprint.ts             attach project + dataset; adopt Studio at '.'");
-    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
-    log(`  ${marker('.gitignore')} .gitignore`);
-    log(`  ${marker('package.json')} package.json`);
-    log('');
-    const adoption = adoptWorkspace({
-        dir,
-        projectId: match.project.id,
-        displayName: match.project.displayName,
-        datasetName: studio.dataset,
-        stackName,
-        studioName,
-        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
-    });
-    return await createStackAndFinish({
-        ...options,
-        organizationId: match.organization.id,
-        projectId: match.project.id,
-        datasetName: studio.dataset,
-        stackName,
-        blueprintFilePath: adoption.blueprintFilePath,
-        files: adoption.files,
-        nextSteps: [
-            `  npx ${bin} blueprints plan`,
-            `  npx ${bin} blueprints deploy`,
-            `  npx ${bin} blueprints info`,
-        ],
-    });
-}

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

@@ -1,14 +0,0 @@
-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>;
-export declare function alignSteps(steps: Array<[command: string, description?: string]>): string[];
-export {};

package/dist/cores/blueprinit/finish.js

@@ -1,36 +0,0 @@
-import { writeConfigFile } from '../../actions/blueprints/config.js';
-import { createEmptyStack } from '../../actions/blueprints/stacks.js';
-import { check } from '../../utils/display/presenters.js';
-export async function createStackAndFinish(options) {
-    const stack = await createEmptyStack({
-        token: options.token,
-        scopeType: 'organization',
-        scopeId: options.organizationId,
-        name: options.stackName,
-        logger: options.log,
-    });
-    writeConfigFile(options.blueprintFilePath, {
-        organizationId: options.organizationId,
-        stackId: stack.id,
-    });
-    options.log(check(`Stack ${stack.name} created (org scope)`));
-    options.log('');
-    options.log('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'],
-        },
-    };
-}
-export function alignSteps(steps) {
-    const width = Math.max(...steps.map(([command]) => command.length));
-    return steps.map(([command, description]) => description ? `  ${command.padEnd(width + 2)}${description}` : `  ${command}`);
-}

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

@@ -1,3 +0,0 @@
-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

@@ -1,88 +0,0 @@
-import { STARTER_FUNCTION_NAME, slugify } 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 { getLatestNpmVersion } from '../../utils/external/npmjs.js';
-import { isInteractive } from '../../utils/interactive.js';
-import { alignSteps, createStackAndFinish } from './finish.js';
-import { confirmUnlessSkipped, promptForStudioName } from './prompts.js';
-import { chooseDataset, chooseOrganization, chooseProject } from './selection.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 dataset = chooseDataset(datasets.datasets);
-    if (!dataset)
-        return { success: false, error: `No datasets found in ${project.displayName}.` };
-    log(check(`Org: ${organization.name} (${organization.id})`));
-    log(check(`Project: ${project.displayName} (${project.id}), dataset: ${dataset.name}`));
-    log('');
-    const confirmed = await confirmUnlessSkipped(flags, isInteractive, `Set up this directory as the workspace for "${project.displayName}"?`);
-    if (!confirmed)
-        return { success: false, error: 'Initialization cancelled.' };
-    const stackName = slugify(project.displayName) || project.id;
-    const studioName = await promptForStudioName(flags, isInteractive);
-    log('Files to write:');
-    log('  + sanity.blueprint.ts             project + dataset (attached), studio, function');
-    log(`  + ${`studios/${studioName}/`.padEnd(32)}Studio with a "post" type`);
-    log(`  + ${`functions/${STARTER_FUNCTION_NAME}/`.padEnd(32)}sets a post slug from its title`);
-    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
-    log('  + .gitignore');
-    log('  + package.json');
-    log('');
-    const scaffold = scaffoldWorkspace({
-        dir,
-        projectId: project.id,
-        displayName: project.displayName,
-        datasetName: dataset.name,
-        stackName,
-        studioName,
-        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
-    });
-    return await createStackAndFinish({
-        ...options,
-        organizationId: organization.id,
-        projectId: project.id,
-        datasetName: dataset.name,
-        stackName,
-        blueprintFilePath: scaffold.blueprintFilePath,
-        files: scaffold.files,
-        nextSteps: [
-            ...alignSteps([
-                ['npm install'],
-                [`npm run dev -w studios/${studioName}`, 'open the Studio and add a post'],
-                [`npx ${bin} blueprints plan`, 'preview the deployment'],
-                [`npx ${bin} blueprints deploy`, 'deploy the resources'],
-            ]),
-            '',
-            'Test the function on that post:',
-            `  npx ${bin} functions test ${STARTER_FUNCTION_NAME} --document-id <id>` +
-                ` --project-id ${project.id} --dataset ${dataset.name} --with-user-token`,
-        ],
-    });
-}

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

@@ -1,4 +0,0 @@
-import type { BlueprinitFlags } from './types.js';
-export declare const DEFAULT_STUDIO_NAME = "studio";
-export declare function confirmUnlessSkipped(flags: BlueprinitFlags, interactive: boolean, message: string): Promise<boolean>;
-export declare function promptForStudioName(flags: BlueprinitFlags, interactive: boolean): Promise<string>;

package/dist/cores/blueprinit/prompts.js

@@ -1,14 +0,0 @@
-import { confirm, input } from '@inquirer/prompts';
-import { slugify } from '../../actions/blueprinit/manifest.js';
-export const DEFAULT_STUDIO_NAME = 'studio';
-export async function confirmUnlessSkipped(flags, interactive, message) {
-    if (flags.yes || !interactive)
-        return true;
-    return await confirm({ message, default: true });
-}
-export async function promptForStudioName(flags, interactive) {
-    if (flags.yes || !interactive)
-        return DEFAULT_STUDIO_NAME;
-    const answer = await input({ message: 'Name your studio?', default: DEFAULT_STUDIO_NAME });
-    return slugify(answer) || DEFAULT_STUDIO_NAME;
-}

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

@@ -1,15 +0,0 @@
-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[]): Dataset | undefined;
-export declare function findProject(groups: GroupedProjects[], projectId: string): {
-    organization: GroupedProjects['organization'];
-    project: Project;
-} | undefined;
-export {};

package/dist/cores/blueprinit/selection.js

@@ -1,63 +0,0 @@
-import { select } from '@inquirer/prompts';
-export async function chooseOrganization(groups, organizationId, interactive) {
-    if (groups.length === 0) {
-        return failure('No organizations found for this account.');
-    }
-    if (organizationId) {
-        const organization = groups.find((group) => group.organization.id === organizationId);
-        return organization
-            ? { ok: true, value: organization }
-            : failure(`No organization "${organizationId}" found for this account.`);
-    }
-    if (groups.length === 1)
-        return { ok: true, value: groups[0] };
-    if (!interactive) {
-        return failure('Multiple organizations found.', ['Pass --organization-id <id> to choose one.']);
-    }
-    const selectedId = await select({
-        message: 'Choose a Sanity organization:',
-        choices: groups.map(({ organization, projects }) => ({
-            name: organization.name,
-            value: organization.id,
-            description: `${projects?.length ?? 0} projects`,
-        })),
-    });
-    const selected = groups.find(({ organization }) => organization.id === selectedId);
-    return selected ? { ok: true, value: selected } : failure('Organization not found.');
-}
-export async function chooseProject(projects, projectId, organizationName, interactive) {
-    if (projects.length === 0) {
-        return failure(`No projects found in ${organizationName}.`);
-    }
-    if (projectId) {
-        const project = projects.find(({ id }) => id === projectId);
-        return project
-            ? { ok: true, value: project }
-            : failure(`No project "${projectId}" found in ${organizationName}.`);
-    }
-    if (projects.length === 1)
-        return { ok: true, value: projects[0] };
-    if (!interactive) {
-        return failure('Multiple projects found.', ['Pass --project-id <id> to choose one.']);
-    }
-    const selectedId = await select({
-        message: 'Choose a Sanity project:',
-        choices: projects.map((project) => ({ name: project.displayName, value: project.id })),
-    });
-    const selected = projects.find(({ id }) => id === selectedId);
-    return selected ? { ok: true, value: selected } : failure('Project not found.');
-}
-export function chooseDataset(datasets) {
-    return datasets.find(({ name }) => name === 'production') ?? datasets[0];
-}
-export function findProject(groups, projectId) {
-    for (const { organization, projects = [] } of groups) {
-        const project = projects.find(({ id }) => id === projectId);
-        if (project)
-            return { organization, project };
-    }
-    return undefined;
-}
-function failure(message, suggestions) {
-    return { ok: false, error: { message, suggestions } };
-}

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

@@ -1,13 +0,0 @@
-import type { Logger } from '../../utils/logger.js';
-export interface BlueprinitFlags {
-    yes?: boolean;
-    organizationId?: string;
-    projectId?: string;
-}
-export interface BlueprinitFlowOptions {
-    bin: string;
-    dir: string;
-    flags: BlueprinitFlags;
-    log: Logger;
-    token: string;
-}

package/dist/cores/blueprinit/types.js

@@ -1 +0,0 @@
-export {};

package/dist/cores/blueprinit.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,39 +0,0 @@
-import { cwd } from 'node:process';
-import { detectStudio } from '../actions/blueprinit/studio.js';
-import { findBlueprintFile } from '../actions/blueprints/blueprint.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 {
-        const existingBlueprint = findBlueprintFile(dir);
-        if (existingBlueprint) {
-            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 blueprinit again.'],
-            };
-        }
-        log('Setting up your Sanity workspace.');
-        log('');
-        const flowOptions = { bin, 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) };
-    }
-}