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

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 {};

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 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) };
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { AuthParams } from '../../utils/types.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface FunctionListOptions extends Pick<CoreConfig, 'log'> {
+    auth: AuthParams;
+    flags: {
+        json?: boolean;
+        verbose?: boolean;
+    };
+}
+export declare function functionListCore(options: FunctionListOptions): Promise<CoreResult>;

package/dist/cores/functions/list.js

@@ -0,0 +1,34 @@
+import { listFunctions } from '../../actions/functions/list.js';
+import { formatFunctionsList } from '../../utils/display/functions-formatting.js';
+import { capitalize, niceId } from '../../utils/display/presenters.js';
+import { styleText } from '../../utils/style-text.js';
+export async function functionListCore(options) {
+    const { auth, flags, log } = options;
+    const { scopeId, scopeType } = auth;
+    const spinner = flags.json ? undefined : log.ora('Fetching functions...').start();
+    const result = await listFunctions(auth, log);
+    if (!result.ok) {
+        spinner?.fail('Failed to list functions');
+        const suggestions = /access|permission|forbidden/i.test(result.error)
+            ? [
+                `Verify you have access to ${scopeType} "${scopeId}".`,
+                'Try a different scope with --project-id or --organization-id.',
+            ]
+            : undefined;
+        return { success: false, error: result.error, suggestions };
+    }
+    spinner?.stop().clear();
+    if (!flags.json) {
+        if (result.functions.length === 0) {
+            log(`No functions found for ${scopeType} ${niceId(scopeId)}`);
+        }
+        else {
+            log(`${styleText('bold', capitalize(scopeType))} ${niceId(scopeId)} ${styleText('bold', 'Functions')} [${result.functions.length}]:`);
+            log(formatFunctionsList(result.functions, { verbose: flags.verbose }));
+        }
+    }
+    return {
+        success: true,
+        json: { functions: result.functions, scopeType, scopeId },
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { DeployedFunction } from '../../actions/functions/list.js';
+export declare function formatFunctionsList(functions: DeployedFunction[], options?: {
+    verbose?: boolean;
+}): string;
+export declare function formatFunction(fn: DeployedFunction, options?: {
+    verbose?: boolean;
+}): string;

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

@@ -0,0 +1,95 @@
+import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
+import { styleText } from '../style-text.js';
+import { formatDateTime } from './dates.js';
+import { niceId, renderSection } from './presenters.js';
+export function formatFunctionsList(functions, options = {}) {
+    if (!options.verbose)
+        return formatCompactList(functions);
+    return functions.map((fn) => formatFunction(fn, options)).join('\n');
+}
+export function formatFunction(fn, options = {}) {
+    if (!options.verbose)
+        return formatCompactList([fn]);
+    const rows = [];
+    if (fn.type)
+        rows.push(['Type', shortType(fn.type)]);
+    if (fn.updatedAt) {
+        const updatedAt = formatDateTime(fn.updatedAt);
+        if (updatedAt)
+            rows.push(['Updated', updatedAt]);
+    }
+    if (typeof fn.memory === 'number')
+        rows.push(['Memory', `${fn.memory} MB`]);
+    if (typeof fn.timeout === 'number')
+        rows.push(['Timeout', `${fn.timeout}s`]);
+    const rule = formatEventRule(fn.eventRule);
+    if (rule)
+        rows.push(['Rule', rule]);
+    return renderSection(formatTitle(fn), rows);
+}
+function formatCompactList(functions) {
+    const titles = functions.map(plainTitle);
+    const ids = functions.map((fn) => `<${fn.id}>`);
+    const types = functions.map((fn) => (fn.type ? shortType(fn.type) : '-'));
+    const updated = functions.map((fn) => (fn.updatedAt ? formatDateTime(fn.updatedAt) || '-' : '-'));
+    const titlePad = Math.max(...titles.map((title) => title.length));
+    const idPad = Math.max(...ids.map((id) => id.length));
+    const typePad = Math.max(...types.map((type) => type.length));
+    return functions
+        .map((fn, index) => {
+        const title = formatIdentity(fn) + ' '.repeat(titlePad - titles[index].length);
+        const id = niceId(fn.id) + ' '.repeat(idPad - ids[index].length);
+        const type = styleText('dim', types[index].padEnd(typePad));
+        const timestamp = styleText('dim', updated[index]);
+        return `  ${title}  ${id}  ${type}  ${timestamp}`;
+    })
+        .join('\n');
+}
+function formatTitle(fn) {
+    return `${formatIdentity(fn)} ${niceId(fn.id)}`;
+}
+function formatIdentity(fn) {
+    const parts = [];
+    if (fn.name)
+        parts.push(styleText('bold', fn.name));
+    if (fn.displayName && fn.displayName !== fn.name) {
+        parts.push(styleText('green', `"${fn.displayName}"`));
+    }
+    if (parts.length === 0)
+        parts.push(styleText('bold', 'Unnamed'));
+    return parts.join(' ');
+}
+function plainTitle(fn) {
+    const parts = [];
+    if (fn.name)
+        parts.push(fn.name);
+    if (fn.displayName && fn.displayName !== fn.name)
+        parts.push(`"${fn.displayName}"`);
+    return parts.length > 0 ? parts.join(' ') : 'Unnamed';
+}
+function shortType(type) {
+    return type.startsWith(SANITY_FUNCTION_PREFIX) ? type.slice(SANITY_FUNCTION_PREFIX.length) : type;
+}
+function formatEventRule(rule) {
+    if (rule === null || rule === undefined)
+        return undefined;
+    if (typeof rule !== 'object')
+        return String(rule);
+    if (Array.isArray(rule))
+        return rule.map(formatRuleValue).join(', ');
+    const entries = Object.entries(rule);
+    if (entries.length === 0)
+        return undefined;
+    return entries.map(([key, value]) => `${key}: ${formatRuleValue(value)}`).join(' · ');
+}
+function formatRuleValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === null || value === undefined)
+        return String(value);
+    if (Array.isArray(value))
+        return value.map(formatRuleValue).join(', ');
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}

