@sanity/runtime-cli 1.1.1 → 1.2.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity COMMAND
 running command...
 $ sanity (--version)
-@sanity/runtime-cli/1.1.1 linux-x64 node-v22.14.0
+@sanity/runtime-cli/1.2.0 linux-x64 node-v22.14.0
 $ sanity --help [COMMAND]
 USAGE
   $ sanity COMMAND
@@ -29,6 +29,9 @@ USAGE
 <!-- usagestop -->
 # Commands
 <!-- commands -->
+* [`sanity blueprints deploy`](#sanity-blueprints-deploy)
+* [`sanity blueprints info`](#sanity-blueprints-info)
+* [`sanity blueprints plan`](#sanity-blueprints-plan)
 * [`sanity functions dev`](#sanity-functions-dev)
 * [`sanity functions invoke ID`](#sanity-functions-invoke-id)
 * [`sanity functions logs ID`](#sanity-functions-logs-id)
@@ -45,6 +48,57 @@ USAGE
 * [`sanity plugins unlink [PLUGIN]`](#sanity-plugins-unlink-plugin)
 * [`sanity plugins update`](#sanity-plugins-update)
 
+## `sanity blueprints deploy`
+
+Deploy a Blueprint
+
+```
+USAGE
+  $ sanity blueprints deploy
+
+DESCRIPTION
+  Deploy a Blueprint
+
+EXAMPLES
+  $ sanity blueprints deploy
+```
+
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/blueprints/deploy.ts)_
+
+## `sanity blueprints info`
+
+Show information about a Blueprint
+
+```
+USAGE
+  $ sanity blueprints info
+
+DESCRIPTION
+  Show information about a Blueprint
+
+EXAMPLES
+  $ sanity blueprints info
+```
+
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/blueprints/info.ts)_
+
+## `sanity blueprints plan`
+
+Enumerate resources to be deployed - will not modify any resources
+
+```
+USAGE
+  $ sanity blueprints plan
+
+DESCRIPTION
+  Enumerate resources to be deployed - will not modify any resources
+
+EXAMPLES
+  $ sanity blueprints plan
+```
+
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/blueprints/plan.ts)_
+
 ## `sanity functions dev`
 
 Start the Sanity Function emulator
@@ -63,7 +117,7 @@ EXAMPLES
   $ sanity functions dev --port 8974
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v1.1.1/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/functions/dev.ts)_
 
 ## `sanity functions invoke ID`
 
@@ -89,7 +143,7 @@ EXAMPLES
   $ sanity functions invoke <ID> --file 'payload.json'
 ```
 
-_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v1.1.1/src/commands/functions/invoke.ts)_
+_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/functions/invoke.ts)_
 
 ## `sanity functions logs ID`
 
@@ -109,7 +163,7 @@ EXAMPLES
   $ sanity functions logs <ID>
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.1.1/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/functions/logs.ts)_
 
 ## `sanity functions test PATH`
 
@@ -138,7 +192,7 @@ EXAMPLES
   $ sanity functions test ./test.ts --data '{ "id": 1 }' --timeout 60
 ```
 
-_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v1.1.1/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.0/src/commands/functions/test.ts)_
 
 ## `sanity help [COMMAND]`
 

package/dist/actions/blueprints/read-blueprint.d.ts

@@ -0,0 +1,2 @@
+import type { Blueprint } from '../../utils/types.js';
+export default function readBlueprint(): Blueprint;

package/dist/actions/blueprints/read-blueprint.js

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+export default function readBlueprint() {
+    try {
+        const blueprintPath = join(cwd(), 'blueprint.json');
+        if (!existsSync(blueprintPath)) {
+            throw Error('Could not find blueprint.json');
+        }
+        const readBlueprint = readFileSync(blueprintPath, 'utf8').toString();
+        const blueprintJson = JSON.parse(readBlueprint);
+        return blueprintJson;
+    }
+    catch (err) {
+        throw Error('Unable to parse blueprint.json');
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { BlueprintJob } from '../../utils/types.js';
+declare function listStacks(): Promise<{
+    ok: boolean;
+    error: any;
+    stacks: any;
+}>;
+declare function getStack(stackId: string): Promise<{
+    ok: boolean;
+    error: any;
+    stack: any;
+}>;
+declare function createStack(blueprint: BlueprintJob): Promise<{
+    ok: boolean;
+    error: any;
+    stack: any;
+}>;
+declare function updateStack(stackId: string, blueprint: BlueprintJob): Promise<{
+    ok: boolean;
+    error: any;
+    stack: any;
+}>;
+export { listStacks, getStack, createStack, updateStack };

package/dist/actions/blueprints/stacks.js

@@ -0,0 +1,57 @@
+import config from '../../config.js';
+const { blueprints } = config.server;
+const HEADERS = {
+    Authorization: `Bearer ${config.token}`,
+    'Content-Type': 'application/json',
+};
+async function listStacks() {
+    const response = await fetch(`${blueprints}/vX/stacks`, {
+        method: 'GET',
+        headers: HEADERS,
+    });
+    const stacks = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : stacks.message,
+        stacks,
+    };
+}
+async function getStack(stackId) {
+    const response = await fetch(`${blueprints}/vX/stacks/${stackId}`, {
+        method: 'GET',
+        headers: HEADERS,
+    });
+    const stack = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : stack.message,
+        stack,
+    };
+}
+async function createStack(blueprint) {
+    const response = await fetch(`${blueprints}/vX/stacks`, {
+        method: 'POST',
+        headers: HEADERS,
+        body: JSON.stringify(blueprint),
+    });
+    const stack = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : stack.message,
+        stack,
+    };
+}
+async function updateStack(stackId, blueprint) {
+    const response = await fetch(`${blueprints}/vX/stacks/${stackId}`, {
+        method: 'PUT',
+        headers: HEADERS,
+        body: JSON.stringify(blueprint),
+    });
+    const stack = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : stack.message,
+        stack,
+    };
+}
+export { listStacks, getStack, createStack, updateStack };

package/dist/actions/blueprints/stash-asset.d.ts

@@ -0,0 +1,10 @@
+import type { BlueprintResource } from '../../utils/types.js';
+export declare function stashAsset(resource: BlueprintResource): Promise<{
+    success: boolean;
+    assetId: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    assetId?: undefined;
+}>;

package/dist/actions/blueprints/stash-asset.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cwd } from 'node:process';
+import JSZip from 'jszip';
+import config from '../../config.js';
+const { blueprints } = config.server;
+export async function stashAsset(resource) {
+    try {
+        // Read the function source
+        const source = await fs.readFileSync(path.join(cwd(), resource.src), 'utf8');
+        // Create zip with function source
+        const zip = new JSZip();
+        zip.file('index.js', source);
+        const zipBuffer = await zip.generateAsync({ type: 'nodebuffer' });
+        const base64Zip = zipBuffer.toString('base64');
+        // Stash the asset
+        const assetResponse = await fetch(`${blueprints}/assets/stash`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                file: base64Zip,
+                filename: `${resource.name}.zip`,
+            }),
+        });
+        const assetJson = await assetResponse.json();
+        console.debug('ASSET RESPONSE:', assetJson);
+        if (assetResponse.ok) {
+            return { success: true, assetId: assetJson.id };
+        }
+        return { success: false, error: assetJson.message || 'Unknown error' };
+    }
+    catch (err) {
+        let error = '';
+        if (err instanceof Error) {
+            error = err.message;
+        }
+        return { success: false, error };
+    }
+}

