@sanity/runtime-cli 17.6.2 → 17.7.0-blueprinit.ga49bda6

package/dist/cores/blueprinit/selection.js

@@ -0,0 +1,90 @@
+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 async function chooseDataset(datasets, datasetName, projectName, interactive) {
+    if (datasets.length === 0) {
+        return failure(`No datasets found in ${projectName}.`);
+    }
+    if (datasetName) {
+        const dataset = datasets.find(({ name }) => name === datasetName);
+        return dataset
+            ? { ok: true, value: dataset }
+            : failure(`No dataset "${datasetName}" found in ${projectName}.`);
+    }
+    if (datasets.length === 1)
+        return { ok: true, value: datasets[0] };
+    if (!interactive) {
+        return failure('Multiple datasets found.', ['Pass --dataset <name> to choose one.']);
+    }
+    const production = datasets.find(({ name }) => name === 'production');
+    const orderedDatasets = production
+        ? [production, ...datasets.filter(({ name }) => name !== 'production')]
+        : datasets;
+    const selectedName = await select({
+        message: 'Choose a Sanity dataset:',
+        choices: orderedDatasets.map((dataset) => ({
+            name: dataset.name,
+            value: dataset.name,
+            description: dataset.aclMode,
+        })),
+    });
+    const selected = datasets.find(({ name }) => name === selectedName);
+    return selected ? { ok: true, value: selected } : failure('Dataset not found.');
+}
+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

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

package/dist/cores/blueprinit/types.js

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

package/dist/cores/blueprinit.d.ts

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

@@ -0,0 +1,48 @@
+import { cwd } from 'node:process';
+import { detectStudio } from '../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../actions/blueprints/blueprint.js';
+import { readConfigFile } from '../actions/blueprints/config.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) {
+            const blueprintConfig = readConfigFile(existingBlueprint.blueprintFilePath);
+            if (!blueprintConfig?.stackId) {
+                return {
+                    success: false,
+                    error: `A Blueprint exists here (${existingBlueprint.fileName}), but it is not connected to a Stack.`,
+                    suggestions: [`Finish setup with: npx ${bin} blueprints init`],
+                };
+            }
+            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 init 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) };
+    }
+}

package/dist/utils/display/blueprints-formatting.js

@@ -1,10 +1,10 @@
 import { treeify } from 'array-treeify';
-import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
+import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, SANITY_STUDIO, } from '../../constants.js';
 import { styleText } from '../style-text.js';
-import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isWebhookResource, } from '../types.js';
+import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isStudioResource, isWebhookResource, } from '../types.js';
 import { formatDateTime, formatDuration } from './dates.js';
 import { capitalize, niceId, renderSection } from './presenters.js';
-import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyWebhook, } from './resources-formatting.js';
+import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyStudio, arrayifyWebhook, } from './resources-formatting.js';
 const functionCategory = {
     label: 'Functions',
     displayNameAttribute: 'displayName',
@@ -58,6 +58,13 @@ const RESOURCE_CATEGORIES = {
             return isWebhookResource(res) ? arrayifyWebhook(res) : [];
         },
     },
