@sanity/runtime-cli 17.5.0 → 17.6.0-blueprinit.g77b7a64

package/dist/actions/blueprints/resources.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { cwd } from 'node:process';
-import { MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
+import { MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
 import { styleText } from '../../utils/style-text.js';
 import { writeOrUpdateNodeDependency } from '../node.js';
 import { addResourceToBlueprint } from './blueprint.js';
@@ -36,6 +36,12 @@ export const handler = syncTagInvalidateEventHandler(async ({ context, event, do
     console.error('Error invoking Sanity invalidation done endpoint!', e)
   }
 })`;
+const DEFAULT_PUBSUB_HELPER_FUNCTION_TEMPLATE = /*ts*/ `import { pubSubEventHandler } from '@sanity/functions'
+
+export const handler = pubSubEventHandler(async ({ context, event }) => {
+  const time = new Date().toLocaleTimeString()
+  console.log(\`Your pubsub Sanity Function was called at \${time}\`)
+})`;
 /**
  * Creates a new function resource file and adds it to the blueprint
  */
@@ -68,6 +74,9 @@ export async function createFunctionResource(options, logger) {
     let template = DEFAULT_FUNCTION_TEMPLATE;
     if (addHelpers) {
         switch (functionType) {
+            case SANITY_FUNCTION_PUBSUB:
+                template = DEFAULT_PUBSUB_HELPER_FUNCTION_TEMPLATE;
+                break;
             case SANITY_FUNCTION_SCHEDULED:
                 template = DEFAULT_SCHEDULED_HELPER_FUNCTION_TEMPLATE;
                 break;
@@ -119,6 +128,13 @@ export async function createFunctionResource(options, logger) {
                 },
             };
             break;
+        case SANITY_FUNCTION_PUBSUB:
+            resourceJson = {
+                name,
+                src: `functions/${name}`,
+                type: SANITY_FUNCTION_PUBSUB,
+            };
+            break;
         case SANITY_FUNCTION_SCHEDULED:
             resourceJson = {
                 name,

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

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

@@ -0,0 +1,26 @@
+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/init.d.ts

@@ -0,0 +1,17 @@
+import { RuntimeCommand } from '../baseCommands.js';
+export default class InitCommand extends RuntimeCommand<typeof InitCommand> {
+    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>;
+        dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'studio-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Record<string, unknown> | undefined>;
+}

package/dist/commands/init.js

@@ -0,0 +1,59 @@
+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 InitCommand 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',
+        '<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --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'],
+        }),
+        dataset: Flags.string({
+            description: 'Dataset to attach',
+        }),
+        'stack-name': Flags.string({
+            description: 'Name for the new organization-scoped Stack',
+        }),
+        'studio-name': Flags.string({
+            description: 'Name and hosted slug for the Studio resource',
+        }),
+    };
+    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'],
+                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/constants.d.ts

@@ -3,8 +3,10 @@ export declare const SANITY_ACCESS_ROBOT = "sanity.access.robot";
 export declare const SANITY_FUNCTION_PREFIX = "sanity.function.";
 export declare const SANITY_FUNCTION_DOCUMENT = "sanity.function.document";
 export declare const SANITY_FUNCTION_MEDIA_LIBRARY_ASSET = "sanity.function.media-library.asset";
+export declare const SANITY_FUNCTION_PUBSUB = "sanity.function.pubsub";
 export declare const SANITY_FUNCTION_SCHEDULED = "sanity.function.cron";
 export declare const SANITY_FUNCTION_SYNC_TAG_INVALIDATE = "sanity.function.sync-tag-invalidate";
+export declare const SANITY_FUNCTION_DURABLE = "sanity.function.durable";
 export declare const SANITY_PROJECT = "sanity.project";
 export declare const SANITY_PROJECT_CORS = "sanity.project.cors";
 export declare const SANITY_PROJECT_DATASET = "sanity.project.dataset";
@@ -17,6 +19,7 @@ export declare const EVENT_DOCUMENT_DELETE = "document-delete";
 export declare const EVENT_MEDIA_LIBRARY_ASSET_CREATE = "media-library-asset-create";
 export declare const EVENT_MEDIA_LIBRARY_ASSET_UPDATE = "media-library-asset-update";
 export declare const EVENT_MEDIA_LIBRARY_ASSET_DELETE = "media-library-asset-delete";
+export declare const EVENT_PUBSUB = "pub-sub";
 export declare const EVENT_SCHEDULED = "scheduled-function";
 export declare const EVENT_SYNC_TAG_INVALIDATE = "sync-tag-invalidate";
 export declare const MAP_EVENT_TO_FUNCTION_TYPE: {
@@ -27,6 +30,7 @@ export declare const MAP_EVENT_TO_FUNCTION_TYPE: {
     readonly "media-library-asset-create": "sanity.function.media-library.asset";
     readonly "media-library-asset-delete": "sanity.function.media-library.asset";
     readonly "media-library-asset-update": "sanity.function.media-library.asset";
+    readonly "pub-sub": "sanity.function.pubsub";
     readonly "scheduled-function": "sanity.function.cron";
     readonly "sync-tag-invalidate": "sanity.function.sync-tag-invalidate";
 };
@@ -42,6 +46,7 @@ export declare const LABEL_DOCUMENT_DELETE = "Document Delete";
 export declare const LABEL_MEDIA_LIBRARY_ASSET_CREATE = "Media Library Asset Create";
 export declare const LABEL_MEDIA_LIBRARY_ASSET_UPDATE = "Media Library Asset Update";
 export declare const LABEL_MEDIA_LIBRARY_ASSET_DELETE = "Media Library Asset Delete";
+export declare const LABEL_PUBSUB = "PubSub";
 export declare const LABEL_SCHEDULED = "Scheduled";
 export declare const LABEL_SYNC_TAG_INVALIDATE = "Sync Tag Invalidate";
 export declare const CI_SETUP_DOCS_URL = "https://www.sanity.io/docs/blueprints/deploy-blueprints-from-ci";

package/dist/constants.js

@@ -3,8 +3,10 @@ export const SANITY_ACCESS_ROBOT = 'sanity.access.robot';
 export const SANITY_FUNCTION_PREFIX = 'sanity.function.';
 export const SANITY_FUNCTION_DOCUMENT = 'sanity.function.document';
 export const SANITY_FUNCTION_MEDIA_LIBRARY_ASSET = 'sanity.function.media-library.asset';
+export const SANITY_FUNCTION_PUBSUB = 'sanity.function.pubsub';
 export const SANITY_FUNCTION_SCHEDULED = 'sanity.function.cron';
 export const SANITY_FUNCTION_SYNC_TAG_INVALIDATE = 'sanity.function.sync-tag-invalidate';
+export const SANITY_FUNCTION_DURABLE = 'sanity.function.durable';
 export const SANITY_PROJECT = 'sanity.project';
 export const SANITY_PROJECT_CORS = 'sanity.project.cors';
 export const SANITY_PROJECT_DATASET = 'sanity.project.dataset';
@@ -17,6 +19,7 @@ export const EVENT_DOCUMENT_DELETE = 'document-delete';
 export const EVENT_MEDIA_LIBRARY_ASSET_CREATE = 'media-library-asset-create';
 export const EVENT_MEDIA_LIBRARY_ASSET_UPDATE = 'media-library-asset-update';
 export const EVENT_MEDIA_LIBRARY_ASSET_DELETE = 'media-library-asset-delete';
+export const EVENT_PUBSUB = 'pub-sub';
 export const EVENT_SCHEDULED = 'scheduled-function';
 export const EVENT_SYNC_TAG_INVALIDATE = 'sync-tag-invalidate';
 export const MAP_EVENT_TO_FUNCTION_TYPE = {
@@ -27,6 +30,7 @@ export const MAP_EVENT_TO_FUNCTION_TYPE = {
     [EVENT_MEDIA_LIBRARY_ASSET_CREATE]: SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
     [EVENT_MEDIA_LIBRARY_ASSET_DELETE]: SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
     [EVENT_MEDIA_LIBRARY_ASSET_UPDATE]: SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
+    [EVENT_PUBSUB]: SANITY_FUNCTION_PUBSUB,
     [EVENT_SCHEDULED]: SANITY_FUNCTION_SCHEDULED,
     [EVENT_SYNC_TAG_INVALIDATE]: SANITY_FUNCTION_SYNC_TAG_INVALIDATE,
 };
@@ -35,6 +39,7 @@ export const PROJECT_SCOPED_FUNCTION_TYPES = new Set([
     SANITY_FUNCTION_DOCUMENT,
     SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
     SANITY_FUNCTION_SYNC_TAG_INVALIDATE,
+    SANITY_FUNCTION_DURABLE,
 ]);
 export const ORGANIZATION_SCOPED_FUNCTION_TYPES = new Set([
     SANITY_FUNCTION_SCHEDULED,
@@ -47,6 +52,7 @@ export const LABEL_DOCUMENT_DELETE = 'Document Delete';
 export const LABEL_MEDIA_LIBRARY_ASSET_CREATE = 'Media Library Asset Create';
 export const LABEL_MEDIA_LIBRARY_ASSET_UPDATE = 'Media Library Asset Update';
 export const LABEL_MEDIA_LIBRARY_ASSET_DELETE = 'Media Library Asset Delete';
+export const LABEL_PUBSUB = 'PubSub';
 export const LABEL_SCHEDULED = 'Scheduled';
 export const LABEL_SYNC_TAG_INVALIDATE = 'Sync Tag Invalidate';
 export const CI_SETUP_DOCS_URL = 'https://www.sanity.io/docs/blueprints/deploy-blueprints-from-ci';

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,119 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { env } from 'node:process';
+import { hostedStudioOrigin, 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 { printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, promptForStudioName, resourceNamesCollide } from './prompts.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 studioName = await promptForStudioName(flags, isInteractive);
+    const stackName = flags.stackName
+        ? slugify(flags.stackName) || match.project.id
+        : slugify(match.project.displayName) || match.project.id;
+    if (resourceNamesCollide(stackName, studioName)) {
+        return {
+            success: false,
+            error: `Stack and Studio names both resolve to "${stackName}". Blueprint resource names must be unique.`,
+            suggestions: ['Pass --stack-name or --studio-name with a different value.'],
+        };
+    }
+    const studioOrigin = hostedStudioOrigin(studioName, env.SANITY_INTERNAL_ENV);
+    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
+    printBlueprintPreview({
+        log,
+        organizationName: match.organization.name,
+        projectId: match.project.id,
+        projectName: match.project.displayName,
+        datasetName,
+        studioName,
+        studioOrigin,
+        studioSource: '.',
+        stackName,
+    });
+    log('Changes:');
+    log("  + sanity.blueprint.ts             attach project + dataset; add CORS and Studio at '.'");
+    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
+    log(`  ${marker('.gitignore')} .gitignore`);
+    log(`  ${marker('package.json')} package.json`);
+    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,
+        studioName,
+        studioOrigin,
+        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: match.organization.id,
+        projectId: match.project.id,
+        datasetName,
+        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

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

@@ -0,0 +1,64 @@
+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) {
+    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(check(`Stack ${stack.name} created (org scope)`));
+    options.log('The Stack is empty; Blueprint resources have not been deployed.');
+    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

@@ -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,120 @@
+import { env } from 'node:process';
+import { hostedStudioOrigin, 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 { printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, promptForStudioName, resourceNamesCollide } 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 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 stackName = flags.stackName
+        ? slugify(flags.stackName) || project.id
+        : slugify(project.displayName) || project.id;
+    const studioName = await promptForStudioName(flags, isInteractive);
+    if (resourceNamesCollide(stackName, studioName)) {
+        return {
+            success: false,
+            error: `Stack and Studio names both resolve to "${stackName}". Blueprint resource names must be unique.`,
+            suggestions: ['Pass --stack-name or --studio-name with a different value.'],
+        };
+    }
+    const studioOrigin = hostedStudioOrigin(studioName, env.SANITY_INTERNAL_ENV);
+    printBlueprintPreview({
+        log,
+        organizationName: organization.name,
+        projectId: project.id,
+        projectName: project.displayName,
+        datasetName: dataset.name,
+        studioName,
+        studioOrigin,
+        studioSource: `studios/${studioName}`,
+        stackName,
+        functionName: STARTER_FUNCTION_NAME,
+    });
+    log('Files to write:');
+    log('  + sanity.blueprint.ts             project + dataset (attached), CORS, studio, function');
+    const studioDirectory = `studios/${studioName}/`;
+    log(`  + ${studioDirectory.padEnd(Math.max(32, studioDirectory.length + 2))}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 confirmed = await confirmUnlessSkipped(flags, isInteractive, `Create this Blueprint workspace for "${project.displayName}"?`);
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    const scaffold = scaffoldWorkspace({
+        dir,
+        projectId: project.id,
+        displayName: project.displayName,
+        datasetName: dataset.name,
+        stackName,
+        studioName,
+        studioOrigin,
+        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/preview.d.ts

@@ -0,0 +1,15 @@
+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;
+}
+export declare function printBlueprintPreview(options: BlueprintPreviewOptions): void;
+export {};

package/dist/cores/blueprinit/preview.js

@@ -0,0 +1,14 @@
+export function printBlueprintPreview(options) {
+    options.log('Blueprint plan:');
+    options.log(`  attach  Project ${options.projectName} (${options.projectId}) on deploy; retain on Stack removal`);
+    options.log(`  attach  Dataset ${options.datasetName} on deploy; retain on Stack removal`);
+    options.log(`  create  CORS Origin ${options.studioName}-cors for ${options.studioOrigin} on deploy`);
+    options.log(`  create  Studio ${options.studioName} from ${options.studioSource} at ${options.studioOrigin} on deploy`);
+    if (options.functionName) {
+        options.log(`  create  Function ${options.functionName} on deploy`);
+    }
+    options.log('');
+    options.log('Remote action now:');
+    options.log(`  create  Stack ${options.stackName} in ${options.organizationName} (empty, organization scope)`);
+    options.log('');
+}

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

@@ -0,0 +1,5 @@
+import type { BlueprinitFlags } from './types.js';
+export declare const DEFAULT_STUDIO_NAME = "studio";
+export declare function resourceNamesCollide(stackName: string, studioName: string): boolean;
+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

@@ -0,0 +1,22 @@
+import { confirm, input } from '@inquirer/prompts';
+import { slugify } from '../../actions/blueprinit/manifest.js';
+export const DEFAULT_STUDIO_NAME = 'studio';
+export function resourceNamesCollide(stackName, studioName) {
+    return stackName === studioName;
+}
+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.studioName)
+        return slugify(flags.studioName) || DEFAULT_STUDIO_NAME;
+    if (flags.yes || !interactive)
+        return DEFAULT_STUDIO_NAME;
+    const answer = await input({
+        message: 'Name your Studio and hosted slug?',
+        default: DEFAULT_STUDIO_NAME,
+    });
+    return slugify(answer) || 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 {};