@sanity/runtime-cli 17.12.0 → 17.13.0-next.g06897b0

package/dist/utils/functions/is-folder-larger-than.js

@@ -0,0 +1,38 @@
+import { readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Recursively validates the total size of a folder, including all nested files and subdirectories.
+ */
+export function isFolderLargerThan(folder, maxBytes) {
+    if (!statSync(folder).isDirectory()) {
+        throw new Error('Provided path is not a directory');
+    }
+    function recurse(f, bytesSoFar) {
+        let totalBytes = bytesSoFar;
+        const fileEntries = readdirSync(f);
+        for (const file of fileEntries) {
+            const filePath = path.join(f.toString(), file);
+            const stats = statSync(filePath);
+            if (stats.isFile()) {
+                totalBytes += stats.size;
+            }
+            else if (stats.isDirectory()) {
+                const result = recurse(filePath, totalBytes);
+                totalBytes = result.totalBytes;
+            }
+            // return early if we have already exceeded the maximum
+            if (totalBytes > maxBytes) {
+                return {
+                    totalBytes,
+                    exceededMax: true,
+                };
+            }
+        }
+        return {
+            totalBytes,
+            exceededMax: false,
+        };
+    }
+    const result = recurse(folder, 0);
+    return result.exceededMax;
+}

package/dist/utils/functions/prepare-asset.d.ts

@@ -1,6 +1,8 @@
+import AdmZip from 'adm-zip';
 import type { AssetPrepResult, FunctionResource, InstallerType } from '../types.js';
 export declare function prepareAsset({ blueprintFileDir, resource, installer, }: {
     blueprintFileDir: string;
     resource: FunctionResource;
     installer?: InstallerType;
 }): Promise<AssetPrepResult>;
+export declare function pathToZip(path: string): Promise<AdmZip>;

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

@@ -1,9 +1,11 @@
-import { existsSync } from 'node:fs';
-import { rm, stat } from 'node:fs/promises';
+import fs, { existsSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import { MAX_ASSET_SIZE } from '../../constants.js';
+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 { getFolderSize } from './get-folder-size.js';
+import { isFolderLargerThan } from './is-folder-larger-than.js';
 import { resolveResourceDependencies } from './resolve-dependencies.js';
 import { shouldAutoResolveDependencies } from './should-auto-resolve-deps.js';
 import { shouldTranspileFunction } from './should-transpile.js';
@@ -15,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 {
@@ -41,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');
@@ -51,29 +56,60 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
         }
     }
     try {
-        const size = getFolderSize(functionPath);
-        if (size > MAX_ASSET_SIZE) {
+        // First check the size before trying to create the zip file
+        const result = isFolderLargerThan(functionPath, MAX_ASSET_SIZE);
+        if (result) {
             throw new Error('Resource is larger than max asset size of 200 MB.');
         }
-        return { success: true, outputPath: functionPath, cleanup };
+        const zip = await pathToZip(functionPath);
+        // Add up the uncompressed sizes of all entries to get a more accurate size of the asset being uploaded
+        const zipEntrySize = zip
+            .getEntries()
+            .map((entry) => entry.header.size)
+            .reduce((a, b) => a + b, 0);
+        if (zipEntrySize > MAX_ASSET_SIZE) {
+            throw new Error(`Asset size of ${(zipEntrySize / CONVERT_BYTES_TO_MB).toFixed(2)} MB exceeds the maximum allowed size of 200 MB.`);
+        }
+        return {
+            success: true,
+            outputBuffer: await zip.toBufferPromise(),
+            fileExtension: 'zip',
+            assetParameter: 'src',
+            cleanup,
+            metadata: {
+                transpiled: shouldTranspile.transpile,
+                bundled: wasBundled,
+                dependenciesInstalled,
+                ...(await getDependencyInfo({
+                    sourceDir: resolvedFunctionPath,
+                    autoInstall,
+                    bundled: wasBundled,
+                })),
+                assetBytes: zipEntrySize,
+            },
+        };
     }
     catch (err) {
         return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
     }
 }
-/**
- * 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
-    }
+export async function pathToZip(path) {
+    const stats = await stat(path);
+    const zip = new AdmZip(undefined, {
+        fs: {
+            ...fs,
+            // @ts-expect-error monkey patching to return matching mtime for builds
+            statSync(path, options) {
+                const s = fs.statSync(path, options);
+                if (s)
+                    s.mtime = new Date(0);
+                return s;
+            },
+        },
+    });
+    if (stats.isDirectory())
+        zip.addLocalFolder(path);
+    else
+        zip.addLocalFile(path, '', 'index.js');
+    return zip;
 }

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

@@ -1,16 +1,16 @@
 import { createWriteStream } from 'node:fs';
-import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 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 ?? '/';
@@ -105,11 +108,18 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
         }
         // tar/gzip/write the built output
         await pipeline(pack(dirname(outDir), { entries: [basename(outDir)] }), createGzip(), createWriteStream(outFile));
+        const buffer = await readFile(outFile);
         return {
             success: true,
             cleanup,
-            // studio must be pre built (e.g. with `npm run build`) and tarred/gzipped
-            outputPath: outFile,
+            outputBuffer: buffer,
+            fileExtension: 'tar.gz',
+            assetParameter: 'src',
+            metadata: {
+                sanityVersion: await getInstalledSanityVersion(studioPath),
+                mismatchedPackages,
+                assetBytes: buffer.length,
+            },
         };
     }
     catch (error) {
@@ -137,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

@@ -20,8 +20,6 @@ export type FunctionResource = FunctionGroqResource | BlueprintPubSubFunctionRes
 export type EventFunctionResource = Exclude<FunctionResource, BlueprintPubSubFunctionResource>;
 /** The `event` of any function resource that declares one */
 export type FunctionResourceEvent = EventFunctionResource['event'];
-/** Resource types that carry a deployable asset (have src: string) */
-export type AssetResource = FunctionResource | BlueprintStudioResource;
 /** @internal */
 export interface AuthParams {
     token: string;
@@ -52,7 +50,6 @@ export declare function isRoleResource(r: unknown): r is BlueprintRoleResource;
 export declare function isDatasetResource(r: unknown): r is BlueprintDatasetResource;
 export declare function isStudioResource(r: BlueprintResource): r is BlueprintStudioResource;
 export declare function isDurableFunctionResource(r: unknown): r is BlueprintDurableFunctionResource;
-export declare function isAssetResource(r: BlueprintResource): r is AssetResource;
 export declare function isWebhookResource(r: unknown): r is BlueprintDocumentWebhookResource;
 interface StackBase {
     id: string;
@@ -90,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;
@@ -301,13 +313,32 @@ export declare const INSTALLER_OPTIONS: readonly ['npm', 'pnpm', 'yarn'];
 export type InstallerType = 'npm' | 'pnpm' | 'yarn';
 export type AssetPrepResult = {
     success: true;
-    outputPath: string;
+    outputBuffer: Buffer;
+    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>;
     error: string;
 };
+export type PrepAssetFn<R extends BlueprintResource> = (options: {
+    resource: R;
+    blueprintFileDir: string;
+    installer?: InstallerType;
+}) => Promise<AssetPrepResult>;
+export type PreDeployConfig = {
+    /** The resource type this config applies to or a function that returns true if this config applies to the given type. */
+    resourceType: string | ((type: string) => boolean);
+    /** Function that takes a resource and returns a buffer to be sent to blueprints. */
+    prepareAsset?: PrepAssetFn<BlueprintResource>;
+};
+export type AssetResource<R extends BlueprintResource> = {
+    resource: R;
+    prepareAsset: PrepAssetFn<R>;
+};
 export type Warning = {
     code: string;
     suggestions: string[];

package/dist/utils/types.js

@@ -31,9 +31,6 @@ export function isStudioResource(r) {
 export function isDurableFunctionResource(r) {
     return validateDurableFunction(r).length === 0;
 }
-export function isAssetResource(r) {
-    return isLocalFunctionResource(r) || isStudioResource(r);
-}
 export function isWebhookResource(r) {
     return validateDocumentWebhook(r).length === 0;
 }

package/oclif.manifest.json

@@ -2042,7 +2042,7 @@
     "functions:dev": {
       "aliases": [],
       "args": {},
-      "description": "Runs a local, web-based development server to test your functions before deploying.\n\nOpen the emulator in your browser to interactively test your functions with the payload editor.\n\nOptionally, set the host and port with the --host and --port flags. Port 8974 is reserved for the emulator's live-reload WebSocket server. Function timeout can be configured with the --timeout flag.\n\nTo invoke a function with the CLI, use 'functions test'.",
+      "description": "Runs a local, web-based development server to test your functions before deploying.\n\nOpen the emulator in your browser to interactively test your functions with the payload editor.\n\nOptionally, set the host and port with the --host and --port flags. The live-reload WebSocket server shares this host and port. Function timeout can be configured with the --timeout flag.\n\nTo invoke a function with the CLI, use 'functions test'.",
       "examples": [
         "<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 3333",
         "<%= config.bin %> <%= command.id %> --timeout 60"
@@ -3148,5 +3148,5 @@
       ]
     }
   },
-  "version": "17.12.0"
+  "version": "17.13.0-next.g06897b0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.12.0",
+  "version": "17.13.0-next.g06897b0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -34,8 +34,8 @@
     "sanity-run": "bin/run.js"
   },
   "scripts": {
-    "build": "npm run build:rollup && npm run build:ts && npm run build:static && npm run build:oclif",
-    "build:rollup": "rollup -c",
+    "build": "npm run build:vendor && npm run build:ts && npm run build:static && npm run build:oclif",
+    "build:vendor": "vite build --config vite.vendor.config.mjs",
     "build:oclif": "oclif manifest && oclif readme",
     "build:ts": "shx rm -rf dist *.tsbuildinfo && tsc -b",
     "build:static": "npm run copy:wrapper && npm run copy:design-tokens && npm run copy:server",
@@ -52,7 +52,7 @@
     "postpack": "shx rm -f oclif.manifest.json",
     "test": "npm run typecheck && vitest run && npm run test:depmgmt && npm run lint",
     "test:depmgmt": "vitest run --config ./test-depmgmt/vitest.config.ts",
-    "test:coverage": "vitest run --coverage --coverage.include \"runtime-cli/src/**/*\"",
+    "test:coverage": "vitest run --coverage --coverage.include \"src/**/*\" --coverage.exclude \"src/server/static/**\"",
     "test:scenarios": "vitest run test/scenarios",
     "test:playwright": "playwright install chromium && playwright install-deps chromium && playwright test",
     "test:bp-version-smoke": "node ./test/blueprints-version-smoke.js",
@@ -64,16 +64,16 @@
   "dependencies": {
     "@architect/hydrate": "~6.0.2",
     "@architect/inventory": "~6.1.0",
-    "@inquirer/prompts": "^8.7.0",
+    "@inquirer/prompts": "^8.7.2",
     "@oclif/core": "^4.14.0",
     "@oclif/plugin-help": "^6.3.0",
     "@sanity-labs/oclif-plugin-skills-flag": "^0.2.1",
     "@sanity/blueprints": "^0.24.0",
     "@sanity/blueprints-parser": "^0.5.0",
-    "@sanity/cli-build": "^5.2.0",
-    "@sanity/cli-core": "^3.5.0",
-    "@sanity/client": "^8.4.0",
-    "adm-zip": "^0.6.0",
+    "@sanity/cli-build": "^6.3.0",
+    "@sanity/cli-core": "^3.7.0",
+    "@sanity/client": "^8.6.1",
+    "adm-zip": "^0.6.1",
     "array-treeify": "^0.2.0",
     "cardinal": "^2.1.1",
     "empathic": "^2.0.1",
@@ -86,37 +86,35 @@
     "strip-ansi": "^7.2.0",
     "tar-fs": "^3.1.3",
     "tar-stream": "^3.2.1",
-    "vite": "^8.2.2",
+    "vite": "^8.3.0",
     "ws": "^8.21.3",
     "xdg-basedir": "^5.1.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.11",
+    "@biomejs/biome": "2.5.13",
     "@codemirror/lang-json": "^6.0.2",
     "@codemirror/language": "^6.12.4",
-    "@codemirror/state": "^6.7.1",
+    "@codemirror/state": "^6.7.4",
     "@enhance/store": "^1.0.2",
     "@lezer/highlight": "^1.2.3",
     "@oclif/test": "^4.2.0",
-    "@playwright/test": "^1.62.1",
-    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@playwright/test": "^1.63.0",
     "@sanity-labs/design-tokens": "^0.0.2-alpha.2",
-    "@sanity/functions": "^1.7.1",
+    "@sanity/functions": "^1.7.2",
     "@types/cardinal": "^2.1.1",
     "@types/mime-types": "^3.0.1",
     "@types/node": "^22",
     "@types/tar-fs": "^2.0.4",
     "@types/ws": "^8.18.1",
-    "@vitest/coverage-v8": "4.1.11",
+    "@vitest/coverage-v8": "5.0.0",
     "codemirror": "^6.0.2",
     "mentoss": "^0.13.0",
     "oclif": "^4.24.0",
-    "pretty-bytes": "^7.1.2",
+    "pretty-bytes": "^7.1.3",
     "pretty-ms": "^9.3.1",
-    "rollup": "^4.63.1",
     "shx": "^0.4.0",
     "typescript": "^7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "oclif": {
     "bin": "sanity-run",

package/skills/functions-dev.md

@@ -16,6 +16,6 @@ The emulator is available at `http://localhost:8080`. Choose another loopback po
 npx @sanity/cli functions dev --host 127.0.0.1 --port 3333 --timeout 60
 ```
 
-Port 8974 is not available: the emulator's WebSocket server binds it. `--timeout` sets the execution limit in seconds for every Function, taking precedence over each Function's configured `timeout` (default 10 seconds). Bind to a non-loopback interface only when network access is requested and exposing the development server is acceptable.
+The emulator's live-reload WebSocket server shares the same host and port, so no additional port is reserved. `--timeout` sets the execution limit in seconds for every Function, taking precedence over each Function's configured `timeout` (default 10 seconds). Bind to a non-loopback interface only when network access is requested and exposing the development server is acceptable.
 
 Run this command in a persistent terminal, report the URL, and stop the process when development is complete. For one bounded invocation without a web server, use `functions test`.

package/dist/utils/functions/get-folder-size.d.ts

@@ -1,5 +0,0 @@
-import { type PathLike } from 'node:fs';
-/**
- * Recursively calculates the total size of a folder, including all nested files and subdirectories.
- */
-export declare const getFolderSize: (folder: PathLike) => number;

package/dist/utils/functions/get-folder-size.js

@@ -1,24 +0,0 @@
-import { readdirSync, statSync } from 'node:fs';
-import path from 'node:path';
-/**
- * Recursively calculates the total size of a folder, including all nested files and subdirectories.
- */
-export const getFolderSize = (folder) => {
-    if (!statSync(folder).isDirectory()) {
-        throw new Error('Provided path is not a directory');
-    }
-    let totalSize = 0;
-    const fileEntries = readdirSync(folder);
-    for (const file of fileEntries) {
-        const filePath = path.join(folder.toString(), file);
-        const stats = statSync(filePath);
-        if (stats.isFile()) {
-            totalSize += stats.size;
-        }
-        else if (stats.isDirectory()) {
-            const recursiveSize = getFolderSize(filePath);
-            totalSize += recursiveSize;
-        }
-    }
-    return totalSize;
-};