@sanity/runtime-cli 5.1.0 → 5.2.0

package/dist/cores/blueprints/init.js

@@ -0,0 +1,190 @@
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
+import { getProject, listProjects } from '../../actions/blueprints/projects.js';
+import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { niceId } from '../../utils/display/colors.js';
+const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
+export async function blueprintInitCore(options) {
+    const { log, token, args, flags } = options;
+    try {
+        const { 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, dir: flagDir, } = flags;
+        const { dir: argDir } = args;
+        const dirProvided = argDir || flagDir;
+        const here = cwd();
+        const dir = argDir || flagDir || here;
+        const existingBlueprint = findBlueprintFile(dir);
+        if (existingBlueprint) {
+            return { success: false, error: 'Existing Blueprint found.' };
+        }
+        const blueprintExtension = flagBlueprintType || (await promptForBlueprintType());
+        if (!blueprintExtension) {
+            return { success: false, error: 'Blueprint type is required.' };
+        }
+        let projectId = flagProjectId;
+        let stackId = flagStackId;
+        if (!projectId) {
+            const pickedProject = await promptForProject(token);
+            projectId = pickedProject.projectId;
+        }
+        if (flagStackName) {
+            // using --stack-name gets around "LAUNCH LIMIT: 1 Stack per Project"
+            const stack = await createEmptyStack({
+                token,
+                projectId,
+                name: flagStackName,
+                projectBased: false,
+            });
+            stackId = stack.id;
+        }
+        const auth = { token: token, projectId };
+        if (!stackId) {
+            // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
+            if (LAUNCH_LIMIT_STACK_PER_PROJECT) {
+                await createProjectBasedStack(auth, token, log);
+                // do not set stackId, to avoid saving it to the config file
+            }
+            else {
+                stackId = await promptForStackId({ projectId, token });
+            }
+        }
+        const fileName = `blueprint.${blueprintExtension}`;
+        const filePath = join(dir, fileName);
+        if (dirProvided)
+            log(`New Blueprint created:   ${dirProvided}/`);
+        writeBlueprintToDisk({ blueprintFilePath: filePath });
+        log(`Created new blueprint:   ${dirProvided ?? '.'}/${fileName}`);
+        writeConfigFile({ blueprintFilePath: filePath, projectId, stackId });
+        log(`Created new config file: ${dirProvided ?? '.'}/.blueprint/config.json`);
+        if (blueprintExtension === 'ts') {
+            log('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx');
+        }
+        return { success: true };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Error: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}
+async function promptForBlueprintType() {
+    const { pickedBlueprintsType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'pickedBlueprintsType',
+            message: 'Choose a blueprint type:',
+            choices: [
+                { name: 'JSON (Recommended)', value: 'json' },
+                { name: 'JavaScript', value: 'js', disabled: true },
+                { name: 'TypeScript', value: 'ts', disabled: true },
+            ],
+            default: 'json',
+        },
+    ]);
+    return pickedBlueprintsType;
+}
+async function promptForProject(token) {
+    const { ok: projectsOk, error: projectsErr, projects } = await listProjects({ token });
+    if (!projectsOk) {
+        throw new Error(projectsErr ?? 'Unknown error listing projects');
+    }
+    if (projects.length === 0) {
+        throw new Error('No Sanity projects found. Use `npx sanity init` to create one.');
+    }
+    const projectChoices = projects.map(({ displayName, id: projectId }) => ({
+        name: `"${displayName}" ${niceId(projectId)}`,
+        value: { projectId, displayName },
+    }));
+    const { pickedProject } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'pickedProject',
+            message: 'Select your Sanity project:',
+            choices: projectChoices,
+        },
+    ]);
+    return pickedProject;
+}
+async function promptForStackId({ projectId, token, }) {
+    const { ok: stacksOk, error: stacksErr, stacks } = await listStacks({ token, projectId });
+    if (!stacksOk) {
+        throw new Error(stacksErr || 'Failed to list Stacks');
+    }
+    const stackChoices = [
+        { name: chalk.bold('✨ Create a new Stack'), value: 'new' },
+    ];
+    if (stacks.length > 0) {
+        stackChoices.push(new inquirer.Separator(chalk.underline('Use an existing Stack:')));
+        stackChoices.push(...stacks.map((s) => ({
+            name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
+            value: s.id,
+        })));
+    }
+    const { pickedStackId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'pickedStackId',
+            message: 'Select an existing deployment or create a new one:',
+            choices: stackChoices,
+        },
+    ]);
+    if (pickedStackId === 'new') {
+        const { stackName } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'stackName',
+                message: 'Enter a name for your Stack:',
+                validate: (input) => input.length > 0 || 'Stack name is required',
+            },
+        ]);
+        const stack = await createEmptyStack({
+            token,
+            projectId,
+            name: stackName,
+        });
+        return stack.id;
+    }
+    return pickedStackId;
+}
+async function createEmptyStack({ token, projectId, name, projectBased = true, }) {
+    const stackPayload = {
+        name,
+        projectId,
+        useProjectBasedId: projectBased,
+        document: { resources: [] },
+    };
+    const auth = { token, projectId };
+    const response = await createStack({ stackPayload, auth });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to create new Stack');
+    }
+    return response.stack;
+}
+// LAUNCH LIMIT: 1 Stack per Project - create exclusive stack for project
+async function createProjectBasedStack(auth, token, log) {
+    const { projectId } = auth;
+    // get project
+    const { ok: projectOk, project } = await getProject(auth);
+    if (!projectOk) {
+        throw new Error('Failed to find Project while creating Stack');
+    }
+    const projectDisplayName = project.displayName;
+    // check if project has a stack
+    const inferredStackId = `ST-${projectId}`;
+    const { stack: existingStack, ok: stackOk } = await getStack({ stackId: inferredStackId, auth });
+    // if existing stack, return stack
+    if (stackOk && existingStack) {
+        log(chalk.red(`Found existing deployment for "${projectDisplayName}" Blueprint`));
+        log(chalk.red('Deploying an empty Blueprint will override the existing deployment.'));
+        return existingStack;
+    }
+    // if not, create a stack
+    const stack = await createEmptyStack({
+        token,
+        projectId,
+        name: projectDisplayName,
+    });
+    return stack;
+}

