@sanity/runtime-cli 1.2.1 → 1.3.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity COMMAND
 running command...
 $ sanity (--version)
-@sanity/runtime-cli/1.2.1 linux-x64 node-v22.14.0
+@sanity/runtime-cli/1.3.0 linux-x64 node-v22.14.0
 $ sanity --help [COMMAND]
 USAGE
   $ sanity COMMAND
@@ -31,6 +31,7 @@ USAGE
 <!-- commands -->
 * [`sanity blueprints deploy`](#sanity-blueprints-deploy)
 * [`sanity blueprints info`](#sanity-blueprints-info)
+* [`sanity blueprints logs`](#sanity-blueprints-logs)
 * [`sanity blueprints plan`](#sanity-blueprints-plan)
 * [`sanity functions dev`](#sanity-functions-dev)
 * [`sanity functions invoke ID`](#sanity-functions-invoke-id)
@@ -63,7 +64,7 @@ EXAMPLES
   $ sanity blueprints deploy
 ```
 
-_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/blueprints/deploy.ts)_
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/blueprints/deploy.ts)_
 
 ## `sanity blueprints info`
 
@@ -80,7 +81,32 @@ EXAMPLES
   $ sanity blueprints info
 ```
 
-_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/blueprints/info.ts)_
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/blueprints/info.ts)_
+
+## `sanity blueprints logs`
+
+Display logs for a Blueprint stack
+
+```
+USAGE
+  $ sanity blueprints logs [-s <value>] [-w]
+
+FLAGS
+  -s, --stack-id=<value>  Stack ID to fetch logs for (optional if running in a blueprint directory)
+  -w, --watch             Watch for new logs (streaming mode)
+
+DESCRIPTION
+  Display logs for a Blueprint stack
+
+EXAMPLES
+  $ sanity blueprints logs
+
+  $ sanity blueprints logs --stack-id <stack-id>
+
+  $ sanity blueprints logs --watch
+```
+
+_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/blueprints/logs.ts)_
 
 ## `sanity blueprints plan`
 
@@ -97,7 +123,7 @@ EXAMPLES
   $ sanity blueprints plan
 ```
 
-_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/blueprints/plan.ts)_
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/blueprints/plan.ts)_
 
 ## `sanity functions dev`
 
@@ -117,7 +143,7 @@ EXAMPLES
   $ sanity functions dev --port 8974
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/functions/dev.ts)_
 
 ## `sanity functions invoke ID`
 
@@ -143,7 +169,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.2.1/src/commands/functions/invoke.ts)_
+_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/functions/invoke.ts)_
 
 ## `sanity functions logs ID`
 
@@ -163,7 +189,7 @@ EXAMPLES
   $ sanity functions logs <ID>
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.2.1/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/functions/logs.ts)_
 
 ## `sanity functions test PATH`
 
@@ -192,7 +218,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.2.1/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v1.3.0/src/commands/functions/test.ts)_
 
 ## `sanity help [COMMAND]`
 

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

@@ -0,0 +1,7 @@
+import type { BlueprintLog } from '../../utils/types.js';
+export declare function getLogs(stackId: string, projectId: string, token: string): Promise<{
+    logs: BlueprintLog[];
+    ok: boolean;
+    error: string | null;
+}>;
+export declare function streamLogs(stackId: string, projectId: string, token: string, onLog: (log: BlueprintLog) => void, onOpen: () => void, onError: (error: string) => void): () => void;

package/dist/actions/blueprints/logs.js

@@ -0,0 +1,79 @@
+import { EventSource } from 'eventsource';
+import config from '../../config.js';
+const { blueprints } = config.server;
+export async function getLogs(stackId, projectId, token) {
+    const response = await fetch(`${blueprints}/vX/blueprints/logs?stackId=${stackId}`, {
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+            'X-Sanity-Scope-Type': 'project',
+            'X-Sanity-Scope-Id': projectId,
+        },
+        method: 'GET',
+    });
+    const result = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : result.message || 'Unknown error',
+        logs: response.ok ? result : [],
+    };
+}
+export function streamLogs(stackId, projectId, token, onLog, onOpen, onError) {
+    const url = new URL(`${blueprints}/vX/blueprints/logs/stream`);
+    url.searchParams.append('stackId', stackId);
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+    const eventSource = new EventSource(url.toString(), {
+        fetch: (input, init) => fetch(input, {
+            ...init,
+            headers: {
+                ...init?.headers,
+                ...headers,
+            },
+        }),
+    });
+    eventSource.onopen = onOpen;
+    eventSource.onmessage = (event) => {
+        try {
+            const log = JSON.parse(event.data);
+            onLog(log);
+        }
+        catch (err) {
+            onError(`Failed to parse log data: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    eventSource.addEventListener('logs', (event) => {
+        try {
+            const logData = JSON.parse(event.data);
+            // usually an array
+            if (Array.isArray(logData)) {
+                for (const log of logData)
+                    onLog(log);
+            }
+            else {
+                onLog(logData);
+            }
+        }
+        catch (err) {
+            console.error('Error parsing logs event:', err);
+        }
+    });
+    eventSource.onerror = (err) => {
+        onError('Connection to log stream failed or was closed');
+        if (eventSource.readyState === eventSource.CLOSED) {
+            console.log('Connection is CLOSED');
+        }
+        else if (eventSource.readyState === eventSource.CONNECTING) {
+            console.log('Connection is attempting to reconnect...');
+            return; // Don't close if trying to reconnect
+        }
+        eventSource.close();
+    };
+    return () => {
+        eventSource.close();
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { BlueprintOperation } from '../../utils/types.js';
+export declare function getOperation({ stackId, operationId, projectId, }: {
+    stackId: string;
+    operationId: string;
+    projectId: string;
+}): Promise<{
+    ok: boolean;
+    error: string | null;
+    operation: BlueprintOperation | null;
+}>;
+export declare function listOperations({ stackId, projectId, }: {
+    stackId: string;
+    projectId: string;
+}): Promise<{
+    ok: boolean;
+    error: string | null;
+    operations: BlueprintOperation[];
+}>;

package/dist/actions/blueprints/operations.js

@@ -0,0 +1,52 @@
+import config from '../../config.js';
+const { blueprints } = config.server;
+function getHeaders(projectId) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+}
+export async function getOperation({ stackId, operationId, projectId, }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}/operations/${operationId}`;
+    const response = await fetch(path, {
+        method: 'GET',
+        headers: getHeaders(projectId),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        return {
+            ok: false,
+            error: errorText || 'Failed to fetch operation details',
+            operation: null,
+        };
+    }
+    const operation = await response.json();
+    return {
+        ok: true,
+        error: null,
+        operation,
+    };
+}
+export async function listOperations({ stackId, projectId, }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}/operations`;
+    const response = await fetch(path, {
+        method: 'GET',
+        headers: getHeaders(projectId),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        return {
+            ok: false,
+            error: errorText || 'Failed to fetch operations',
+            operations: [],
+        };
+    }
+    const operations = await response.json();
+    return {
+        ok: true,
+        error: null,
+        operations,
+    };
+}

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

@@ -1,2 +1,7 @@
 import type { Blueprint } from '../../utils/types.js';
-export default function readBlueprint(): Blueprint;
+export default function readBlueprintOnDisk(): {
+    document: Blueprint;
+    path: string;
+    fileName: string;
+    extension: string;
+};

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

@@ -1,17 +1,43 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { extname, join } from 'node:path';
 import { cwd } from 'node:process';
-export default function readBlueprint() {
+const SUPPORTED_FILE_NAMES_IN_PRIORITY_ORDER = [
+    'blueprint.json',
+    // 'blueprint.js',
+    // 'blueprint.mjs',
+    // 'blueprint.cjs',
+    // 'blueprint.ts',
+];
+function findBlueprintFile() {
+    for (const fileName of SUPPORTED_FILE_NAMES_IN_PRIORITY_ORDER) {
+        const filePath = join(cwd(), fileName);
+        if (existsSync(filePath)) {
+            return { path: filePath, fileName, extension: extname(filePath) };
+        }
+    }
+    return null;
+}
+export default function readBlueprintOnDisk() {
     try {
-        const blueprintPath = join(cwd(), 'blueprint.json');
-        if (!existsSync(blueprintPath)) {
-            throw Error('Could not find blueprint.json');
+        const blueprintPath = findBlueprintFile();
+        if (!blueprintPath)
+            throw Error('Could not find Blueprint file');
+        const { path, fileName, extension } = blueprintPath;
+        let readBlueprint;
+        let blueprintJson;
+        if (extension === '.json') {
+            readBlueprint = readFileSync(path, 'utf8').toString();
+            blueprintJson = JSON.parse(readBlueprint);
+            // } else if (extension === '.js' || extension === '.mjs') {
+            //   const blueprintModule = require(path)
+            //   blueprintJson = blueprintModule.default
+        }
+        else {
+            throw Error(`Unsupported blueprint file extension: ${extension}`);
         }
-        const readBlueprint = readFileSync(blueprintPath, 'utf8').toString();
-        const blueprintJson = JSON.parse(readBlueprint);
-        return blueprintJson;
+        return { document: blueprintJson, path, fileName, extension };
     }
     catch (err) {
-        throw Error('Unable to parse blueprint.json');
+        throw Error(`Unable to parse Blueprint file: ${err}`);
     }
 }

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

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

package/dist/actions/blueprints/stacks.js

@@ -1,13 +1,18 @@
 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`, {
+function getHeaders(projectId) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+}
+async function listStacks({ projectId }) {
+    const path = `${blueprints}/vX/blueprints/stacks`;
+    const response = await fetch(path, {
         method: 'GET',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
     });
     const stacks = await response.json();
     return {
@@ -16,10 +21,39 @@ async function listStacks() {
         stacks,
     };
 }
-async function getStack(stackId) {
-    const response = await fetch(`${blueprints}/vX/stacks/${stackId}`, {
+async function getStackByName({ name, projectId }) {
+    const { ok, stacks, error } = await listStacks({ projectId });
+    if (!ok || !stacks) {
+        return {
+            ok: false,
+            error: error || 'Failed to retrieve stacks',
+            stack: null,
+            stackId: null,
+        };
+    }
+    const foundStack = stacks.find((stack) => stack.name === name);
+    if (!foundStack) {
+        return {
+            ok: true,
+            error: null,
+            stack: null,
+            stackId: null,
+            availableStacks: stacks.map((s) => s.name),
+        };
+    }
+    const stackResult = await getStack({ stackId: foundStack.id, projectId });
+    return {
+        ok: stackResult.ok,
+        error: stackResult.error,
+        stack: stackResult.stack,
+        stackId: foundStack.id,
+    };
+}
+async function getStack({ stackId, projectId }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}`;
+    const response = await fetch(path, {
         method: 'GET',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
     });
     const stack = await response.json();
     return {
@@ -28,10 +62,11 @@ async function getStack(stackId) {
         stack,
     };
 }
-async function createStack(blueprint) {
-    const response = await fetch(`${blueprints}/vX/stacks`, {
+async function createStack({ blueprint, projectId }) {
+    const path = `${blueprints}/vX/blueprints/stacks`;
+    const response = await fetch(path, {
         method: 'POST',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
         body: JSON.stringify(blueprint),
     });
     const stack = await response.json();
@@ -41,10 +76,11 @@ async function createStack(blueprint) {
         stack,
     };
 }
-async function updateStack(stackId, blueprint) {
-    const response = await fetch(`${blueprints}/vX/stacks/${stackId}`, {
+async function updateStack({ stackId, blueprint, projectId, }) {
+    const path = `${blueprints}/vX/blueprints/stacks/${stackId}`;
+    const response = await fetch(path, {
         method: 'PUT',
-        headers: HEADERS,
+        headers: getHeaders(projectId),
         body: JSON.stringify(blueprint),
     });
     const stack = await response.json();
@@ -54,4 +90,4 @@ async function updateStack(stackId, blueprint) {
         stack,
     };
 }
-export { listStacks, getStack, createStack, updateStack };
+export { listStacks, getStack, createStack, updateStack, getStackByName };

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

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

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

@@ -4,7 +4,15 @@ import { cwd } from 'node:process';
 import JSZip from 'jszip';
 import config from '../../config.js';
 const { blueprints } = config.server;
-export async function stashAsset(resource) {
+function getHeaders(projectId) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+        'X-Sanity-Scope-Type': 'project',
+        'X-Sanity-Scope-Id': projectId,
+    };
+}
+export async function stashAsset({ resource, projectId, }) {
     try {
         // Read the function source
         const source = await fs.readFileSync(path.join(cwd(), resource.src), 'utf8');
@@ -14,19 +22,16 @@ export async function stashAsset(resource) {
         const zipBuffer = await zip.generateAsync({ type: 'nodebuffer' });
         const base64Zip = zipBuffer.toString('base64');
         // Stash the asset
-        const assetResponse = await fetch(`${blueprints}/assets/stash`, {
+        const assetResponse = await fetch(`${blueprints}/vX/blueprints/assets/stash`, {
             method: 'POST',
-            headers: {
-                Authorization: `Bearer ${config.token}`,
-                'Content-Type': 'application/json',
-            },
+            headers: getHeaders(projectId),
             body: JSON.stringify({
                 file: base64Zip,
                 filename: `${resource.name}.zip`,
             }),
         });
         const assetJson = await assetResponse.json();
-        console.debug('ASSET RESPONSE:', assetJson);
+        // console.debug('ASSET RESPONSE:', assetJson)
         if (assetResponse.ok) {
             return { success: true, assetId: assetJson.id };
         }

package/dist/actions/functions/invoke.js

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

package/dist/commands/blueprints/deploy.js

@@ -1,70 +1,64 @@
 import { Command } from '@oclif/core';
-import readBlueprint from '../../actions/blueprints/read-blueprint.js';
-import { createStack, listStacks, updateStack } from '../../actions/blueprints/stacks.js';
+import readBlueprintOnDisk from '../../actions/blueprints/read-blueprint.js';
+import { createStack, getStackByName, updateStack } from '../../actions/blueprints/stacks.js';
 import { stashAsset } from '../../actions/blueprints/stash-asset.js';
+import { green, red, yellow } from '../../utils/display/colors.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 { document } = readBlueprintOnDisk();
+        const { displayName, name, projectId, resources } = document;
         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);
+                const result = await stashAsset({ resource, projectId });
                 if (result.success) {
-                    resource.assetId = result.assetId;
-                    fnSpinner.stop(`✓ ${resource.name} (${result.assetId})`);
-                    this.log(`   Source: ${resource.src}`);
+                    const src = resource.src;
+                    resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
+                    fnSpinner.stop(`${green('✓')} ${resource.name} <${yellow(result.assetId)}>`);
+                    this.log(`   Source: ${src}`);
                 }
                 else {
-                    fnSpinner.stop(`✗ Failed to process ${resource.name}`);
+                    fnSpinner.stop(`${red('✗')} 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'}`);
+        s.start('Looking for existing stack...');
+        const { ok, error, stackId: existingStackId, } = await getStackByName({
+            name,
+            projectId,
+        });
+        if (!ok) {
+            s.stop(`${red('Failed')} to list stacks`);
+            this.log(`Error: ${error || '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;
-                }),
-            },
+            document: { resources },
         };
         this.debug('BLUEPRINT DOCUMENT:', blueprint);
-        // Create or update stack
-        const { ok, stack, error } = existingStack
-            ? await updateStack(existingStack.id, blueprint)
-            : await createStack(blueprint);
+        const { ok: deployOk, stack, error: deployError, } = existingStackId
+            ? await updateStack({ stackId: existingStackId, blueprint, projectId })
+            : await createStack({ blueprint, projectId });
         this.debug('STACK RESPONSE:', stack);
-        if (ok) {
-            s.stop(`Stack ${existingStack ? 'updated' : 'created'}! (${stack.id})`);
-            this.log('Use `blueprints info` to check deployment status');
+        if (deployOk) {
+            s.stop(`${green('Success!')} Stack ${existingStackId ? 'updated' : 'created'} <${yellow(stack.id)}>`);
+            this.log('\nUse `sanity blueprints info` to check deployment status');
         }
         else {
-            s.stop(`Failed to ${existingStack ? 'update' : 'create'} stack`);
-            this.log(`Error: ${error || 'Unknown error'}`);
+            this.debug('STACK ERROR RESPONSE:', stack);
+            s.stop(`${red('Failed')} to ${existingStackId ? 'update' : 'create'} stack`);
+            this.log(`Error: ${deployError || 'Unknown error'}`);
         }
     }
 }

package/dist/commands/blueprints/info.js

@@ -1,68 +1,74 @@
 import { Command } from '@oclif/core';
-import readBlueprint from '../../actions/blueprints/read-blueprint.js';
-import { getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import readBlueprintOnDisk from '../../actions/blueprints/read-blueprint.js';
+import { getStackByName } from '../../actions/blueprints/stacks.js';
+import { formatResourceTree, formatStacksList, formatTitle, } from '../../utils/display/blueprints-formatting.js';
+import { bold, green, red, yellow } from '../../utils/display/colors.js';
+import { formatDate, formatDuration } from '../../utils/display/dates.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 { document } = readBlueprintOnDisk();
+        const { displayName, name, projectId } = document;
         const s = new Spinner();
         if (!projectId) {
-            this.log(`No project for Blueprint "${displayName}"`);
+            this.log(`Cannot determine project for Blueprint "${displayName}"`);
             return;
         }
         s.start(`Retrieving info for "${displayName}"`);
         try {
-            const { ok, stacks, error } = await listStacks();
+            const { ok, stack, stackId: foundStackId, error, availableStacks, } = await getStackByName({
+                name,
+                projectId,
+            });
             if (!ok) {
-                s.stop('Failed to retrieve stacks');
+                s.stop(`${red('Failed')} to retrieve stacks`);
                 this.log(`Error: ${error || 'Unknown error'}`);
                 return;
             }
-            if (stacks.length === 0) {
-                s.stop(`No stacks found for Blueprint "${displayName}"`);
+            if (!foundStackId || !stack) {
+                s.stop(`${red('Failed')} to find Stack for ${formatTitle('Blueprint', displayName)}`);
+                if (availableStacks && availableStacks.length > 0) {
+                    this.log(formatStacksList(availableStacks));
+                }
                 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;
+            const foundStack = { id: foundStackId };
+            s.stop(`${formatTitle('Blueprint', displayName)} Info\n`);
+            this.log(`Stack name: ${bold(stack.name)}`);
+            this.log(`Stack ID: ${yellow(foundStack.id)}`);
+            if (stack.createdAt) {
+                this.log(`Created: ${formatDate(stack.createdAt)}`);
             }
-            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 (stack.updatedAt) {
+                this.log(`Updated: ${formatDate(stack.updatedAt)}`);
+            }
+            if (stack.recentOperation) {
+                const operation = stack.recentOperation;
+                if (operation.id) {
+                    this.log(`Recent Operation <${yellow(operation.id)}>:`);
                 }
-                if (otherResources.length > 0) {
-                    this.log(`└─Other Resources (${otherResources.length})`);
-                    for (const other of otherResources) {
-                        this.log(`    ├─ ${other.name || other.src}`);
-                    }
+                if (operation.status) {
+                    const operationColor = operation.status === 'COMPLETED' ? green : red;
+                    const status = operation.status || 'UNKNOWN';
+                    this.log(`  Status: ${operationColor(status)}`);
                 }
-            }
-            // 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 (operation.createdAt) {
+                    this.log(`  Started  : ${formatDate(operation.createdAt)}`);
                 }
-                if (stack.recentOperation.progress) {
-                    this.log(`Progress: ${stack.recentOperation.progress}`);
+                if (operation.status === 'COMPLETED' && operation.completedAt && operation.createdAt) {
+                    this.log(`  Completed: ${formatDate(operation.completedAt)}`);
+                    this.log(`  Duration: ${yellow(formatDuration(operation.createdAt, operation.completedAt))}`);
                 }
             }
+            this.log('');
+            if (stack?.resources) {
+                formatResourceTree(stack.resources, this.log.bind(this));
+            }
         }
         catch (err) {
-            s.stop('Failed to retrieve info');
+            s.stop('Failed to parse Stack info');
             if (err instanceof Error) {
                 this.log(`Error: ${err.message}`);
             }

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Logs extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        watch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/blueprints/logs.js

@@ -0,0 +1,166 @@
+import { Command, Flags } from '@oclif/core';
+import { getLogs, streamLogs } from '../../actions/blueprints/logs.js';
+import readBlueprintOnDisk from '../../actions/blueprints/read-blueprint.js';
+import { getStackByName } from '../../actions/blueprints/stacks.js';
+import config from '../../config.js';
+import { formatStacksList, formatTitle } from '../../utils/display/blueprints-formatting.js';
+import { blue, bold, green, red, yellow } from '../../utils/display/colors.js';
+import Spinner from '../../utils/spinner.js';
+export default class Logs extends Command {
+    static description = 'Display logs for a Blueprint stack';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --stack-id <stack-id>',
+        '<%= config.bin %> <%= command.id %> --watch',
+    ];
+    static flags = {
+        'stack-id': Flags.string({
+            char: 's',
+            description: 'Stack ID to fetch logs for (optional if running in a blueprint directory)',
+            required: false,
+        }),
+        watch: Flags.boolean({
+            char: 'w',
+            description: 'Watch for new logs (streaming mode)',
+            required: false,
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Logs);
+        const s = new Spinner();
+        const watchMode = flags.watch;
+        try {
+            const { document } = readBlueprintOnDisk();
+            const { name, displayName, projectId } = document;
+            if (!projectId) {
+                this.log('Cannot determine project ID for this Blueprint');
+                return;
+            }
+            let stackId = flags['stack-id'];
+            if (!stackId) {
+                s.start(`Finding stack for blueprint "${displayName}"`);
+                const { ok, stackId: foundStackId, error, availableStacks, } = await getStackByName({
+                    name,
+                    projectId,
+                });
+                if (!ok) {
+                    s.stop(`${red('Failed')} to retrieve stacks`);
+                    this.log(`Error: ${error || 'Unknown error'}`);
+                    return;
+                }
+                if (!foundStackId) {
+                    s.stop(`${red('Failed')} to find Stack for ${formatTitle('Blueprint', displayName)}`);
+                    if (availableStacks && availableStacks.length > 0) {
+                        this.log(formatStacksList(availableStacks));
+                    }
+                    return;
+                }
+                stackId = foundStackId;
+                s.stop(`Found stack ${stackId} for blueprint "${displayName}"`);
+            }
+            if (!stackId) {
+                s.stop(`${red('Failed')} to determine stack ID`);
+                return;
+            }
+            if (watchMode) {
+                // recent logs
+                s.start(`Fetching recent logs for stack ${stackId}`);
+                const { ok, logs, error } = await getLogs(stackId, projectId, config.token);
+                if (!ok) {
+                    s.stop(`${red('Failed')} to retrieve logs`);
+                    this.log(`Error: ${error || 'Unknown error'}`);
+                    return;
+                }
+                s.stop(`${formatTitle('Blueprint', displayName)} ${bold('Live')} Logs`);
+                if (logs.length > 0) {
+                    this.log('\nMost recent logs:');
+                    const sortedLogs = [...logs].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+                    const recentLogs = sortedLogs.slice(-10);
+                    for (const log of recentLogs) {
+                        const date = new Date(log.timestamp);
+                        const time = date.toLocaleTimeString();
+                        const day = date.toLocaleDateString();
+                        this.log(`  ${bold(day)} ${yellow(time)} ${log.message}`);
+                    }
+                }
+                else {
+                    this.log(`No recent logs found for stack ${yellow(stackId)}`);
+                }
+                const onOpen = () => {
+                    this.log(`\n${bold('Watching')} for new logs...`);
+                    this.log(`Press ${bold('Ctrl+C')} to stop\n`);
+                };
+                let newestTimestamp = 0;
+                if (logs.length > 0) {
+                    for (const log of logs) {
+                        const timestamp = new Date(log.timestamp).getTime();
+                        if (timestamp > newestTimestamp) {
+                            newestTimestamp = timestamp;
+                        }
+                    }
+                }
+                const renderLog = (log) => {
+                    const logTimestamp = new Date(log.timestamp).getTime();
+                    if (logTimestamp <= newestTimestamp) {
+                        return;
+                    }
+                    newestTimestamp = logTimestamp;
+                    const date = new Date(log.timestamp);
+                    const time = date.toLocaleTimeString();
+                    const day = date.toLocaleDateString();
+                    this.log(`${green('>')} ${bold(day)} ${yellow(time)} ${log.message}`);
+                };
+                this.debug(`${yellow('Debug:')} Connecting to streaming endpoint for stack ${stackId}...`);
+                streamLogs(stackId, projectId, config.token, renderLog, onOpen, (error) => this.log(`${red('Error:')} ${error}`));
+                return new Promise(() => {
+                    // hold the line until the user terminates with Ctrl+C
+                });
+            }
+            s.start(`Fetching logs for stack ${stackId}`);
+            const { ok, logs, error } = await getLogs(stackId, projectId, config.token);
+            if (!ok) {
+                s.stop(`${red('Failed')} to retrieve logs`);
+                this.log(`Error: ${error || 'Unknown error'}`);
+                return;
+            }
+            if (logs.length === 0) {
+                s.stop(`No logs found for stack ${stackId}`);
+                return;
+            }
+            s.stop(`${formatTitle('Blueprint', displayName)} Logs`);
+            this.log(`Found ${bold(logs.length.toString())} log entries for stack ${yellow(stackId)}\n`);
+            const logsByDay = new Map();
+            for (const log of logs) {
+                const date = new Date(log.timestamp);
+                const day = date.toLocaleDateString();
+                if (!logsByDay.has(day)) {
+                    logsByDay.set(day, []);
+                }
+                logsByDay.get(day)?.push(log);
+            }
+            const sortedDays = Array.from(logsByDay.keys()).sort((a, b) => {
+                return new Date(a).getTime() - new Date(b).getTime();
+            });
+            for (const day of sortedDays) {
+                this.log(`${blue('Date:')} ${bold(day)}`);
+                const dayLogs = logsByDay.get(day) || [];
+                dayLogs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+                for (const [i, log] of dayLogs.entries()) {
+                    const date = new Date(log.timestamp);
+                    const time = date.toLocaleTimeString();
+                    const isLast = i === dayLogs.length - 1;
+                    this.log(`  ${isLast ? '└─' : '├─'} ${yellow(time)} ${log.message}`);
+                }
+                // new line between days
+                this.log('');
+            }
+        }
+        catch (err) {
+            s.stop('Failed to retrieve logs');
+            if (err instanceof Error) {
+                this.log(`Error: ${err.message}`);
+            }
+        }
+    }
+}

package/dist/commands/blueprints/plan.js

@@ -1,31 +1,18 @@
 import { Command } from '@oclif/core';
-import readBlueprint from '../../actions/blueprints/read-blueprint.js';
+import readBlueprintOnDisk from '../../actions/blueprints/read-blueprint.js';
+import { formatResourceTree, formatTitle } from '../../utils/display/blueprints-formatting.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');
+        const { document, fileName } = readBlueprintOnDisk();
+        const { displayName, name, resources } = document;
+        this.log(`${formatTitle('Blueprint', displayName)} Plan\n`);
+        this.log(`Blueprint document: "${name}" (${fileName})`);
+        this.log('');
+        formatResourceTree(resources, this.log.bind(this));
+        if (resources.length > 0) {
+            this.log('\nRun `sanity blueprints deploy` to deploy these changes');
         }
     }
 }

package/dist/config.js

@@ -9,8 +9,8 @@ const functionsUrls = {
     default: 'http://localhost:4567',
 };
 const blueprintsUrls = {
-    production: 'https://api.sanity.io/',
-    staging: 'https://api.sanity.work/',
+    production: 'https://api.sanity.io',
+    staging: 'https://api.sanity.work',
     default: 'http://localhost:4567',
 };
 const functionsUrl = new URL(functionsUrls[nodeEnv] ?? functionsUrls.default);

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

@@ -0,0 +1,4 @@
+import type { BlueprintResource } from '../types.js';
+export declare function formatTitle(title: string, name: string): string;
+export declare function formatStacksList(stacks: string[]): string;
+export declare function formatResourceTree(resources: BlueprintResource[], logger: (msg: string) => void): void;

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

@@ -0,0 +1,42 @@
+import { blue, bold, boldnblue, green, yellow } from './colors.js';
+export function formatTitle(title, name) {
+    return `${boldnblue(title)} ${bold(`"${name}"`)}`;
+}
+export function formatStacksList(stacks) {
+    if (!stacks || stacks.length === 0) {
+        return 'No stacks found';
+    }
+    let result = '\nFound Stacks:\n';
+    for (const name of stacks) {
+        result += `  ${name}\n`;
+    }
+    return result;
+}
+export function formatResourceTree(resources, logger) {
+    if (!resources || resources.length === 0) {
+        logger('  No resources in this stack');
+        return;
+    }
+    logger(`${blue('Stack Resources')} [${resources.length}]`);
+    const functionResources = resources.filter((r) => r.kind === 'function');
+    const otherResources = resources.filter((r) => r.kind !== 'function');
+    const hasOtherResources = otherResources.length > 0;
+    if (functionResources.length > 0) {
+        logger(`  ${hasOtherResources ? '├─' : '└─'} ${bold('Functions')} [${functionResources.length}]`);
+        for (const [i, fn] of functionResources.entries()) {
+            const isLast = i === functionResources.length - 1;
+            const prefix = hasOtherResources ? '│' : ' ';
+            const connector = isLast ? '└─' : '├─';
+            const name = green(fn.displayName || fn.name);
+            const externalId = fn.externalId ? `Fn<${yellow(fn.externalId)}>` : '';
+            logger(`  ${prefix}   ${connector} "${name}" ${externalId}`);
+        }
+    }
+    if (hasOtherResources) {
+        logger(`  └─ ${bold('Other Resources')} [${otherResources.length}]`);
+        for (const [i, other] of otherResources.entries()) {
+            const isLast = i === otherResources.length - 1;
+            logger(`      ${isLast ? '└─' : '├─'} "${yellow(other.displayName || other.name || other.src)}"`);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare function bold(str: string): string;
+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;

package/dist/utils/display/colors.js

@@ -0,0 +1,18 @@
+export function bold(str) {
+    return `\x1b[1m${str}\x1b[0m`;
+}
+export function blue(str) {
+    return `\x1b[34m${str}\x1b[0m`;
+}
+export function green(str) {
+    return `\x1b[32m${str}\x1b[0m`;
+}
+export function red(str) {
+    return `\x1b[31m${str}\x1b[0m`;
+}
+export function yellow(str) {
+    return `\x1b[33m${str}\x1b[0m`;
+}
+export function boldnblue(str) {
+    return bold(blue(str));
+}

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

@@ -0,0 +1,2 @@
+export declare function formatDate(dateString: string): string;
+export declare function formatDuration(startDate: string, endDate: string): string;

package/dist/utils/display/dates.js

@@ -0,0 +1,26 @@
+export function formatDate(dateString) {
+    const date = new Date(dateString);
+    return date.toLocaleString();
+}
+export function formatDuration(startDate, endDate) {
+    const start = new Date(startDate).getTime();
+    const end = new Date(endDate).getTime();
+    if (start > end) {
+        return 'Invalid duration';
+    }
+    const durationMs = end - start;
+    if (durationMs < 1000) {
+        return `${durationMs}ms`;
+    }
+    if (durationMs < 60000) {
+        return `${Math.round(durationMs / 1000)}s`;
+    }
+    if (durationMs < 3600000) {
+        const minutes = Math.floor(durationMs / 60000);
+        const seconds = Math.floor((durationMs % 60000) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+    const hours = Math.floor(durationMs / 3600000);
+    const minutes = Math.floor((durationMs % 3600000) / 60000);
+    return `${hours}h ${minutes}m`;
+}

package/dist/utils/types.d.ts

@@ -48,17 +48,36 @@ export interface BlueprintJob {
  * @internal
  */
 export interface BlueprintResource {
+    id: string;
+    displayName: string;
     name: string;
     kind: string;
     src: string;
-    assetId: string;
+    externalId: string;
 }
 /**
  * @internal
  */
+export interface BlueprintOperation {
+    id: string;
+    status: string;
+    createdAt?: string;
+    completedAt?: string;
+}
 export interface BlueprintStack {
+    id: string;
     name: string;
-    kind: string;
-    src: string;
+    displayName: string;
+    resources: Array<BlueprintResource>;
+    createdAt?: string;
+    updatedAt?: string;
+    recentOperation?: BlueprintOperation;
+}
+/**
+ * @internal
+ */
+export interface BlueprintLog {
+    timestamp: string;
+    message: string;
 }
 export {};

package/oclif.manifest.json

@@ -48,6 +48,50 @@
         "info.js"
       ]
     },
+    "blueprints:logs": {
+      "aliases": [],
+      "args": {},
+      "description": "Display logs for a Blueprint stack",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> --stack-id <stack-id>",
+        "<%= config.bin %> <%= command.id %> --watch"
+      ],
+      "flags": {
+        "stack-id": {
+          "char": "s",
+          "description": "Stack ID to fetch logs for (optional if running in a blueprint directory)",
+          "name": "stack-id",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "watch": {
+          "char": "w",
+          "description": "Watch for new logs (streaming mode)",
+          "name": "watch",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "blueprints:logs",
+      "pluginAlias": "@sanity/runtime-cli",
+      "pluginName": "@sanity/runtime-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "blueprints",
+        "logs.js"
+      ]
+    },
     "blueprints:plan": {
       "aliases": [],
       "args": {},
@@ -247,5 +291,5 @@
       ]
     }
   },
-  "version": "1.2.1"
+  "version": "1.3.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "A new CLI generated with oclif",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,8 @@
     "sanity": "./bin/run.js"
   },
   "scripts": {
-    "build": "rollup -c && shx rm -rf dist && tsc -b && npm run build:static",
+    "build": "rollup -c && npm run build:bin && npm run build:static",
+    "build:bin": "shx rm -rf dist && tsc -b",
     "build:static": "npm run copy:wrapper && npm run copy:server",
     "copy:server": "shx cp -r ./src/server/static ./dist/server/static",
     "copy:wrapper": "shx cp ./src/utils/child-process-wrapper.js ./dist/utils/child-process-wrapper.js",
@@ -38,6 +39,7 @@
     "@oclif/core": "^4",
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
+    "eventsource": "^3.0.5",
     "jszip": "^3.10.1",
     "mime-types": "^2.1.35",
     "xdg-basedir": "^5.1.0"