@sanity/runtime-cli 1.2.0 → 1.3.0

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

@@ -1,3 +1,2 @@
-import { Hono } from 'hono';
-declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+declare const app: (port: number) => void;
 export default app;

package/dist/server/app.js

@@ -1,36 +1,66 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { cwd } from 'node:process';
-import { serveStatic } from '@hono/node-server/serve-static';
-import { Hono } from 'hono';
+import { default as mime } from 'mime-types';
 import invoke from '../utils/invoke-local.js';
-import isDependency from '../utils/is-dependency.js';
-function errorResponse(code, message, details = {}) {
-    return { error: { code, details, message } };
-}
-function getStaticPath() {
-    return isDependency('./server/static')
-        ? './node_modules/@sanity/runtime-cli/dist/server/static'
-        : './src/server/static';
-}
-const app = new Hono();
-app.use('*', serveStatic({ root: getStaticPath() }));
-app.get('/blueprint', async (c) => {
-    const response = JSON.parse(readFileSync(join(cwd(), './blueprint.json')).toString());
-    return c.json(response);
-});
-app.post('/invoke', async (c) => {
-    const { data = {}, func } = await c.req.json();
-    const response = await invoke(func, { data: JSON.parse(data) });
-    return c.json(response);
-});
-app
-    .notFound((c) => c.json(errorResponse('NOT_FOUND', 'Not Found', {
-    method: c.req.method,
-    path: c.req.path,
-}), 404))
-    .onError((err, c) => c.json(errorResponse('INTERNAL_SERVER_ERROR', 'Internal Server Error', {
-    error: err.message,
-    stack: err,
-}), 500));
+import * as http from 'node:http';
+const host = 'localhost';
+const app = (port) => {
+    const requestListener = async (req, res) => {
+        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);
+                break;
+            }
+            case '/invoke': {
+                if (req.method === 'POST') {
+                    let body = '';
+                    req.on('data', (data) => {
+                        body += data;
+                    });
+                    req.on('end', async () => {
+                        const { data, func } = JSON.parse(body);
+                        res.setHeader('Content-Type', 'application/json');
+                        try {
+                            const response = await invoke(func, { data: JSON.parse(data) });
+                            res.writeHead(200);
+                            res.end(JSON.stringify(response));
+                        }
+                        catch (error) {
+                            const response = { logs: '', error: '' };
+                            if (error instanceof Error) {
+                                response.logs = error.message;
+                            }
+                            res.writeHead(200);
+                            res.end(JSON.stringify(response));
+                        }
+                    });
+                }
+                break;
+            }
+            default: {
+                const requestPath = req.url?.endsWith('/') ? `${req.url}index.html` : req.url;
+                const filePath = new URL(`./static${requestPath}`, import.meta.url).pathname;
+                if (existsSync(filePath)) {
+                    const mimeType = mime.lookup(filePath) || 'text/plain';
+                    res.setHeader('Content-Type', mimeType);
+                    const content = readFileSync(filePath).toString();
+                    res.writeHead(200);
+                    res.end(content);
+                }
+                else {
+                    res.writeHead(404);
+                    res.end();
+                }
+                break;
+            }
+        }
+    };
+    const server = http.createServer(requestListener);
+    server.listen(port, host, () => { });
+};
 export default app;

package/dist/server/static/vendor/vendor.bundle.js

@@ -8787,14 +8787,14 @@ function scrollRectIntoView(dom, rect, side, x, y, xMargin, yMargin, ltr) {
             let moveX = 0, moveY = 0;
             if (y == "nearest") {
                 if (rect.top < bounding.top) {
-                    moveY = -(bounding.top - rect.top + yMargin);
+                    moveY = rect.top - (bounding.top + yMargin);
                     if (side > 0 && rect.bottom > bounding.bottom + moveY)
-                        moveY = rect.bottom - bounding.bottom + moveY + yMargin;
+                        moveY = rect.bottom - bounding.bottom + yMargin;
                 }
                 else if (rect.bottom > bounding.bottom) {
                     moveY = rect.bottom - bounding.bottom + yMargin;
                     if (side < 0 && (rect.top - moveY) < bounding.top)
-                        moveY = -(bounding.top + moveY - rect.top + yMargin);
+                        moveY = rect.top - (bounding.top + yMargin);
                 }
             }
             else {
@@ -8806,14 +8806,14 @@ function scrollRectIntoView(dom, rect, side, x, y, xMargin, yMargin, ltr) {
             }
             if (x == "nearest") {
                 if (rect.left < bounding.left) {
-                    moveX = -(bounding.left - rect.left + xMargin);
+                    moveX = rect.left - (bounding.left + xMargin);
                     if (side > 0 && rect.right > bounding.right + moveX)
-                        moveX = rect.right - bounding.right + moveX + xMargin;
+                        moveX = rect.right - bounding.right + xMargin;
                 }
                 else if (rect.right > bounding.right) {
                     moveX = rect.right - bounding.right + xMargin;
                     if (side < 0 && rect.left < bounding.left + moveX)
-                        moveX = -(bounding.left + moveX - rect.left + xMargin);
+                        moveX = rect.left - (bounding.left + xMargin);
                 }
             }
             else {
@@ -8848,6 +8848,10 @@ function scrollRectIntoView(dom, rect, side, x, y, xMargin, yMargin, ltr) {
             }
             if (top)
                 break;
+            if (rect.top < bounding.top || rect.bottom > bounding.bottom ||
+                rect.left < bounding.left || rect.right > bounding.right)
+                rect = { left: Math.max(rect.left, bounding.left), right: Math.min(rect.right, bounding.right),
+                    top: Math.max(rect.top, bounding.top), bottom: Math.min(rect.bottom, bounding.bottom) };
             cur = cur.assignedSlot || cur.parentNode;
         }
         else if (cur.nodeType == 11) { // A shadow root
@@ -23360,7 +23364,15 @@ function createLineDialog(view) {
             event.preventDefault();
             go();
         }
-    }, crelt("label", view.state.phrase("Go to line"), ": ", input), " ", crelt("button", { class: "cm-button", type: "submit" }, view.state.phrase("go")));
+    }, crelt("label", view.state.phrase("Go to line"), ": ", input), " ", crelt("button", { class: "cm-button", type: "submit" }, view.state.phrase("go")), crelt("button", {
+        name: "close",
+        onclick: () => {
+            view.dispatch({ effects: dialogEffect.of(false) });
+            view.focus();
+        },
+        "aria-label": view.state.phrase("close"),
+        type: "button"
+    }, ["×"]));
     function go() {
         let match = /^([+-])?(\d+)?(:\d+)?(%)?$/.exec(input.value);
         if (!match)
@@ -23424,7 +23436,17 @@ const gotoLine = view => {
 const baseTheme$1$1 = /*@__PURE__*/EditorView.baseTheme({
     ".cm-panel.cm-gotoLine": {
         padding: "2px 6px 4px",
-        "& label": { fontSize: "80%" }
+        position: "relative",
+        "& label": { fontSize: "80%" },
+        "& [name=close]": {
+            position: "absolute",
+            top: "0", bottom: "0",
+            right: "4px",
+            backgroundColor: "inherit",
+            border: "none",
+            font: "inherit",
+            padding: "0"
+        }
     }
 });
 

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;