@sanity/runtime-cli 1.2.1 → 1.3.1

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/server/app.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { cwd } from 'node:process';
 import { default as mime } from 'mime-types';
+import readBlueprintOnDisk from '../actions/blueprints/read-blueprint.js';
 import invoke from '../utils/invoke-local.js';
 import * as http from 'node:http';
 const host = 'localhost';
@@ -10,10 +9,16 @@ const app = (port) => {
         res.setHeader('Content-Type', 'application/json');
         switch (req.url) {
             case '/blueprint': {
-                res.setHeader('Content-Type', 'application/json');
-                const blueprint = readFileSync(join(cwd(), './blueprint.json')).toString();
-                res.writeHead(200);
-                res.end(blueprint);
+                try {
+                    const blueprint = readBlueprintOnDisk();
+                    res.setHeader('Content-Type', 'application/json');
+                    res.writeHead(200);
+                    res.end(JSON.stringify(blueprint));
+                }
+                catch {
+                    res.writeHead(404);
+                    res.end();
+                }
                 break;
             }
             case '/invoke': {

package/dist/server/static/api.js

@@ -42,9 +42,12 @@ function blueprint() {
   fetch('/blueprint')
     .then((response) => response.json())
     .then((json) => {
-      const functions = json?.resources.filter((resource) => resource.kind === 'function')
+      const functions = json?.document?.resources.filter((resource) => resource.kind === 'function')
 
       store.functions = functions
       store.selectedIndex = functions[0].src
     })
+    .catch(() => {
+      store.functions = []
+    })
 }

package/dist/server/static/components/function-list.js

@@ -15,18 +15,23 @@ class FunctionList extends ApiBaseElement {
     this.api.store.selectedIndex = event.srcElement.value
   }
   renderFunctions = () => {
-    this.list.innerHTML = this.api.store.functions
-      .map((func) => {
-        const selected = this.api.store.selectedIndex === func.src ? 'selected' : ''
-        return `<li class="pad-sm ${selected}">${func.name}</li>`
-      })
-      .join('')
-    this.select.innerHTML = this.api.store.functions
-      .map((func) => {
-        const selected = this.api.store.selectedIndex === func.src ? 'selected' : ''
-        return `<option value="${func.src}" ${selected}>${func.name}</option>`
-      })
-      .join('')
+    if (this.api.store.functions.length > 0) {
+      this.list.innerHTML = this.api.store.functions
+        .map((func) => {
+          const selected = this.api.store.selectedIndex === func.src ? 'selected' : ''
+          return `<li class="pad-sm ${selected}">${func.name}</li>`
+        })
+        .join('')
+      this.select.innerHTML = this.api.store.functions
+        .map((func) => {
+          const selected = this.api.store.selectedIndex === func.src ? 'selected' : ''
+          return `<option value="${func.src}" ${selected}>${func.name}</option>`
+        })
+        .join('')
+    } else {
+      this.list.innerHTML = '<option class="pad-sm">No blueprint.json file found</li>'
+      this.select.innerHTML = '<option>No blueprint.json file found</option>'
+    }
   }
 
   connectedCallback() {

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.1"
 }