@sanity/runtime-cli 17.12.1 → 17.13.0-next.g2501ffa

package/dist/utils/blueprints/deploy-metadata.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Facts about the environment that runs a deploy.
+ * Sent as the `client` part of deploy metadata. Keys with an `undefined` value drop out of the JSON body.
+ */
+export declare function getClientMetadata({ cliVersion, dir, }: {
+    /** Version of the CLI that hosts this plugin, when known */
+    cliVersion?: string;
+    /** Directory of the Blueprint file, used to detect the package manager */
+    dir: string;
+}): Record<string, unknown>;

package/dist/utils/blueprints/deploy-metadata.js

@@ -0,0 +1,17 @@
+import { platform, versions } from 'node:process';
+import config, { RUNTIME_CLI_VERSION } from '../../config.js';
+import { detectPackageManager } from '../package-manager.js';
+/**
+ * Facts about the environment that runs a deploy.
+ * Sent as the `client` part of deploy metadata. Keys with an `undefined` value drop out of the JSON body.
+ */
+export function getClientMetadata({ cliVersion, dir, }) {
+    return {
+        cliVersion,
+        runtimeCliVersion: RUNTIME_CLI_VERSION,
+        nodeVersion: versions.node,
+        nodePackageManager: detectPackageManager(dir),
+        platform,
+        ci: config.isCi,
+    };
+}

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

@@ -4,6 +4,7 @@ import type { DeploymentPlan } from '../../actions/blueprints/stacks.js';
 import { type BlueprintResourceRecord, type Stack, type StackSummary } from '../types.js';
 export declare function formatTitle(title: string, name: string): string;
 export declare function formatDeployedResourceTree(resources: BlueprintResourceRecord[] | undefined, verbose?: boolean): string;
+export declare function formatStudioUrls(resources: BlueprintResourceRecord[] | undefined): string[];
 export declare function formatResourceTree(resources: BlueprintResource[] | undefined, verbose?: boolean): string;
 export declare function formatStackInfo(stack: Stack | StackSummary | Blueprint, isCurrentStack?: boolean): string;
 export declare function formatStacksListing(stacks: StackSummary[], currentStackId?: string): string;

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

@@ -1,10 +1,10 @@
+import { formatDateTime, formatElapsed } from '@sanity/cli-core/dates';
 import { treeify } from 'array-treeify';
 import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, SANITY_STUDIO, } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isStudioResource, isWebhookResource, } from '../types.js';
-import { formatDateTime, formatDuration } from './dates.js';
 import { capitalize, niceId, renderSection } from './presenters.js';
-import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyStudio, arrayifyWebhook, } from './resources-formatting.js';
+import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyStudio, arrayifyWebhook, studioHost, studioUrl, } from './resources-formatting.js';
 const functionCategory = {
     label: 'Functions',
     displayNameAttribute: 'displayName',
@@ -165,6 +165,19 @@ export function formatDeployedResourceTree(resources, verbose = false) {
     (res) => ({ name: res.name, type: res.type, ...(res.resolvedParameters ?? res.parameters) }), verbose);
     return `${treeify(output)}\n`;
 }
