@sanity/runtime-cli 17.3.2 → 17.4.0-blueprinit.g596ac51

package/dist/actions/blueprinit/workspace.js

@@ -0,0 +1,143 @@
+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,
+        studioOrigin: options.studioOrigin,
+    };
+}
+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/blueprints/pre-deploy.d.ts

@@ -1,6 +1,7 @@
 import type { BlueprintResource } from '@sanity/blueprints';
 import type { Logger } from '../../utils/logger.js';
 import { type AuthParams, type InstallerType, type ScopeType } from '../../utils/types.js';
+import { type ProcessAssetsProgress, type ProcessedAsset } from './process-assets.js';
 type PreDeployResult = {
     success: false;
     error: string;
@@ -10,11 +11,14 @@ type PreDeployResult = {
 } | {
     success: true;
 };
-type PreDeployResourceOptions = {
-    auth: AuthParams;
-    blueprintFileDir: string;
-    installer: InstallerType;
-    log: Logger;
+export type PreDeployAssetEvent = {
+    type: 'progress';
+    progress: ProcessAssetsProgress;
+} | {
+    type: 'complete';
+} | {
+    type: 'result';
+    result: ProcessedAsset;
 };
 type PreDeployOptions = {
     scopeType: ScopeType;
@@ -24,6 +28,11 @@ type PreDeployOptions = {
     stackName: string;
     bin: string;
     verbose: boolean | undefined;
-} & PreDeployResourceOptions;
+    auth: AuthParams;
+    blueprintFileDir: string;
+    installer: InstallerType;
+    logger: Logger;
+    onAssetEvent?: (event: PreDeployAssetEvent) => void;
+};
 export declare function preDeploy(options: PreDeployOptions): Promise<PreDeployResult>;
 export {};

package/dist/actions/blueprints/pre-deploy.js

@@ -1,18 +1,13 @@
 import { env } from 'node:process';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
-import { niceId } from '../../utils/display/presenters.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
 import { styleText } from '../../utils/style-text.js';
 import { isAssetResource, } from '../../utils/types.js';
-import { stashAsset } from './assets.js';
+import { processAssets } from './process-assets.js';
 import { updateStack } from './stacks.js';
 import { waitForOperation } from './wait-for-operation.js';
-const DEFAULT_ASSET_TIMEOUT = 180;
-const assetTimeoutS = Number(process.env.SANITY_ASSET_TIMEOUT) || DEFAULT_ASSET_TIMEOUT;
-const assetTimeoutMs = assetTimeoutS * 1000;
-const warnTimeoutMs = assetTimeoutMs / 3;
 export async function preDeploy(options) {
-    const { resources, stackId, auth, blueprintFileDir, installer, log } = options;
+    const { resources, stackId, auth, blueprintFileDir, installer, logger } = options;
     const hasAssetResources = resources.some(isAssetResource);
     if (hasAssetResources) {
         let assetResources;
@@ -26,34 +21,45 @@ export async function preDeploy(options) {
                 resources,
                 stackId,
                 auth,
-                logger: log,
+                logger,
             });
             assetResources = resolvedResources.filter(isAssetResource);
         }
         else {
             assetResources = resources.filter(isAssetResource);
         }
-        log('Processing assets...');
-        for (const resource of assetResources) {
-            const preDeployResult = await preDeployResource(resource, {
+        let processedAssets;
+        try {
+            processedAssets = await processAssets({
+                assetResources,
                 auth,
                 blueprintFileDir,
                 installer,
-                log,
+                logger,
+                onProgress: (progress) => options.onAssetEvent?.({ type: 'progress', progress }),
+                onResult: (result) => options.onAssetEvent?.({ type: 'result', result }),
             });
-            if (!preDeployResult.success)
-                return preDeployResult;
-            const idx = resources.findIndex((r) => r.name === resource.name);
+        }
+        finally {
+            options.onAssetEvent?.({ type: 'complete' });
+        }
+        const failure = processedAssets.find((result) => !result.success);
+        if (failure)
+            return { success: false, error: failure.error };
+        // update resources with processed assets
+        for (const asset of processedAssets) {
+            const idx = resources.findIndex((r) => r.name === asset.resource.name);
+            // ! I think this error message is wrong. we somehow have an extra asset
             if (idx === -1)
                 throw new Error('Unable to update resource asset');
-            resources[idx] = preDeployResult.resource;
+            resources[idx] = asset.resource;
         }
     }
     return { success: true };
 }
 async function preDeployStack(options) {
-    const { scopeType, scopeId, stackId, stackName, resources, auth, log, bin, verbose } = options;
-    const spinner = log.ora('Starting pre-deploy...').start();
+    const { scopeType, scopeId, stackId, stackName, resources, auth, logger, bin, verbose } = options;
+    const spinner = logger.ora('Starting pre-deploy...').start();
     const stackMutation = {
         scopeType,
         scopeId,
@@ -61,7 +67,7 @@ async function preDeployStack(options) {
         preDeploy: true,
         document: { resources },
     };
-    const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackMutation, auth, logger: log });
+    const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackMutation, auth, logger });
     if (!deployOk) {
         spinner.fail(`${styleText('red', 'Failed')} to complete Stack pre-deployment`);
         return {
@@ -74,19 +80,19 @@ async function preDeployStack(options) {
         };
     }
     spinner.stop().clear();
-    log(styleText('dim', 'Stack deployment progress:'));
-    log('');
+    logger(styleText('dim', 'Stack deployment progress:'));
+    logger('');
     const outcome = await waitForOperation({
         stackId,
         operationId: stack.operationId,
         auth,
-        log,
+        log: logger,
         bin,
         verbose,
         progressNoun: 'pre-deployment',
     });
     if (outcome.type === 'completed') {
-        log(styleText(['bold', 'green'], 'Stack pre-deployment completed!'));
+        logger(styleText(['bold', 'green'], 'Stack pre-deployment completed!'));
     }
     else if (outcome.type === 'unconfirmed') {
         return {
@@ -115,50 +121,3 @@ async function preDeployStack(options) {
     }
     return { success: true };
 }
-async function preDeployResource(resource, options) {
-    const { auth, blueprintFileDir, installer, log } = options;
-    const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
-    const warnTimer = setTimeout(() => {
-        fnSpinner.text = `Still processing ${resource.name}, this can take a moment...`;
-    }, warnTimeoutMs);
-    let assetTimeoutTimer;
-    let result;
-    try {
-        result = await Promise.race([
-            stashAsset({ resource, blueprintFileDir, auth, logger: log, installer }),
-            new Promise((_, reject) => {
-                assetTimeoutTimer = setTimeout(() => {
-                    reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
-                }, assetTimeoutMs);
-            }),
-        ]);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        fnSpinner.fail(msg);
-        return { success: false, error: msg };
-    }
-    finally {
-        clearTimeout(warnTimer);
-        clearTimeout(assetTimeoutTimer);
-    }
-    if (result.success && result.assetId) {
-        const updatedResource = { ...resource, src: result.assetId };
-        fnSpinner.succeed(`${updatedResource.name} ${niceId(result.assetId)}`);
-        log(`   Source: ${updatedResource.src}`);
-        if (result.hash) {
-            if (result.hash.length > 24) {
-                log.verbose(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
-            }
-            else {
-                log.verbose(`   Hash: ${result.hash}`);
-            }
-        }
-        if (result.exists)
-            log.verbose('   Asset unchanged');
-        return { success: true, resource: updatedResource };
-    }
-    const errorMsg = `Failed uploading ${resource.name} asset, deploy has stopped`;
-    fnSpinner.fail(errorMsg);
-    return { success: false, error: result.error || 'Failed to process asset' };
-}

package/dist/actions/blueprints/process-assets.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '../../utils/logger.js';
+import type { AssetResource, AuthParams, InstallerType } from '../../utils/types.js';
+type ProcessAssetsOptions = {
+    assetResources: AssetResource[];
+    auth: AuthParams;
+    blueprintFileDir: string;
+    installer: InstallerType;
+    logger: Logger;
+    onProgress?: (progress: ProcessAssetsProgress) => void;
+    onResult?: (result: ProcessedAsset) => void;
+};
+export type ProcessAssetsProgress = {
+    completed: number;
+    total: number;
+    slow: boolean;
+};
+export type ProcessedAsset = {
+    success: false;
+    resource: AssetResource;
+    error: string;
+    failureKind: 'processing' | 'upload';
+} | {
+    success: true;
+    resource: AssetResource;
+    hash?: string;
+    exists?: boolean;
+};
+export declare function processAssets(options: ProcessAssetsOptions): Promise<ProcessedAsset[]>;
+export {};

package/dist/actions/blueprints/process-assets.js

@@ -0,0 +1,80 @@
+import { env } from 'node:process';
+import { stashAsset } from './assets.js';
+const DEFAULT_ASSET_CONCURRENCY = 4;
+const DEFAULT_ASSET_TIMEOUT = 180;
+const assetTimeoutS = Number(env.SANITY_ASSET_TIMEOUT) || DEFAULT_ASSET_TIMEOUT;
+const assetTimeoutMs = assetTimeoutS * 1000;
+const warnTimeoutMs = assetTimeoutMs / 3;
+export async function processAssets(options) {
+    const { assetResources, onProgress, onResult } = options;
+    const total = assetResources.length;
+    const processedAssets = [];
+    const concurrency = getAssetConcurrency();
+    let completed = 0;
+    let slow = false;
+    const reportProgress = () => onProgress?.({ completed, total, slow });
+    reportProgress();
+    const warnTimer = setTimeout(() => {
+        slow = true;
+        reportProgress();
+    }, warnTimeoutMs);
+    try {
+        for (let start = 0; start < total; start += concurrency) {
+            const batch = assetResources.slice(start, start + concurrency);
+            const batchResults = await Promise.all(batch.map(async (resource) => {
+                const result = await processAsset(resource, options);
+                completed += 1;
+                reportProgress();
+                onResult?.(result);
+                return result;
+            }));
+            processedAssets.push(...batchResults);
+            if (batchResults.some((result) => !result.success))
+                break;
+        }
+    }
+    finally {
+        clearTimeout(warnTimer);
+    }
+    return processedAssets;
+}
+function getAssetConcurrency() {
+    const configured = Number(env.SANITY_ASSET_CONCURRENCY);
+    return Number.isSafeInteger(configured) && configured > 0 ? configured : DEFAULT_ASSET_CONCURRENCY;
+}
+async function processAsset(resource, options) {
+    const { auth, blueprintFileDir, installer, logger } = options;
+    let assetTimeoutTimer;
+    let result;
+    try {
+        result = await Promise.race([
+            stashAsset({ resource, blueprintFileDir, auth, logger, installer }),
+            new Promise((_, reject) => {
+                assetTimeoutTimer = setTimeout(() => {
+                    reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
+                }, assetTimeoutMs);
+            }),
+        ]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, resource, error: msg, failureKind: 'processing' };
+    }
+    finally {
+        clearTimeout(assetTimeoutTimer);
+    }
+    if (result.success && result.assetId) {
+        return {
+            success: true,
+            resource: { ...resource, src: result.assetId },
+            hash: result.hash,
+            exists: result.exists,
+        };
+    }
+    return {
+        success: false,
+        resource,
+        error: result.error || 'Failed to process asset',
+        failureKind: 'upload',
+    };
+}

package/dist/actions/functions/list.d.ts

@@ -0,0 +1,34 @@
+import type { Logger } from '../../utils/logger.js';
+import type { AuthParams } from '../../utils/types.js';
+/** A deployed function returned by the Functions API. */
+export interface DeployedFunction {
+    id: string;
+    name: string | null;
+    displayName: string | null;
+    type: string | null;
+    runtime: string | null;
+    status: string | null;
+    memory: number | null;
+    storage: number | null;
+    timeout: number | null;
+    resourceType: string | null;
+    resourceId: string | null;
+    robotId: string | null;
+    url: string | null;
+    eventRule?: unknown;
+    contentSub?: Record<string, unknown> | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    deletedAt?: string | null;
+}
+type ListFunctionsResponse = {
+    ok: true;
+    error: null;
+    functions: DeployedFunction[];
+} | {
+    ok: false;
+    error: string;
+    functions: [];
+};
+export declare function listFunctions(auth: AuthParams, logger: Logger): Promise<ListFunctionsResponse>;
+export {};

package/dist/actions/functions/list.js

@@ -0,0 +1,33 @@
+import config from '../../config.js';
+import getHeaders from '../../utils/get-headers.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
+const { apiUrl } = config;
+export async function listFunctions(auth, logger) {
+    try {
+        const fetchFn = createTracedFetch(logger);
+        const response = await fetchFn(`${apiUrl}v2025-07-30/functions/`, {
+            headers: getHeaders(auth),
+            method: 'GET',
+        });
+        const payload = (await response.json());
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: payload.error?.message ?? payload.message ?? 'Failed to list functions',
+                functions: [],
+            };
+        }
+        return {
+            ok: true,
+            error: null,
+            functions: Array.isArray(payload.functions) ? payload.functions : [],
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            functions: [],
+        };
+    }
+}

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/baseCommands.d.ts

@@ -138,5 +138,7 @@ export declare abstract class ResolvedCommand<T extends typeof Command> extends
     protected blueprintConfig?: LocatedBlueprintsConfig | null;
     protected auth: AuthParams;
     protected deployedStack: Stack;
+    /** Runs after flag parsing and before declared command context is resolved. */
+    protected preResolve(): Promise<void>;
     init(): Promise<void>;
 }

package/dist/baseCommands.js

@@ -220,8 +220,11 @@ export class ResolvedCommand extends RuntimeCommand {
     blueprintConfig;
     auth;
     deployedStack;
+    /** Runs after flag parsing and before declared command context is resolved. */
+    async preResolve() { }
     async init() {
         await super.init(); // RuntimeCommand: parse flags + args
+        await this.preResolve();
         const needs = new Set(this.constructor.needs);
         if (needs.size === 0)
             return;

package/dist/commands/blueprinit.d.ts

@@ -0,0 +1,17 @@
+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>;
+        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/blueprinit.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 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',
+        '<%= 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;
+    }
+}