+    [SANITY_STUDIO]: {
+        label: 'Studios',
+        displayNameAttribute: 'title',
+        formatDetails(res) {
+            return isStudioResource(res) ? arrayifyStudio(res) : [];
+        },
+    },
 };
 const categoryByLabel = Object.values(RESOURCE_CATEGORIES).reduce((acc, curr) => {
     acc[curr.label] = curr;
@@ -76,9 +83,11 @@ function resourceName(res, displayNameAttribute) {
 }
 function deployedResourceName(res, displayNameAttribute, verbose = false) {
     const nameParts = [styleText(['bold', 'green'], res.name)];
-    const displayName = displayNameAttribute &&
-        typeof res.parameters[displayNameAttribute] === 'string' &&
-        res.parameters[displayNameAttribute];
+    // deployed state: prefer the resolved value, fall back to the authored one
+    const nameValue = displayNameAttribute
+        ? (res.resolvedParameters?.[displayNameAttribute] ?? res.parameters[displayNameAttribute])
+        : undefined;
+    const displayName = typeof nameValue === 'string' && nameValue;
     if (displayName && displayName !== res.name)
         nameParts.push(styleText('green', `"${displayName}"`));
     if (verbose)
@@ -151,7 +160,9 @@ function buildOutputTree(resources, createName, mapToResource, verbose = false)
 export function formatDeployedResourceTree(resources, verbose = false) {
     if (!resources || resources.length === 0)
         return '  Zero deployed resources';
-    const output = buildOutputTree(resources, (category, res, v) => deployedResourceName(res, category.displayNameAttribute, v), (res) => ({ name: res.name, type: res.type, ...res.parameters }), verbose);
+    const output = buildOutputTree(resources, (category, res, v) => deployedResourceName(res, category.displayNameAttribute, v), 
+    // deployed state: prefer resolved values, fall back to authored ones
+    (res) => ({ name: res.name, type: res.type, ...(res.resolvedParameters ?? res.parameters) }), verbose);
     return `${treeify(output)}\n`;
 }
 export function formatResourceTree(resources, verbose = false) {

package/dist/utils/display/resources-formatting.d.ts

@@ -1,8 +1,9 @@
-import type { BlueprintCorsOriginResource, BlueprintDatasetResource, BlueprintDocumentWebhookResource, BlueprintResource, BlueprintRobotResource, BlueprintRoleResource } from '@sanity/blueprints';
+import type { BlueprintCorsOriginResource, BlueprintDatasetResource, BlueprintDocumentWebhookResource, BlueprintResource, BlueprintRobotResource, BlueprintRoleResource, BlueprintStudioResource } from '@sanity/blueprints';
 import type { TreeInput } from 'array-treeify';
-export declare function arrayifyFunction(fn: BlueprintResource): TreeInput;
 export declare function arrayifyCors(resource: BlueprintCorsOriginResource): TreeInput;
 export declare function arrayifyDataset(resource: BlueprintDatasetResource): TreeInput;
+export declare function arrayifyFunction(fn: BlueprintResource): TreeInput;
 export declare function arrayifyRobot(resource: BlueprintRobotResource): TreeInput;
 export declare function arrayifyRole(resource: BlueprintRoleResource): TreeInput;
+export declare function arrayifyStudio(resource: BlueprintStudioResource): TreeInput;
 export declare function arrayifyWebhook(resource: BlueprintDocumentWebhookResource): TreeInput;

package/dist/utils/display/resources-formatting.js

@@ -1,11 +1,27 @@
 import { hasEventSource, isLocalFunctionResource, isScheduleEvent, } from '../../utils/types.js';
 import { styleText } from '../style-text.js';
+import { niceId } from './presenters.js';
 function formatLabel(label) {
     return styleText('dim', `${label}:`);
 }
 function formatLabeledValue(label, value) {
     return `${styleText('dim', `${label}:`)} ${value}`;
 }
+export function arrayifyCors(resource) {
+    const details = [formatLabeledValue('origin', resource.origin)];
+    if (resource.allowCredentials !== undefined) {
+        details.push(formatLabeledValue('allowCredentials', resource.allowCredentials));
+    }
+    return details;
+}
+export function arrayifyDataset(resource) {
+    const details = [formatLabeledValue('title', resource.datasetName)];
+    if (resource.aclMode)
+        details.push(formatLabeledValue('visibility', resource.aclMode));
+    if (resource.project)
+        details.push(formatLabeledValue('project', niceId(resource.project)));
+    return details;
+}
 function arrayifyEvent(event) {
     if (!event)
         return undefined;
@@ -55,19 +71,8 @@ export function arrayifyFunction(fn) {
     }
     return details;
 }
-export function arrayifyCors(resource) {
-    return [formatLabeledValue('origin', resource.origin)];
-}
-export function arrayifyDataset(resource) {
-    const details = [formatLabeledValue('title', resource.datasetName)];
-    if (resource.aclMode)
-        details.push(formatLabeledValue('visibility', resource.aclMode));
-    if (resource.project)
-        details.push(formatLabeledValue('project', resource.project));
-    return details;
-}
 export function arrayifyRobot(resource) {
-    const details = [formatLabeledValue('label', resource.label)];
+    const details = [];
     if (resource.memberships.length > 0) {
         details.push(formatLabel('memberships'));
         const memberships = [];
@@ -115,8 +120,16 @@ export function arrayifyRole(resource) {
     }
     return details;
 }
+export function arrayifyStudio(resource) {
+    const details = [formatLabeledValue('appHost', resource.slug)];
+    if (resource.project)
+        details.push(formatLabeledValue('project', niceId(resource.project)));
+    return details;
+}
 export function arrayifyWebhook(resource) {
     const details = [];
+    if (resource.displayName)
+        details.push(formatLabeledValue('displayName', resource.displayName));
     if (resource.description)
         details.push(formatLabeledValue('description', resource.description));
     details.push(formatLabeledValue('url', resource.url));
@@ -131,6 +144,8 @@ export function arrayifyWebhook(resource) {
         details.push(formatLabeledValue('httpMethod', resource.httpMethod));
     if (resource.dataset)
         details.push(formatLabeledValue('dataset', resource.dataset));
+    if (resource.project)
+        details.push(formatLabeledValue('project', niceId(resource.project)));
     // not included: headers, includeDrafts, includeAllVersions, secret, apiVersion
     return details;
 }

package/dist/utils/functions/resolve-auth.js

@@ -1,4 +1,15 @@
 import { ORGANIZATION_SCOPED_FUNCTION_TYPES, PROJECT_SCOPED_FUNCTION_TYPES } from '../../constants.js';
+const REFERENCE_PREFIX = '$.resources.';
+/**
+ * A scope ID the API can use: a literal, never an unresolved Blueprint reference.
+ * Overly defensive and checks resource.parameters as fallback.
+ */
+function literalScopeId(resource, key) {
+    const value = resource.resolvedParameters?.[key] ?? resource.parameters[key];
+    if (typeof value !== 'string' || value.startsWith(REFERENCE_PREFIX))
+        return undefined;
+    return value;
+}
 /**
  * Resolves the correct auth scope for a function API request.
  *
@@ -8,11 +19,13 @@ import { ORGANIZATION_SCOPED_FUNCTION_TYPES, PROJECT_SCOPED_FUNCTION_TYPES } fro
  */
 export function resolveFunctionAuth(auth, deployedStack, resource) {
     // 1. explicit resource-level scope takes highest priority
-    if (typeof resource.parameters.project === 'string') {
-        return { ...auth, scopeType: 'project', scopeId: resource.parameters.project };
+    const project = literalScopeId(resource, 'project');
+    if (project) {
+        return { ...auth, scopeType: 'project', scopeId: project };
     }
-    if (typeof resource.parameters.organization === 'string') {
-        return { ...auth, scopeType: 'organization', scopeId: resource.parameters.organization };
+    const organization = literalScopeId(resource, 'organization');
+    if (organization) {
+        return { ...auth, scopeType: 'organization', scopeId: organization };
     }
     // 2. project-scoped function types: resolve a project ID or fail
     if (PROJECT_SCOPED_FUNCTION_TYPES.has(resource.type)) {

package/dist/utils/types.d.ts

@@ -33,7 +33,10 @@ export interface AuthParams {
 export interface BlueprintResourceRecord extends BlueprintResource {
     id: string;
     externalId?: string | null;
+    /** Authored values; a value can be an unresolved `$.resources.<name>` reference */
     parameters: Record<string, unknown>;
+    /** Values deployment used, with references resolved */
+    resolvedParameters?: Record<string, unknown>;
 }
 /** The deployed resource; complete with external ID */
 export interface DeployedResource extends BlueprintResourceRecord {

package/oclif.manifest.json

@@ -1,5 +1,134 @@
 {
   "commands": {
+    "init": {
+      "aliases": [],
+      "args": {},
+      "description": "Scaffolds a Blueprint, Studio, and starter function around an existing Sanity project.\n\nThis hidden command is an experiment; its interface and generated files are not stable.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> --yes",
+        "<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --yes"
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "path": {
+          "aliases": [
+            "blueprint-path"
+          ],
+          "char": "p",
+          "description": "Path to a Blueprint file or directory containing one",
+          "env": "SANITY_BLUEPRINT_PATH",
+          "hidden": true,
+          "name": "path",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "trace": {
+          "description": "Trace output",
+          "hidden": true,
+          "name": "trace",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "validate-resources": {
+          "description": "Validate resources",
+          "hidden": true,
+          "name": "validate-resources",
+          "allowNo": true,
+          "type": "boolean"
+        },
+        "verbose": {
+          "description": "Verbose output",
+          "hidden": true,
+          "name": "verbose",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "llms": {
+          "aliases": [
+            "skill"
+          ],
+          "description": "Show agent-oriented guidance for this command",
+          "hidden": true,
+          "name": "llms",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "yes": {
+          "char": "y",
+          "description": "Skip confirmation prompts",
+          "name": "yes",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "organization-id": {
+          "aliases": [
+            "organization",
+            "organizationId",
+            "org"
+          ],
+          "description": "Organization to use when the account has several",
+          "name": "organization-id",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "project-id": {
+          "aliases": [
+            "project",
+            "projectId"
+          ],
+          "description": "Project to use when the organization has several",
+          "name": "project-id",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "dataset": {
+          "description": "Dataset to attach",
+          "name": "dataset",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "stack-name": {
+          "description": "Name for the new organization-scoped Stack",
+          "name": "stack-name",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "studio-name": {
+          "description": "Name and hosted slug for the Studio resource",
+          "name": "studio-name",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hidden": true,
+      "hiddenAliases": [],
+      "id": "init",
+      "pluginAlias": "@sanity/runtime-cli",
+      "pluginName": "@sanity/runtime-cli",
+      "pluginType": "core",
+      "strict": true,
+      "summary": "Experimental blueprints-first project init",
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "init.js"
+      ]
+    },
     "blueprints:add": {
       "aliases": [],
       "args": {
@@ -3127,5 +3256,5 @@
       ]
     }
   },
-  "version": "17.6.2"
+  "version": "17.7.0-blueprinit.ga49bda6"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.6.2",
+  "version": "17.7.0-blueprinit.ga49bda6",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -65,20 +65,20 @@
     "@architect/hydrate": "~6.0.2",
     "@architect/inventory": "~6.1.0",
     "@inquirer/prompts": "^8.5.2",
-    "@oclif/core": "^4.13.3",
-    "@oclif/plugin-help": "^6.2.56",
+    "@oclif/core": "^4.13.4",
+    "@oclif/plugin-help": "^6.2.58",
     "@sanity-labs/design-tokens": "^0.0.2-alpha.2",
     "@sanity-labs/oclif-plugin-skills-flag": "^0.2.1",
-    "@sanity/blueprints": "^0.23.2",
-    "@sanity/blueprints-parser": "^0.4.0",
-    "@sanity/cli-build": "^5.1.0",
-    "@sanity/cli-core": "^2.8.1",
-    "@sanity/client": "^7.26.2",
+    "@sanity/blueprints": "^0.23.6",
+    "@sanity/blueprints-parser": "^0.5.0",
+    "@sanity/cli-build": "^5.2.0",
+    "@sanity/cli-core": "^3.0.0",
+    "@sanity/client": "^8.0.0",
     "adm-zip": "^0.6.0",
-    "array-treeify": "^0.1.5",
+    "array-treeify": "^0.2.0",
     "cardinal": "^2.1.1",
     "empathic": "^2.0.1",
-    "eventsource": "^4.1.1",
+    "eventsource": "^5.1.0",
     "groq-js": "^2.0.0",
     "jiti": "^2.7.0",
     "mime-types": "^3.0.2",
@@ -92,15 +92,15 @@
     "xdg-basedir": "^5.1.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.7",
+    "@biomejs/biome": "2.5.8",
     "@codemirror/lang-json": "^6.0.2",
     "@codemirror/state": "^6.7.1",
     "@enhance/store": "^1.0.2",
     "@lezer/highlight": "^1.2.3",
-    "@oclif/test": "^4.1.21",
+    "@oclif/test": "^4.1.22",
     "@playwright/test": "^1.62.1",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@sanity/functions": "^1.6.0",
+    "@sanity/functions": "^1.6.6",
     "@types/adm-zip": "^0.5.8",
     "@types/cardinal": "^2.1.1",
     "@types/mime-types": "^3.0.1",