package/dist/actions/functions/invoke.js

@@ -1,10 +1,10 @@
 import config from '../../config.js';
 import buildPayload from '../../utils/build-payload.js';
-const { url } = config.server;
+const { functions } = config.server;
 export async function invoke(id, options) {
     const payload = buildPayload(options);
     // eslint-disable-next-line n/no-unsupported-features/node-builtins
-    const response = await fetch(`${url}/api/vX/functions/${id}/invoke`, {
+    const response = await fetch(`${functions}/vX/functions/${id}/invoke`, {
         body: JSON.stringify({ data: payload }),
         headers: {
             Accept: 'application/json',

package/dist/actions/functions/logs.js

@@ -1,8 +1,8 @@
 import config from '../../config.js';
-const { url } = config.server;
+const { functions } = config.server;
 export async function logs(id, token) {
     // eslint-disable-next-line n/no-unsupported-features/node-builtins
-    const response = await fetch(`${url}/api/vX/functions/${id}/logs`, {
+    const response = await fetch(`${functions}/vX/functions/${id}/logs`, {
         headers: {
             Accept: 'application/json',
             'Content-Type': 'application/json',

package/dist/commands/blueprints/deploy.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Deploy extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/blueprints/deploy.js

@@ -0,0 +1,70 @@
+import { Command } from '@oclif/core';
+import readBlueprint from '../../actions/blueprints/read-blueprint.js';
+import { createStack, listStacks, updateStack } from '../../actions/blueprints/stacks.js';
+import { stashAsset } from '../../actions/blueprints/stash-asset.js';
+import Spinner from '../../utils/spinner.js';
+export default class Deploy extends Command {
+    static description = 'Deploy a Blueprint';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const { displayName, name, projectId, resources } = readBlueprint();
+        const s = new Spinner();
+        s.start('Deploying blueprint...');
+        const functionResources = resources.filter((r) => r.kind === 'function');
+        // First stash all function assets
+        if (functionResources.length > 0) {
+            s.stop('Preparing functions...');
+            for (const resource of functionResources) {
+                const fnSpinner = new Spinner();
+                fnSpinner.start(`Processing ${resource.name}...`);
+                const result = await stashAsset(resource);
+                if (result.success) {
+                    resource.assetId = result.assetId;
+                    fnSpinner.stop(`✓ ${resource.name} (${result.assetId})`);
+                    this.log(`   Source: ${resource.src}`);
+                }
+                else {
+                    fnSpinner.stop(`✗ Failed to process ${resource.name}`);
+                    this.log(`   Error: ${result.error}`);
+                    return;
+                }
+            }
+            this.log('│');
+            s.start('Looking for existing stack...');
+        }
+        // Check for existing stack
+        const { ok: stacksOk, stacks, error: stacksError } = await listStacks();
+        if (!stacksOk) {
+            s.stop('Failed to list stacks');
+            this.log(`Error: ${stacksError || 'Unknown error'}`);
+            return;
+        }
+        const existingStack = stacks.find((st) => st.name === name);
+        const blueprint = {
+            name,
+            projectId,
+            document: {
+                resources: resources.map((r) => {
+                    if (r.kind === 'function') {
+                        return { ...r, src: r.assetId };
+                    }
+                    return r;
+                }),
+            },
+        };
+        this.debug('BLUEPRINT DOCUMENT:', blueprint);
+        // Create or update stack
+        const { ok, stack, error } = existingStack
+            ? await updateStack(existingStack.id, blueprint)
+            : await createStack(blueprint);
+        this.debug('STACK RESPONSE:', stack);
+        if (ok) {
+            s.stop(`Stack ${existingStack ? 'updated' : 'created'}! (${stack.id})`);
+            this.log('Use `blueprints info` to check deployment status');
+        }
+        else {
+            s.stop(`Failed to ${existingStack ? 'update' : 'create'} stack`);
+            this.log(`Error: ${error || 'Unknown error'}`);
+        }
+    }
+}

package/dist/commands/blueprints/info.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Info extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/blueprints/info.js

@@ -0,0 +1,71 @@
+import { Command } from '@oclif/core';
+import readBlueprint from '../../actions/blueprints/read-blueprint.js';
+import { getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import Spinner from '../../utils/spinner.js';
+export default class Info extends Command {
+    static description = 'Show information about a Blueprint';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const { displayName, name, projectId, resources } = readBlueprint();
+        const s = new Spinner();
+        if (!projectId) {
+            this.log(`No project for Blueprint "${displayName}"`);
+            return;
+        }
+        s.start(`Retrieving info for "${displayName}"`);
+        try {
+            const { ok, stacks, error } = await listStacks();
+            if (!ok) {
+                s.stop('Failed to retrieve stacks');
+                this.log(`Error: ${error || 'Unknown error'}`);
+                return;
+            }
+            if (stacks.length === 0) {
+                s.stop(`No stacks found for Blueprint "${displayName}"`);
+                return;
+            }
+            const foundStack = stacks.find((st) => st.name === name);
+            const { ok: stackOk, stack, error: stackError } = await getStack(foundStack.id);
+            if (!stackOk) {
+                s.stop('Failed to retrieve stack');
+                this.log(`Error: ${stackError || 'Unknown error'}`);
+                return;
+            }
+            s.stop(`Stack "${stack.name}" (${stack.recentOperation.status})`);
+            // Show resources
+            if (stack?.resources) {
+                const { resources: stackResources } = stack;
+                const functionResources = stackResources.filter((r) => r.kind === 'function');
+                const otherResources = stackResources.filter((r) => r.kind !== 'function');
+                if (functionResources.length > 0) {
+                    this.log(`├─ Functions (${functionResources.length})`);
+                    for (const fn of functionResources) {
+                        this.log(`│   ├─ ${fn.name} <${fn.externalId}>`);
+                    }
+                }
+                if (otherResources.length > 0) {
+                    this.log(`└─Other Resources (${otherResources.length})`);
+                    for (const other of otherResources) {
+                        this.log(`    ├─ ${other.name || other.src}`);
+                    }
+                }
+            }
+            // Show operation details if not completed
+            if (stack.recentOperation.status !== 'COMPLETED') {
+                this.log('\nOperation Details:');
+                if (stack.recentOperation.error) {
+                    this.log(`Error: ${stack.recentOperation.error}`);
+                }
+                if (stack.recentOperation.progress) {
+                    this.log(`Progress: ${stack.recentOperation.progress}`);
+                }
+            }
+        }
+        catch (err) {
+            s.stop('Failed to retrieve info');
+            if (err instanceof Error) {
+                this.log(`Error: ${err.message}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Plan extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/blueprints/plan.js

@@ -0,0 +1,31 @@
+import { Command } from '@oclif/core';
+import readBlueprint from '../../actions/blueprints/read-blueprint.js';
+export default class Plan extends Command {
+    static description = 'Enumerate resources to be deployed - will not modify any resources';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const { displayName, resources } = readBlueprint();
+        this.log(`Blueprint: "${displayName}"`);
+        const functionResources = resources.filter((r) => r.kind === 'function');
+        const otherResources = resources.filter((r) => r.kind === 'test');
+        this.log('Tracked resources:');
+        if (functionResources.length > 0) {
+            this.log(`├─ Functions (${functionResources.length})`);
+            for (const fn of functionResources) {
+                this.log(`│   ├─ ${fn.name}: ${fn.src}`);
+            }
+        }
+        if (otherResources.length > 0) {
+            this.log(`└─Other (${otherResources.length})`);
+            for (const other of otherResources) {
+                this.log(`    ├─ ${other.name}`);
+            }
+        }
+        if (resources.length === 0) {
+            this.log('No resources to deploy');
+        }
+        else {
+            this.log('\nRun `blueprints deploy` to deploy these changes');
+        }
+    }
+}

package/dist/config.d.ts

@@ -1,7 +1,8 @@
 declare const _default: {
     token: string;
     server: {
-        url: string;
+        functions: URL;
+        blueprints: URL;
     };
 };
 export default _default;

package/dist/config.js

@@ -2,10 +2,23 @@ import { env } from 'node:process';
 import getToken from './utils/get-token.js';
 const nodeEnv = env.NODE_ENV ?? 'development';
 const isDev = nodeEnv === 'development';
-const baseUrl = isDev ? 'http://localhost:4567' : '';
+const isProd = nodeEnv === 'production';
+const functionsUrls = {
+    production: 'https://api.sanity.io/',
+    staging: 'https://api.sanity.work/',
+    default: 'http://localhost:4567',
+};
+const blueprintsUrls = {
+    production: 'https://api.sanity.io/',
+    staging: 'https://api.sanity.work/',
+    default: 'http://localhost:4567',
+};
+const functionsUrl = new URL(functionsUrls[nodeEnv] ?? functionsUrls.default);
+const blueprintsUrl = new URL(blueprintsUrls[nodeEnv] ?? blueprintsUrls.default);
 export default {
-    token: isDev ? 'token' : getToken(),
+    token: isDev ? 'token' : getToken(isProd),
     server: {
-        url: baseUrl,
+        functions: functionsUrl,
+        blueprints: blueprintsUrl,
     },
 };

package/dist/server/app.js

@@ -16,7 +16,7 @@ function getStaticPath() {
 const app = new Hono();
 app.use('*', serveStatic({ root: getStaticPath() }));
 app.get('/blueprint', async (c) => {
-    const response = JSON.parse(readFileSync(join(cwd(), './blueprints.json')).toString());
+    const response = JSON.parse(readFileSync(join(cwd(), './blueprint.json')).toString());
     return c.json(response);
 });
 app.post('/invoke', async (c) => {

package/dist/utils/get-token.d.ts

@@ -1 +1 @@
-export default function getToken(): string;
+export default function getToken(isProd: boolean): string;

package/dist/utils/get-token.js

@@ -2,10 +2,11 @@ import { readFileSync } from 'node:fs';
 import { tmpdir, userInfo } from 'node:os';
 import { join } from 'node:path';
 import { xdgConfig } from 'xdg-basedir';
-export default function getToken() {
+export default function getToken(isProd) {
+    const environmentDir = isProd ? 'sanity' : 'sanity-staging';
     const user = (userInfo().username || 'user').replace(/\\/g, '');
     const configDir = xdgConfig || join(tmpdir(), user, '.config');
-    const configPath = join(configDir, 'sanity', 'config.json');
+    const configPath = join(configDir, environmentDir, 'config.json');
     const config = JSON.parse(readFileSync(configPath, 'utf8'));
     return config.authToken;
 }

package/dist/utils/spinner.d.ts

@@ -0,0 +1,9 @@
+export default class Spinner {
+    frames: Array<string>;
+    interval: undefined | ReturnType<typeof setInterval>;
+    currentFrame: number;
+    text: string;
+    constructor();
+    start(message: string): void;
+    stop(message: string): void;
+}

package/dist/utils/spinner.js

@@ -0,0 +1,25 @@
+export default class Spinner {
+    frames;
+    interval;
+    currentFrame;
+    text;
+    constructor() {
+        this.frames = ['✶', '✸', '✹', '✺', '✹', '✷'];
+        this.interval = undefined;
+        this.currentFrame = 0;
+        this.text = '';
+    }
+    start(message) {
+        this.text = message;
+        this.interval = setInterval(() => {
+            const frame = this.frames[this.currentFrame];
+            process.stdout.write(`\r${frame} ${this.text}`);
+            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+        }, 80);
+    }
+    stop(message) {
+        clearInterval(this.interval);
+        process.stdout.write(`\r${' '.repeat(this.text.length + 3)}`);
+        process.stdout.write(`\r${message}\n`);
+    }
+}

package/dist/utils/types.d.ts

@@ -14,3 +14,51 @@ export interface InvocationResponse {
     json: object | undefined;
     logs: string | undefined;
 }
+type LogFunction = (input: string) => void;
+/**
+ * @internal
+ */
+export interface BlueprintsContext {
+    log: LogFunction;
+}
+/**
+ * @internal
+ */
+export interface Blueprint {
+    displayName: string;
+    name: string;
+    projectId: string;
+    resources: Array<BlueprintResource>;
+}
+/**
+ * @internal
+ */
+export interface BlueprintDocument {
+    resources: Array<BlueprintResource>;
+}
+/**
+ * @internal
+ */
+export interface BlueprintJob {
+    name: string;
+    projectId: string;
+    document: BlueprintDocument;
+}
+/**
+ * @internal
+ */
+export interface BlueprintResource {
+    name: string;
+    kind: string;
+    src: string;
+    assetId: string;
+}
+/**
+ * @internal
+ */
+export interface BlueprintStack {
+    name: string;
+    kind: string;
+    src: string;
+}
+export {};

package/oclif.manifest.json

@@ -1,5 +1,77 @@
 {
   "commands": {
+    "blueprints:deploy": {
+      "aliases": [],
+      "args": {},
+      "description": "Deploy a Blueprint",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "blueprints:deploy",
+      "pluginAlias": "@sanity/runtime-cli",
+      "pluginName": "@sanity/runtime-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "blueprints",
+        "deploy.js"
+      ]
+    },
+    "blueprints:info": {
+      "aliases": [],
+      "args": {},
+      "description": "Show information about a Blueprint",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "blueprints:info",
+      "pluginAlias": "@sanity/runtime-cli",
+      "pluginName": "@sanity/runtime-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "blueprints",
+        "info.js"
+      ]
+    },
+    "blueprints:plan": {
+      "aliases": [],
+      "args": {},
+      "description": "Enumerate resources to be deployed - will not modify any resources",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "blueprints:plan",
+      "pluginAlias": "@sanity/runtime-cli",
+      "pluginName": "@sanity/runtime-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "blueprints",
+        "plan.js"
+      ]
+    },
     "functions:dev": {
       "aliases": [],
       "args": {},
@@ -175,5 +247,5 @@
       ]
     }
   },
-  "version": "1.1.1"
+  "version": "1.2.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "A new CLI generated with oclif",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -40,6 +40,7 @@
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
     "hono": "^4.7.2",
+    "jszip": "^3.10.1",
     "xdg-basedir": "^5.1.0"
   },
   "devDependencies": {