package/dist/cores/blueprints/logs.d.ts

@@ -0,0 +1,11 @@
+import type { AuthParams, Stack } from '../../utils/types.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintLogsOptions extends CoreConfig {
+    auth: AuthParams;
+    stackId: string;
+    deployedStack: Stack;
+    flags: {
+        watch?: boolean;
+    };
+}
+export declare function blueprintLogsCore(options: BlueprintLogsOptions): Promise<CoreResult>;

package/dist/cores/blueprints/logs.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+import Spinner from 'yocto-spinner';
+import { findNewestLogTimestamp, getLogs, getRecentLogs, isNewerLog, streamLogs, } from '../../actions/blueprints/logs.js';
+import { formatTitle } from '../../utils/display/blueprints-formatting.js';
+import { bold, niceId } from '../../utils/display/colors.js';
+import { formatLogEntry, formatLogsByDay, organizeLogsByDay, } from '../../utils/display/logs-formatting.js';
+export async function blueprintLogsCore(options) {
+    const { log, auth, stackId, deployedStack, flags } = options;
+    const { watch = false } = flags;
+    const spinner = Spinner({
+        text: `Fetching recent logs for deployment ${niceId(stackId)}`,
+    }).start();
+    try {
+        if (watch) {
+            const { ok, logs, error } = await getLogs(stackId, auth);
+            if (!ok) {
+                spinner.error(`${chalk.red('Failed')} to retrieve logs`);
+                log(`Error: ${error || 'Unknown error'}`);
+                return { success: false, error: error || 'Failed to retrieve logs' };
+            }
+            spinner.stop().clear();
+            log(`${formatTitle('Blueprint', deployedStack.name)} ${niceId(stackId)} logs`);
+            if (logs.length > 0) {
+                log('\nMost recent logs:');
+                const recentLogs = getRecentLogs(logs);
+                for (const logEntry of recentLogs) {
+                    log(`  ${formatLogEntry(logEntry)}`);
+                }
+            }
+            else {
+                log(`No recent logs found for deployment ${niceId(stackId)}`);
+            }
+            const onOpen = () => {
+                log(`Watching for new logs... ${bold('ctrl+c')} to stop`);
+            };
+            let newestTimestamp = findNewestLogTimestamp(logs);
+            const renderLog = (logEntry) => {
+                if (!isNewerLog(logEntry, newestTimestamp))
+                    return;
+                newestTimestamp = new Date(logEntry.timestamp).getTime();
+                log(formatLogEntry(logEntry, true));
+            };
+            streamLogs(stackId, auth, renderLog, onOpen, (error) => log(`${chalk.red('Error:')} ${error}`));
+            // Return a special key for streaming mode
+            return {
+                success: true,
+                streaming: new Promise(() => { }),
+            };
+        }
+        // Regular non-streaming logs
+        const { ok, logs, error } = await getLogs(stackId, auth);
+        if (!ok) {
+            spinner.error(`${chalk.red('Failed')} to retrieve logs`);
+            log(`Error: ${error || 'Unknown error'}`);
+            return { success: false, error: error || 'Failed to retrieve logs' };
+        }
+        if (logs.length === 0) {
+            spinner.info(`No logs found for deployment ${stackId}`);
+            return { success: true };
+        }
+        spinner.success(`${formatTitle('Blueprint', deployedStack.name)} Logs`);
+        log(`Found ${bold(logs.length.toString())} log entries for deployment ${niceId(stackId)}\n`);
+        // Organize and format logs by day
+        const logsByDay = organizeLogsByDay(logs);
+        log(formatLogsByDay(logsByDay));
+        return { success: true };
+    }
+    catch (err) {
+        spinner.error('Failed to retrieve logs');
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        log(`Error: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}

package/dist/cores/blueprints/plan.d.ts

@@ -0,0 +1,6 @@
+import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintPlanOptions extends CoreConfig {
+    blueprint: ReadBlueprintResult;
+}
+export declare function blueprintPlanCore(options: BlueprintPlanOptions): Promise<CoreResult>;

package/dist/cores/blueprints/plan.js

@@ -0,0 +1,11 @@
+import { formatResourceTree, formatTitle } from '../../utils/display/blueprints-formatting.js';
+export async function blueprintPlanCore(options) {
+    const { bin = 'sanity', log, blueprint } = options;
+    const { parsedBlueprint, fileInfo } = blueprint;
+    const { resources } = parsedBlueprint;
+    log(`${formatTitle('Deployment', 'Plan')}`);
+    log(`(${fileInfo.fileName})\n`);
+    log(formatResourceTree(resources));
+    log(`\nRun \`${bin} blueprints deploy\` to deploy these changes`);
+    return { success: true };
+}

package/dist/cores/blueprints/stacks.d.ts

@@ -0,0 +1,10 @@
+import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintStacksOptions extends CoreConfig {
+    token: string;
+    blueprint: ReadBlueprintResult;
+    flags: {
+        projectId?: string;
+    };
+}
+export declare function blueprintStacksCore(options: BlueprintStacksOptions): Promise<CoreResult>;

package/dist/cores/blueprints/stacks.js

@@ -0,0 +1,30 @@
+import chalk from 'chalk';
+import { listStacks } from '../../actions/blueprints/stacks.js';
+import { formatStacksListing } from '../../utils/display/blueprints-formatting.js';
+import { niceId } from '../../utils/display/colors.js';
+export async function blueprintStacksCore(options) {
+    const { log, token, blueprint, flags } = options;
+    const { projectId: blueprintProjectId, stackId: blueprintStackId } = blueprint;
+    const projectId = flags.projectId || blueprintProjectId;
+    if (!projectId) {
+        log('Run in a Blueprint directory or provide a Project with --projectId');
+        return { success: false, error: 'No Project ID provided' };
+    }
+    try {
+        const { ok, stacks, error } = await listStacks({ token, projectId });
+        if (!ok)
+            return { success: false, error: error || 'Failed to list stacks' };
+        if (!stacks || stacks.length === 0) {
+            log('No stacks found');
+            return { success: true };
+        }
+        log(`${chalk.bold('Project')} ${niceId(projectId)} ${chalk.bold('Stacks')}:\n`);
+        log(formatStacksListing(stacks, blueprintStackId));
+        return { success: true };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Error: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}

package/dist/cores/index.d.ts

@@ -0,0 +1,20 @@
+export * as blueprintsCores from './blueprints/index.js';
+export interface CoreConfig {
+    /** The CLI binary name. */
+    bin: string;
+    /** The log output function. */
+    log: (message: string) => void;
+}
+export type CoreResult = {
+    /** Something went wrong. */
+    success: false;
+    /** The error message, if the operation failed. */
+    error: string;
+    streaming?: never;
+} | {
+    /** Everything went well. */
+    success: true;
+    /** The streaming function, if the operation is streaming. */
+    streaming?: Promise<void>;
+    error?: never;
+};

package/dist/cores/index.js

@@ -0,0 +1 @@
+export * as blueprintsCores from './blueprints/index.js';

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

@@ -1,23 +1,24 @@
 import { treeify } from 'array-treeify';
-import { blue, bold, boldnblue, green, niceId, red, yellow } from './colors.js';
+import chalk from 'chalk';
+import { niceId } from './colors.js';
 import { formatDate, formatDuration } from './dates.js';
 export function formatTitle(title, name) {
-    return `${boldnblue(title)} ${bold(`"${name}"`)}`;
+    return `${chalk.bold.blue(title)} ${chalk.bold(`"${name}"`)}`;
 }
 export function formatResourceTree(resources) {
     if (!resources || resources.length === 0) {
-        return '  Zero deployed resources';
+        return '  Zero resources';
     }
     const output = [];
-    output.push(`${blue('Blueprint Resources')} [${resources.length}]`);
+    output.push(`${chalk.blue('Blueprint Resources')} [${resources.length}]`);
     const functionResources = resources.filter((r) => r.type?.startsWith('sanity.function.'));
     const otherResources = resources.filter((r) => !r.type?.startsWith('sanity.function.'));
     const hasOtherResources = otherResources.length > 0;
     if (functionResources.length > 0) {
         const functionsOutput = [];
-        functionsOutput.push(`${bold('Functions')} [${functionResources.length}]`);
+        functionsOutput.push(`${chalk.bold('Functions')} [${functionResources.length}]`);
         const functionResourcesOutput = functionResources.map((fn) => {
-            const name = green(fn.displayName || fn.name);
+            const name = chalk.green(fn.displayName || fn.name);
             const externalId = fn.externalId ? `Fn${niceId(fn.externalId)}` : '';
             return `"${name}" ${externalId}`;
         });
@@ -26,9 +27,9 @@ export function formatResourceTree(resources) {
     }
     if (hasOtherResources) {
         const otherOutput = [];
-        otherOutput.push(`${bold('Other Resources')} [${otherResources.length}]`);
+        otherOutput.push(`${chalk.bold('Other Resources')} [${otherResources.length}]`);
         const otherResourcesOutput = otherResources.map((other) => {
-            return `"${yellow(other.displayName ?? other.name ?? 'unnamed')}"`;
+            return `"${chalk.yellow(other.displayName ?? other.name ?? 'unnamed')}"`;
         });
         otherOutput.push(otherResourcesOutput);
         output.push(otherOutput);
@@ -40,7 +41,7 @@ export function formatStackInfo(stack, isCurrentStack = false) {
     const isStack = 'id' in stack;
     const infoOutput = [];
     if (isStack) {
-        const stackName = isCurrentStack ? boldnblue(stack.name) : bold(stack.name);
+        const stackName = isCurrentStack ? chalk.bold.blue(stack.name) : chalk.bold(stack.name);
         output.push(`"${stackName}" ${niceId(stack.id)}${isCurrentStack ? ' (current)' : ''}`);
     }
     else {
@@ -63,7 +64,7 @@ export function formatStackInfo(stack, isCurrentStack = false) {
             if (operation.id)
                 operationOutput.push(`Recent Operation ${niceId(operation.id)}:`);
             if (operation.status) {
-                const operationColor = operation.status === 'COMPLETED' ? green : red;
+                const operationColor = operation.status === 'COMPLETED' ? chalk.green : chalk.red;
                 const status = operation.status || 'UNKNOWN';
                 operationOutput.push(`Status: ${operationColor(status)}`);
             }
@@ -71,7 +72,7 @@ export function formatStackInfo(stack, isCurrentStack = false) {
                 operationOutput.push(`Started: ${formatDate(operation.createdAt)}`);
             if (operation.status === 'COMPLETED' && operation.completedAt && operation.createdAt) {
                 operationOutput.push(`Completed: ${formatDate(operation.completedAt)}`);
-                operationOutput.push(`Duration: ${yellow(formatDuration(operation.createdAt, operation.completedAt))}`);
+                operationOutput.push(`Duration: ${chalk.yellow(formatDuration(operation.createdAt, operation.completedAt))}`);
             }
             infoOutput.push(operationOutput);
         }

package/dist/utils/display/colors.d.ts

@@ -5,5 +5,7 @@ export declare function blue(str: string): string;
 export declare function green(str: string): string;
 export declare function red(str: string): string;
 export declare function yellow(str: string): string;
-export declare function boldnblue(str: string): string;
+export declare function info(str: string): string;
+export declare function warn(str: string): string;
+export declare function severe(str: string): string;
 export declare function niceId(id: string | undefined): string;

package/dist/utils/display/colors.js

@@ -22,8 +22,14 @@ export function red(str) {
 export function yellow(str) {
     return chalk.yellow(str);
 }
-export function boldnblue(str) {
-    return chalk.bold.blue(str);
+export function info(str) {
+    return `${chalk.blue('❯')} ${str}`;
+}
+export function warn(str) {
+    return `${chalk.yellow('❯')} ${str}`;
+}
+export function severe(str) {
+    return `${chalk.red('❯')} ${str}`;
 }
 export function niceId(id) {
     if (!id)

package/oclif.manifest.json

@@ -12,7 +12,7 @@
           "required": true
         }
       },
-      "description": "Add a (function) resource to a Blueprint",
+      "description": "Add a Resource to a Blueprint",
       "examples": [
         "<%= config.bin %> <%= command.id %> function",
         "<%= config.bin %> <%= command.id %> function --name my-function",
@@ -22,7 +22,7 @@
       "flags": {
         "name": {
           "char": "n",
-          "description": "Name of the resource to add",
+          "description": "Name of the Resource to add",
           "name": "name",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -35,7 +35,7 @@
           "dependsOn": [
             "name"
           ],
-          "description": "Type of new function",
+          "description": "Type of new Function",
           "name": "fn-type",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -49,7 +49,7 @@
             "function-language",
             "lang"
           ],
-          "description": "Language of the new function",
+          "description": "Language of the new Function",
           "name": "language",
           "default": "ts",
           "hasDynamicHelp": false,
@@ -152,7 +152,6 @@
       "pluginName": "@sanity/runtime-cli",
       "pluginType": "core",
       "strict": true,
-      "enableJsonFlag": false,
       "isESM": true,
       "relativePath": [
         "dist",
@@ -201,34 +200,47 @@
       ],
       "flags": {
         "force": {
+          "aliases": [
+            "f"
+          ],
           "description": "Force destroy (skip confirmation)",
           "name": "force",
           "allowNo": false,
           "type": "boolean"
         },
-        "projectId": {
+        "project-id": {
+          "aliases": [
+            "projectId",
+            "project"
+          ],
           "dependsOn": [
-            "id",
+            "stack-id",
             "force"
           ],
           "description": "Project associated with the Stack (defaults to current Project)",
           "hidden": true,
-          "name": "projectId",
+          "name": "project-id",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
-        "id": {
-          "dependsOn": [
-            "projectId",
-            "force"
+        "stack-id": {
+          "aliases": [
+            "stackId",
+            "stack"
           ],
           "description": "Stack ID to destroy (defaults to current Stack)",
           "hidden": true,
-          "name": "id",
+          "name": "stack-id",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "no-wait": {
+          "description": "Do not wait for destruction to complete",
+          "name": "no-wait",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -386,10 +398,12 @@
       ],
       "flags": {
         "watch": {
+          "aliases": [
+            "follow"
+          ],
           "char": "w",
           "description": "Watch for new logs (streaming mode)",
           "name": "watch",
-          "required": false,
           "allowNo": false,
           "type": "boolean"
         }
@@ -768,5 +782,5 @@
       ]
     }
   },
-  "version": "5.1.0"
+  "version": "5.2.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -23,6 +23,10 @@
       "types": "./dist/actions/functions/index.d.ts",
       "import": "./dist/actions/functions/index.js"
     },
+    "./cores/blueprints": {
+      "types": "./dist/cores/blueprints/index.d.ts",
+      "import": "./dist/cores/blueprints/index.js"
+    },
     "./utils": {
       "types": "./dist/utils/index.d.ts",
       "import": "./dist/utils/index.js"