package/oclif.manifest.json

@@ -1,5 +1,133 @@
 {
   "commands": {
+    "blueprinit": {
+      "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",
+          "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": "blueprinit",
+      "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",
+        "blueprinit.js"
+      ]
+    },
     "blueprints:add": {
       "aliases": [],
       "args": {
@@ -491,6 +619,17 @@
           "allowNo": false,
           "type": "boolean"
         },
+        "configure": {
+          "aliases": [
+            "config",
+            "init"
+          ],
+          "description": "Configure the local Blueprint interactively before deploying",
+          "hidden": true,
+          "name": "configure",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "new-stack-name": {
           "description": "Set a new name for the Stack",
           "name": "new-stack-name",
@@ -2146,6 +2285,117 @@
         "dev.js"
       ]
     },
+    "functions:list": {
+      "aliases": [],
+      "args": {},
+      "description": "Lists functions deployed directly in the selected project or organization scope. The local Blueprint config supplies the scope by default.\n\nUse --project-id or --organization-id to select a scope without a local Blueprint. Organization results include organization-scoped functions only.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> --verbose",
+        "<%= config.bin %> <%= command.id %> --project-id <projectId>",
+        "<%= config.bin %> <%= command.id %> --organization-id <organizationId>",
+        "<%= config.bin %> <%= command.id %> --project-id <projectId> --json"
+      ],
+      "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": {
+          "char": "v",
+          "description": "Show function configuration details",
+          "name": "verbose",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "stack": {
+          "description": "Stack name or ID to use instead of the locally configured Stack",
+          "hidden": true,
+          "name": "stack",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "project-id": {
+          "aliases": [
+            "project",
+            "projectId"
+          ],
+          "description": "Sanity project ID used to scope Blueprint and Stack",
+          "exclusive": [
+            "organization-id"
+          ],
+          "name": "project-id",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "organization-id": {
+          "aliases": [
+            "organization",
+            "organizationId",
+            "org"
+          ],
+          "description": "Sanity organization ID used to scope Blueprint and Stack",
+          "exclusive": [
+            "project-id"
+          ],
+          "name": "organization-id",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hidden": true,
+      "hiddenAliases": [],
+      "id": "functions:list",
+      "pluginAlias": "@sanity/runtime-cli",
+      "pluginName": "@sanity/runtime-cli",
+      "pluginType": "core",
+      "strict": true,
+      "summary": "List deployed Sanity Functions",
+      "enableJsonFlag": true,
+      "needs": [
+        "scope"
+      ],
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "functions",
+        "list.js"
+      ]
+    },
     "functions:logs": {
       "aliases": [],
       "args": {
@@ -2998,5 +3248,5 @@
       ]
     }
   },
-  "version": "17.3.2"
+  "version": "17.4.0-blueprinit.g0ac8878"
 }