+export function formatStudioUrls(resources) {
+    if (!resources)
+        return [];
+    const lines = [];
+    for (const res of resources) {
+        if (res.type !== SANITY_STUDIO)
+            continue;
+        const host = studioHost(res.resolvedParameters ?? res.parameters);
+        if (host)
+            lines.push(`Studio ${styleText(['bold', 'green'], res.name)} ${studioUrl(host)}`);
+    }
+    return lines;
+}
 export function formatResourceTree(resources, verbose = false) {
     if (!resources || resources.length === 0)
         return '  Zero resources';
@@ -207,7 +220,8 @@ export function formatStackInfo(stack, isCurrentStack = false) {
         if (time)
             parts.push(styleText('dim', formatDateTime(time)));
         if (op.completedAt && op.createdAt) {
-            parts.push(styleText('yellow', `(${formatDuration(op.createdAt, op.completedAt)})`));
+            const duration = new Date(op.completedAt).getTime() - new Date(op.createdAt).getTime();
+            parts.push(styleText('yellow', `(${formatElapsed(duration)})`));
         }
         rows.push(['Operation', parts.join('  ')]);
         if (op.userMessage)

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

@@ -1,6 +1,4 @@
 type DateInput = string | number | Date;
 export declare function formatDate(input: DateInput): string;
 export declare function formatTime(input: DateInput): string;
-export declare function formatDateTime(input: DateInput): string;
-export declare function formatDuration(startDate: string, endDate: string): string;
 export {};

package/dist/utils/display/dates.js

@@ -19,28 +19,3 @@ export function formatTime(input) {
     const s = String(d.getSeconds()).padStart(2, '0');
     return `${h}:${m}:${s}`;
 }
-export function formatDateTime(input) {
-    const d = toDate(input);
-    if (Number.isNaN(d.getTime()))
-        return '';
-    return `${formatDate(d)} ${formatTime(d)}`;
-}
-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/display/functions-formatting.js

@@ -1,6 +1,6 @@
+import { formatDateTime } from '@sanity/cli-core/dates';
 import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
 import { styleText } from '../style-text.js';
-import { formatDateTime } from './dates.js';
 import { niceId, renderSection } from './presenters.js';
 export function formatFunctionsList(functions, options = {}) {
     if (!options.verbose)

package/dist/utils/display/prompt.js

@@ -1,10 +1,13 @@
 import { confirm, input, Separator, select } from '@inquirer/prompts';
 import { createEmptyStack, listStacks } from '../../actions/blueprints/stacks.js';
 import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { STACKS_DOCS_URL } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { niceId } from './presenters.js';
 // --- Wizard infrastructure ---
 export const BACK = Symbol('back');
+/** Shown under the highlighted Stack choice; a printed line would break the wizard's two-line erase on Back */
+const STACK_DEFINITION = `A Stack is the deployed copy of a Blueprint: the live resources on Sanity's side. ${STACKS_DOCS_URL}`;
 /** Thrown when the user picks "Cancel" in a prompt. Cores translate it to a clean result. */
 export class CancelledError extends Error {
     constructor(message = 'Cancelled by user.') {
@@ -270,7 +273,7 @@ export async function promptForStack({ scopeType, scopeId, token, logger, allowB
     if (stacks.length > 0) {
         const stackChoices = [
             new Separator(styleText('underline', 'Create a new Stack:')),
-            { name: styleText('bold', 'New Stack'), value: NEW_STACK_ID },
+            { name: styleText('bold', 'New Stack'), value: NEW_STACK_ID, description: STACK_DEFINITION },
             new Separator(styleText('underline', 'Use an existing Stack:')),
             ...stacks.map((s) => ({
                 name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} ${s.resourceCount === 1 ? 'resource' : 'resources'})`)}`,
@@ -301,7 +304,7 @@ export async function promptForStack({ scopeType, scopeId, token, logger, allowB
                 {
                     name: 'Create the first Stack',
                     value: NEW_STACK_ID,
-                    description: 'A Blueprint needs a Stack before it can deploy',
+                    description: STACK_DEFINITION,
                 },
                 { name: 'Cancel', value: CANCEL, description: 'Stop here and change nothing' },
             ], allowBack),

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

@@ -5,5 +5,11 @@ export declare function arrayifyDataset(resource: BlueprintDatasetResource): Tre
 export declare function arrayifyFunction(fn: BlueprintResource): TreeInput;
 export declare function arrayifyRobot(resource: BlueprintRobotResource): TreeInput;
 export declare function arrayifyRole(resource: BlueprintRoleResource): TreeInput;
+/**
+ * Hostname label of a Studio: the resolved `appHost` when present, else the authored `slug`.
+ * undefined when a `$.resources` reference
+ */
+export declare function studioHost(params: Record<string, unknown>): string | undefined;
+export declare function studioUrl(host: string): string;
 export declare function arrayifyStudio(resource: BlueprintStudioResource): TreeInput;
 export declare function arrayifyWebhook(resource: BlueprintDocumentWebhookResource): TreeInput;

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

@@ -1,3 +1,4 @@
+import config from '../../config.js';
 import { hasEventSource, isLocalFunctionResource, isScheduleEvent, } from '../../utils/types.js';
 import { styleText } from '../style-text.js';
 import { niceId } from './presenters.js';
@@ -120,8 +121,24 @@ export function arrayifyRole(resource) {
     }
     return details;
 }
+/**
+ * Hostname label of a Studio: the resolved `appHost` when present, else the authored `slug`.
+ * undefined when a `$.resources` reference
+ */
+export function studioHost(params) {
+    const host = params.appHost ?? params.slug;
+    if (typeof host !== 'string' || host.length === 0 || host.startsWith('$.'))
+        return undefined;
+    return host;
+}
+export function studioUrl(host) {
+    return `https://${host}.${config.studioDomain}`;
+}
 export function arrayifyStudio(resource) {
     const details = [formatLabeledValue('appHost', resource.slug)];
+    const host = studioHost(resource);
+    if (host)
+        details.push(formatLabeledValue('url', studioUrl(host)));
     if (resource.project)
         details.push(formatLabeledValue('project', niceId(resource.project)));
     return details;

package/dist/utils/functions/dependency-info.d.ts

@@ -0,0 +1,30 @@
+/** Where a function's dependency list came from. */
+export type DependencySource = 'manifest' | 'autoinstall' | 'bundled' | 'none';
+export type DependencyInfo = {
+    dependencySource: DependencySource;
+    dependencyCount: number;
+    /** Declared versions */
+    dependencies?: Record<string, string>;
+    /** Source files the Arc treeshaker parsed - autoinstall only */
+    parsedFileCount?: number;
+};
+/** The package.json Architect generates during autoinstall. */
+export type AutoInstallManifest = {
+    dependencies?: Record<string, string>;
+    _parsed?: string[];
+};
+/**
+ * Read and delete the manifest Architect generated during autoinstall.
+ * Arc moves it to `node_modules/_arc-autoinstall/` after the install.
+ * Has a timestamp, so it must be deleted to avoid hash changes on every deploy.
+ */
+export declare function takeAutoInstallManifest(installDir: string): Promise<AutoInstallManifest | undefined>;
+/**
+ * Describe a function's dependencies from the manifest that declared them.
+ * The user's own package.json wins. Otherwise the Architect autoinstall manifest is used.
+ */
+export declare function getDependencyInfo({ sourceDir, autoInstall, bundled, }: {
+    sourceDir: string;
+    autoInstall?: AutoInstallManifest;
+    bundled: boolean;
+}): Promise<DependencyInfo>;

package/dist/utils/functions/dependency-info.js

@@ -0,0 +1,57 @@
+import { readFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Read and delete the manifest Architect generated during autoinstall.
+ * Arc moves it to `node_modules/_arc-autoinstall/` after the install.
+ * Has a timestamp, so it must be deleted to avoid hash changes on every deploy.
+ */
+export async function takeAutoInstallManifest(installDir) {
+    const file = path.join(installDir, 'node_modules', '_arc-autoinstall', 'package.json');
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        // no autoinstall happened, or the file is unreadable
+    }
+    try {
+        await rm(file, { force: true });
+    }
+    catch {
+        // best effort
+    }
+    return manifest;
+}
+/**
+ * Describe a function's dependencies from the manifest that declared them.
+ * The user's own package.json wins. Otherwise the Architect autoinstall manifest is used.
+ */
+export async function getDependencyInfo({ sourceDir, autoInstall, bundled, }) {
+    const declared = await readDeclaredDependencies(sourceDir);
+    if (declared && Object.keys(declared).length > 0) {
+        return {
+            dependencySource: 'manifest',
+            dependencyCount: Object.keys(declared).length,
+            dependencies: declared,
+        };
+    }
+    if (autoInstall) {
+        const dependencies = autoInstall.dependencies ?? {};
+        return {
+            dependencySource: 'autoinstall',
+            dependencyCount: Object.keys(dependencies).length,
+            dependencies,
+            parsedFileCount: autoInstall._parsed?.length,
+        };
+    }
+    return { dependencySource: bundled ? 'bundled' : 'none', dependencyCount: 0 };
+}
+async function readDeclaredDependencies(dir) {
+    try {
+        const pkg = JSON.parse(await readFile(path.join(dir, 'package.json'), 'utf8'));
+        return pkg.dependencies;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/utils/functions/prepare-asset.js

@@ -1,8 +1,9 @@
 import fs, { existsSync } from 'node:fs';
-import { rm, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import AdmZip from 'adm-zip';
 import { CONVERT_BYTES_TO_MB, MAX_ASSET_SIZE } from '../../constants.js';
+import { getDependencyInfo, takeAutoInstallManifest, } from './dependency-info.js';
 import { detectNativeModules, errorMessage } from './detect-native-modules.js';
 import { isFolderLargerThan } from './is-folder-larger-than.js';
 import { resolveResourceDependencies } from './resolve-dependencies.js';
@@ -16,6 +17,8 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
     let functionPath = resolvedFunctionPath;
     let cleanup = async () => { };
     let wasBundled = false;
+    let dependenciesInstalled = false;
+    let autoInstall;
     const shouldTranspile = await shouldTranspileFunction(resource, functionPath);
     if (shouldTranspile.transpile) {
         try {
@@ -42,7 +45,8 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
             transpiled: shouldTranspile.transpile,
             installer,
         });
-        await removeArcAutoInstallPackageJson(functionPath);
+        autoInstall = await takeAutoInstallManifest(functionPath);
+        dependenciesInstalled = true;
     }
     if (existsSync(path.join(functionPath, 'node_modules'))) {
         const modulesPath = path.join(functionPath, 'node_modules');
@@ -72,6 +76,17 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
             fileExtension: 'zip',
             assetParameter: 'src',
             cleanup,
+            metadata: {
+                transpiled: shouldTranspile.transpile,
+                bundled: wasBundled,
+                dependenciesInstalled,
+                ...(await getDependencyInfo({
+                    sourceDir: resolvedFunctionPath,
+                    autoInstall,
+                    bundled: wasBundled,
+                })),
+                assetBytes: zipEntrySize,
+            },
         };
     }
     catch (err) {
@@ -98,19 +113,3 @@ export async function pathToZip(path) {
         zip.addLocalFile(path, '', 'index.js');
     return zip;
 }
-/**
- * Remove file that contains the current date to prevent the hash from changing in the final asset.
- * @param functionPath The path to the built function
- */
-async function removeArcAutoInstallPackageJson(functionPath) {
-    const arcAutoInstallPackageJson = path.join(functionPath, 'node_modules', '_arc-autoinstall', 'package.json');
-    try {
-        const fileStat = await stat(arcAutoInstallPackageJson);
-        if (fileStat.isFile()) {
-            await rm(arcAutoInstallPackageJson);
-        }
-    }
-    catch {
-        // ignore errors
-    }
-}

package/dist/utils/studios/prepare-asset.js

@@ -5,12 +5,12 @@ import path, { basename, dirname, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { createGzip } from 'node:zlib';
 import { buildStudio, compareDependencyVersions } from '@sanity/cli-build/_internal/build';
+import { getLocalPackageVersion } from '@sanity/cli-core';
 import { pack } from 'tar-fs';
 export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
-    // validate resource has an externalId
-    if (!('externalId' in resource) ||
-        typeof resource.externalId !== 'string' ||
-        !resource.externalId) {
+    // validate resource has an appId
+    const appId = getAppId(resource);
+    if (!appId) {
         return {
             success: false,
             async cleanup() {
@@ -23,6 +23,8 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
         // no op
     };
     const studioPath = path.resolve(blueprintFileDir, resource.src);
+    // set only when auto-updates is on, because the build compares versions only then
+    let mismatchedPackages;
     try {
         const studioPathStat = await stat(studioPath);
         if (!studioPathStat.isDirectory()) {
@@ -48,14 +50,15 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
             await rm(outDir, { force: true, recursive: true });
             await rm(outFile, { force: true });
         };
-        const appId = resource.externalId;
         try {
             await buildStudio({
                 appId,
                 autoUpdatesEnabled: resource.autoUpdates.enabled,
                 checkAppId() { },
                 async compareDependencyVersions(packages) {
-                    return compareDependencyVersions(packages, studioPath, { appId });
+                    const result = await compareDependencyVersions(packages, studioPath, { appId });
+                    mismatchedPackages = result.mismatched.map((m) => m.pkg);
+                    return result;
                 },
                 determineBasePath() {
                     return resource.basePath ?? '/';
@@ -112,6 +115,11 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
             outputBuffer: buffer,
             fileExtension: 'tar.gz',
             assetParameter: 'src',
+            metadata: {
+                sanityVersion: await getInstalledSanityVersion(studioPath),
+                mismatchedPackages,
+                assetBytes: buffer.length,
+            },
         };
     }
     catch (error) {
@@ -139,3 +147,20 @@ function createSilentOutput() {
         },
     };
 }
+async function getInstalledSanityVersion(studioPath) {
+    try {
+        return (await getLocalPackageVersion('sanity', studioPath)) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getAppId(resource) {
+    if ('externalId' in resource && typeof resource.externalId === 'string' && resource.externalId) {
+        return resource.externalId;
+    }
+    else if (resource.lifecycle?.ownershipAction?.type === 'attach') {
+        return resource.lifecycle.ownershipAction.id;
+    }
+    return undefined;
+}

package/dist/utils/types.d.ts

@@ -87,7 +87,22 @@ export interface StackMutation {
     };
     userMessage?: string;
     preDeploy?: boolean;
+    metadata?: DeployMetadata;
 }
+/**
+ * Facts about one deploy, stored with the Blueprint on the server.
+ * The API accepts it on stack update and never returns it.
+ */
+export interface DeployMetadata {
+    /** The environment that ran the deploy */
+    client?: Record<string, unknown>;
+    /** One entry per resource that had an asset prepared, plus what was learned while preparing it */
+    resources?: ResourceMetadata[];
+}
+export type ResourceMetadata = {
+    name: string;
+    type: string;
+} & Record<string, unknown>;
 /** @internal */
 export interface BuildPayloadOptions {
     data?: string;
@@ -302,6 +317,8 @@ export type AssetPrepResult = {
     fileExtension: string;
     assetParameter: string;
     cleanup: () => Promise<void>;
+    /** Facts learned about the resource while preparing its asset. Sent as deploy metadata. */
+    metadata?: Record<string, unknown>;
 } | {
     success: false;
     cleanup: () => Promise<void>;