@sanity/runtime-cli 4.4.0 → 4.5.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity-run COMMAND
 running command...
 $ sanity-run (--version)
-@sanity/runtime-cli/4.4.0 linux-x64 node-v22.15.0
+@sanity/runtime-cli/4.5.0 linux-x64 node-v22.15.0
 $ sanity-run --help [COMMAND]
 USAGE
   $ sanity-run COMMAND
@@ -74,7 +74,7 @@ EXAMPLES
   $ sanity-run blueprints add function --name my-function --function-type document-publish
 ```
 
-_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/add.ts)_
+_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/add.ts)_
 
 ## `sanity-run blueprints config`
 
@@ -103,7 +103,7 @@ EXAMPLES
   $ sanity-run blueprints config --edit --project-id <projectId> --stack-id <stackId>
 ```
 
-_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/config.ts)_
+_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/config.ts)_
 
 ## `sanity-run blueprints deploy`
 
@@ -123,7 +123,7 @@ EXAMPLES
   $ sanity-run blueprints deploy
 ```
 
-_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/deploy.ts)_
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/deploy.ts)_
 
 ## `sanity-run blueprints destroy`
 
@@ -146,7 +146,7 @@ EXAMPLES
   $ sanity-run blueprints destroy --id ST-a1b2c3
 ```
 
-_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/destroy.ts)_
+_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/destroy.ts)_
 
 ## `sanity-run blueprints info`
 
@@ -168,7 +168,7 @@ EXAMPLES
   $ sanity-run blueprints info --id ST-a1b2c3
 ```
 
-_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/info.ts)_
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/info.ts)_
 
 ## `sanity-run blueprints init`
 
@@ -198,7 +198,7 @@ EXAMPLES
   $ sanity-run blueprints init --blueprint-type <json|js|ts> --project-id <projectId> --stack-name <stackName>
 ```
 
-_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/init.ts)_
+_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/init.ts)_
 
 ## `sanity-run blueprints logs`
 
@@ -220,7 +220,7 @@ EXAMPLES
   $ sanity-run blueprints logs --watch
 ```
 
-_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/logs.ts)_
+_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/logs.ts)_
 
 ## `sanity-run blueprints plan`
 
@@ -237,7 +237,7 @@ EXAMPLES
   $ sanity-run blueprints plan
 ```
 
-_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/plan.ts)_
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/plan.ts)_
 
 ## `sanity-run blueprints stacks`
 
@@ -259,7 +259,7 @@ EXAMPLES
   $ sanity-run blueprints stacks --projectId a1b2c3
 ```
 
-_See code: [src/commands/blueprints/stacks.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/blueprints/stacks.ts)_
+_See code: [src/commands/blueprints/stacks.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/blueprints/stacks.ts)_
 
 ## `sanity-run functions dev`
 
@@ -279,7 +279,7 @@ EXAMPLES
   $ sanity-run functions dev --port 8974
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/dev.ts)_
 
 ## `sanity-run functions env add NAME KEY VALUE`
 
@@ -301,7 +301,7 @@ EXAMPLES
   $ sanity-run functions env add MyFunction API_URL https://api.example.com/
 ```
 
-_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/env/add.ts)_
+_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/env/add.ts)_
 
 ## `sanity-run functions env list NAME`
 
@@ -321,7 +321,7 @@ EXAMPLES
   $ sanity-run functions env list MyFunction
 ```
 
-_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/env/list.ts)_
+_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/env/list.ts)_
 
 ## `sanity-run functions env remove NAME KEY`
 
@@ -342,7 +342,7 @@ EXAMPLES
   $ sanity-run functions env remove MyFunction API_URL
 ```
 
-_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/env/remove.ts)_
+_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/env/remove.ts)_
 
 ## `sanity-run functions invoke NAME`
 
@@ -368,7 +368,7 @@ EXAMPLES
   $ sanity-run functions invoke <name> --file 'payload.json'
 ```
 
-_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/invoke.ts)_
+_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/invoke.ts)_
 
 ## `sanity-run functions logs NAME`
 
@@ -400,7 +400,7 @@ EXAMPLES
   $ sanity-run functions logs <name> --delete
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/logs.ts)_
 
 ## `sanity-run functions test NAME`
 
@@ -433,7 +433,7 @@ EXAMPLES
   $ sanity-run functions test <name> --data '{ "id": 1 }' --timeout 60
 ```
 
-_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v4.4.0/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.0/src/commands/functions/test.ts)_
 
 ## `sanity-run help [COMMAND]`
 

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

@@ -6,5 +6,6 @@ export declare function stashAsset({ resource, auth, }: {
 }): Promise<{
     success: boolean;
     assetId?: string;
+    outputPath?: string;
     error?: string;
 }>;

package/dist/actions/blueprints/assets.js

@@ -3,21 +3,35 @@ import path from 'node:path';
 import { cwd } from 'node:process';
 import AdmZip from 'adm-zip';
 import config from '../../config.js';
+import { bundleFunction } from '../../utils/bundle/bundle-function.js';
+import { shouldBundleFunction } from '../../utils/functions/should-bundle.js';
 import getHeaders from '../../utils/get-headers.js';
 const { apiUrl } = config;
 export const stashUrl = `${apiUrl}vX/blueprints/assets/stash`;
 export async function stashAsset({ resource, auth, }) {
     if (!resource.src)
         throw new Error('Resource src is required');
+    let functionPath = path.join(cwd(), resource.src);
+    let cleanup = async () => { };
+    const shouldBundle = await shouldBundleFunction(resource);
+    if (shouldBundle) {
+        try {
+            const result = await bundleFunction(resource);
+            functionPath = result.outputDir;
+            cleanup = result.cleanup;
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : `${err}` };
+        }
+    }
     try {
-        const sourcePath = path.join(cwd(), resource.src);
-        const stats = await fs.promises.stat(sourcePath);
+        const stats = await fs.promises.stat(functionPath);
         const zip = new AdmZip();
         if (stats.isDirectory()) {
-            zip.addLocalFolder(sourcePath);
+            zip.addLocalFolder(functionPath);
         }
         else {
-            zip.addLocalFile(sourcePath, '', 'index.js');
+            zip.addLocalFile(functionPath, '', 'index.js');
         }
         const zipBuffer = zip.toBuffer();
         const base64Zip = zipBuffer.toString('base64');
@@ -41,4 +55,7 @@ export async function stashAsset({ resource, auth, }) {
             error = err.message;
         return { success: false, error };
     }
+    finally {
+        await cleanup();
+    }
 }

package/dist/actions/functions/test.d.ts

@@ -1,2 +1,2 @@
-import type { InvocationResponse, InvokeContextOptions, InvokePayloadOptions } from '../../utils/types.js';
-export declare function testAction(srcPath: string, options: InvokePayloadOptions, context: InvokeContextOptions): Promise<InvocationResponse>;
+import type { InvocationResponse, InvokeContextOptions, InvokePayloadOptions, LocalFunctionResource } from '../../utils/types.js';
+export declare function testAction(resource: LocalFunctionResource, options: InvokePayloadOptions, context: InvokeContextOptions): Promise<InvocationResponse>;

package/dist/actions/functions/test.js

@@ -1,10 +1,10 @@
 import buildPayload from '../../utils/build-payload.js';
 import invoke from '../../utils/invoke-local.js';
-export async function testAction(srcPath, options, context) {
+export async function testAction(resource, options, context) {
     const payload = buildPayload(options);
     const { timeout } = options;
     try {
-        const { json, logs } = await invoke(srcPath, payload, context, timeout);
+        const { json, logs } = await invoke(resource, payload, context, timeout);
         return { error: undefined, json, logs };
     }
     catch (error) {

package/dist/commands/functions/test.js

@@ -1,7 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { testAction } from '../../actions/functions/test.js';
-import { getFunctionSource } from '../../utils/find-function.js';
+import { findFunctionByName } from '../../utils/find-function.js';
 export default class Test extends Command {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
@@ -42,11 +42,8 @@ export default class Test extends Command {
         const { args, flags } = await this.parse(Test);
         const { parsedBlueprint } = await readBlueprintOnDisk({ getStack: false });
         try {
-            const src = getFunctionSource(parsedBlueprint, args.name);
-            if (!src) {
-                this.error(`Error: Function ${args.name} has no source code`);
-            }
-            const { json, logs, error } = await testAction(src, {
+            const resource = findFunctionByName(parsedBlueprint, args.name);
+            const { json, logs, error } = await testAction(resource, {
                 data: flags.data,
                 file: flags.file,
                 timeout: flags.timeout,

package/dist/server/app.js

@@ -1,9 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
+import * as http from 'node:http';
 import { default as mime } from 'mime-types';
 import { readBlueprintOnDisk } from '../actions/blueprints/blueprint.js';
 import config from '../config.js';
+import { findFunctionByName } from '../utils/find-function.js';
 import invoke from '../utils/invoke-local.js';
-import * as http from 'node:http';
+import { isRecord } from '../utils/is-record.js';
 const host = 'localhost';
 const app = (port) => {
     const requestListener = async (req, res) => {
@@ -14,30 +16,40 @@ const app = (port) => {
                     const { parsedBlueprint } = await readBlueprintOnDisk({ getStack: false });
                     res.setHeader('Content-Type', 'application/json');
                     res.writeHead(200);
-                    res.end(JSON.stringify(parsedBlueprint));
+                    res.end(JSON.stringify(parsedBlueprint)); // Use parsedBlueprint directly
                 }
-                catch {
+                catch (error) {
                     res.writeHead(404);
-                    res.end();
+                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
                 }
                 break;
             }
             case req.url === '/invoke': {
                 if (req.method === 'POST') {
-                    let body = '';
-                    req.on('data', (data) => {
-                        body += data;
-                    });
+                    const body = [];
+                    req.on('data', (data) => body.push(data));
                     req.on('end', async () => {
-                        const { data, func } = JSON.parse(body);
-                        const { context, event } = data;
                         res.setHeader('Content-Type', 'application/json');
                         try {
-                            const response = await invoke(func, event, context);
-                            res.writeHead(200);
+                            const { data, func: functionName } = parseInvokeRequest(Buffer.concat(body));
+                            const { context, event } = data;
+                            const start = performance.now();
+                            const { parsedBlueprint } = await readBlueprintOnDisk({ getStack: false });
+                            const resource = findFunctionByName(parsedBlueprint, functionName);
+                            const readBlueprintTime = performance.now() - start;
+                            const response = await invoke(resource, event, context);
+                            const timings = { ...response.timings, 'blueprint:read': readBlueprintTime };
+                            const timingHeaders = [];
+                            for (const [key, value] of Object.entries(timings)) {
+                                timingHeaders.push(`${key.replace(/:/g, '-')};dur=${Math.abs(value).toFixed(1)}`);
+                            }
+                            if (timingHeaders.length > 0) {
+                                res.setHeader('Server-Timing', timingHeaders.join(', '));
+                            }
                             res.end(JSON.stringify(response));
                         }
                         catch (error) {
+                            console.error(error);
                             const response = { logs: '', error: '' };
                             if (error instanceof Error) {
                                 response.logs = error.message;
@@ -112,4 +124,60 @@ const app = (port) => {
     const server = http.createServer(requestListener);
     server.listen(port, host, () => { });
 };
+function parseInvokeRequest(body) {
+    let json;
+    try {
+        json = JSON.parse(body.toString('utf8'));
+    }
+    catch (error) {
+        throw new Error('Request body is not valid JSON', { cause: error });
+    }
+    if (!isRecord(json)) {
+        throw new Error('Request body is not valid, must be an object');
+    }
+    if (!('func' in json)) {
+        throw new Error('Request body is not valid, missing `func` field');
+    }
+    if (!('data' in json)) {
+        throw new Error('Request body is not valid, missing `data` field');
+    }
+    const { data, func } = json;
+    if (typeof func !== 'string') {
+        throw new Error('Request body is not valid, `func` field is not a string');
+    }
+    if (!isRecord(data)) {
+        throw new Error('Request body is not valid, `data` field is not an object');
+    }
+    const { context, event } = data;
+    if (!isRecord(context)) {
+        throw new Error('Request body is not valid, `context` field is not an object');
+    }
+    if (!isRecord(event)) {
+        throw new Error('Request body is not valid, `event` field is not an object');
+    }
+    if (!('clientOptions' in context)) {
+        throw new Error('Request body is not valid, `context.clientOptions` field is missing');
+    }
+    if (!isRecord(context.clientOptions)) {
+        throw new Error('Request body is not valid, `context.clientOptions` field is not an object');
+    }
+    const { projectId, dataset, apiVersion } = context.clientOptions;
+    if (typeof projectId !== 'string' && typeof projectId !== 'undefined') {
+        throw new Error('Request body is not valid, `context.clientOptions.projectId` field is not a string');
+    }
+    if (typeof dataset !== 'string' && typeof dataset !== 'undefined') {
+        throw new Error('Request body is not valid, `context.clientOptions.dataset` field is not a string');
+    }
+    if (typeof apiVersion !== 'string' && typeof apiVersion !== 'undefined') {
+        throw new Error('Request body is not valid, `context.clientOptions.apiVersion` field is not a string');
+    }
+    const clientOptions = {
+        ...context.clientOptions,
+        projectId,
+        dataset,
+        // Prefer `undefined` over empty string, triggering the right warnings in the client
+        apiVersion: apiVersion || undefined,
+    };
+    return { func, data: { context: { ...context, clientOptions }, event } };
+}
 export default app;

package/dist/server/static/api.js

@@ -30,12 +30,15 @@ function invoke(payloadText = '{}') {
     },
     method: 'POST',
   })
-    .then((response) => response.json())
-    .then((data) => {
+    .then((response) => {
+      return response.json().then((data) => ({data, timings: getServerTimings(response)}))
+    })
+    .then(({data, timings}) => {
       store.inprogress = false
       store.result = {
         ...data,
         time: Date.now() - start,
+        timings,
       }
     })
 }
@@ -47,7 +50,7 @@ function blueprint() {
       const functions = blueprint?.resources.filter((r) => r.type.startsWith('sanity.function.'))
 
       store.functions = functions
-      store.selectedIndex = functions[0].src
+      store.selectedIndex = functions[0].name
     })
     .catch(() => {
       store.functions = []
@@ -77,3 +80,21 @@ function datasets(selectedProject) {
       store.datasets = []
     })
 }
+
+function getServerTimings(response) {
+  const timings = {}
+  const serverTiming = response.headers.get('Server-Timing')
+  if (!serverTiming) {
+    return timings
+  }
+
+  for (const entry of serverTiming.split(',')) {
+    const [name, ...params] = entry.split(';')
+    const durationParam = params.find((p) => p.startsWith('dur='))
+    if (durationParam) {
+      timings[name.trim()] = Number.parseFloat(durationParam.slice(4))
+    }
+  }
+
+  return timings
+}

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

@@ -9,7 +9,7 @@ class FunctionList extends ApiBaseElement {
   functionClicked = (event) => {
     // eslint-disable-next-line unicorn/prefer-dom-node-text-content
     const target = this.api.store.functions.find((func) => func.name === event.srcElement.innerText)
-    this.api.store.selectedIndex = target.src
+    this.api.store.selectedIndex = target.name
   }
   functionSelected = (event) => {
     this.api.store.selectedIndex = event.srcElement.value
@@ -18,14 +18,14 @@ class FunctionList extends ApiBaseElement {
     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' : ''
+          const selected = this.api.store.selectedIndex === func.name ? 'selected' : ''
           return `<li class="function-list-item ${selected}" style="padding: 16px 24px;">${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>`
+          const selected = this.api.store.selectedIndex === func.name ? 'selected' : ''
+          return `<option value="${func.name}" ${selected}>${func.name}</option>`
         })
         .join('')
     } else {

package/dist/server/static/components/response-panel.js

@@ -34,7 +34,7 @@ class ResponsePanel extends ApiBaseElement {
   updateResponse = ({result}) => {
     if (!result) return
 
-    const {error, json, time} = result
+    const {error, json, logs, time, timings} = result
     if (!error) {
       const transaction = this.api.store.response.state.update({
         changes: {
@@ -46,8 +46,19 @@ class ResponsePanel extends ApiBaseElement {
       this.api.store.response.dispatch(transaction)
 
       this.size.innerText = json ? prettyBytes(JSON.stringify(json).length) : ''
-      this.time.innerText = prettyMilliseconds(time)
-      this.time.dateTime = `PT${time / 1000}S`
+
+      if (timings && 'bundle' in timings && 'execute' in timings) {
+        const bundleTime = prettyMilliseconds(timings.bundle)
+        const executeTime = prettyMilliseconds(timings.execute)
+        this.time.innerText = `${executeTime} (+${bundleTime} bundle time)`
+        this.time.dateTime = `PT${executeTime / 1000}S`
+      } else if (timings && 'execute' in timings) {
+        this.time.innerText = prettyMilliseconds(timings.execute)
+        this.time.dateTime = `PT${timings.execute / 1000}S`
+      } else {
+        this.time.innerText = prettyMilliseconds(time)
+        this.time.dateTime = `PT${time / 1000}S`
+      }
     } else {
       const transaction = this.api.store.response.state.update({
         changes: {from: 0, to: this.api.store.response.state.doc.length, insert: ''},

package/dist/server/static/index.html

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
     <head>
+        <meta charset="UTF-8">
         <title>Sanity Functions</title>
         <link href="https://unpkg.com/m-@3.2.0/dist/m-.woff2" rel="preload" as="font" crossorigin>
         <link href="https://unpkg.com/m-@3.2.0/dist/m-.css" rel="stylesheet">

package/dist/server/static/vendor/vendor.bundle.d.ts

@@ -1018,9 +1018,9 @@ declare class ViewState {
     viewport: Viewport | undefined;
     lineGaps: any[];
     lineGapDeco: any;
-    updateForViewport(): 0 | 2;
+    updateForViewport(): 2 | 0;
     viewports: (Viewport | undefined)[] | undefined;
-    updateScaler(): 0 | 2;
+    updateScaler(): 2 | 0;
     updateViewportLines(): void;
     viewportLines: any[] | undefined;
     update(update: any, scrollTarget?: null): void;

package/dist/utils/build-payload.d.ts

@@ -1,2 +1,2 @@
 import type { InvokePayloadOptions } from './types.js';
-export default function buildPayload(options: InvokePayloadOptions): object | null;
+export default function buildPayload(options: InvokePayloadOptions): Record<string, unknown> | null;

package/dist/utils/build-payload.js

@@ -1,15 +1,15 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { cwd } from 'node:process';
-import isJson from './is-json.js';
+import { parseJsonObject } from './parse-json-object.js';
 export default function buildPayload(options) {
     const { data, file } = options;
     let payload = {};
     if (data) {
-        payload = isJson(data);
+        payload = parseJsonObject(data);
     }
     else if (file) {
-        payload = isJson(readFileSync(join(cwd(), file), 'utf8'));
+        payload = parseJsonObject(readFileSync(join(cwd(), file), 'utf8'));
     }
     return payload;
 }

package/dist/utils/bundle/bundle-function.d.ts

@@ -0,0 +1,8 @@
+import type { LocalFunctionResource } from '../types.js';
+export declare function bundleFunction(resource: LocalFunctionResource): Promise<{
+    type: string;
+    outputDir: string;
+    warnings: string[];
+    cleanup: () => Promise<void>;
+    timings: Record<string, number>;
+}>;

package/dist/utils/bundle/bundle-function.js

@@ -0,0 +1,125 @@
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { cwd } from 'node:process';
+import { build as viteBuild } from 'vite';
+import tsConfigPaths from 'vite-tsconfig-paths';
+import { findFunctionEntryPoint } from '../functions/find-entry-point.js';
+import { cleanupSourceMaps } from './cleanup-source-maps.js';
+import { findDirUp } from './find-up.js';
+import { verifyHandler } from './verify-handler.js';
+export async function bundleFunction(resource) {
+    if (!resource.src)
+        throw new Error('Resource src is required');
+    if (!resource.name)
+        throw new Error('Resource name is required');
+    const timings = {};
+    const bundleStart = performance.now();
+    const sourcePath = path.resolve(cwd(), resource.src);
+    const stats = await stat(sourcePath);
+    const fnDisplayName = resource.displayName ?? resource.name;
+    const findEntryStart = performance.now();
+    const entry = await findFunctionEntryPoint(sourcePath, fnDisplayName);
+    timings['bundle:findEntry'] = performance.now() - findEntryStart;
+    const entryDir = stats.isFile() ? path.dirname(sourcePath) : sourcePath;
+    const outputPathStart = performance.now();
+    const outputDir = await getBundleOutputPath(entryDir, resource.name);
+    const outputFile = path.join(outputDir, getOutputFilename(entry));
+    const fnRootDir = (await findDirUp('node_modules', entryDir)) || entryDir;
+    timings['bundle:setupOutput'] = performance.now() - outputPathStart;
+    async function cleanupTmpDir() {
+        // Feel a certain way about leaving things uncleaned, but helps with debugging for now
+        // await rm(outputDir, {recursive: true, force: true}).catch(logCleanupFailure)
+    }
+    try {
+        const viteStart = performance.now();
+        const result = await viteBuild({
+            root: fnRootDir,
+            logLevel: 'silent',
+            build: {
+                target: 'node20',
+                outDir: outputDir,
+                emptyOutDir: false,
+                minify: false,
+                sourcemap: true,
+                ssr: true,
+                rollupOptions: {
+                    input: entry,
+                    output: {
+                        format: 'esm',
+                        entryFileNames: getOutputFilename(entry),
+                    },
+                },
+            },
+            ssr: {
+                noExternal: true,
+                resolve: {
+                    conditions: ['sanity-function', 'vite'],
+                },
+            },
+            plugins: [tsConfigPaths()],
+        });
+        timings['bundle:build'] = performance.now() - viteStart;
+        const verifyStart = performance.now();
+        await verifyHandler(result);
+        timings['bundle:verify'] = performance.now() - verifyStart;
+        const pkgStart = performance.now();
+        await writeBundledPackageJson(entryDir, outputFile);
+        timings['bundle:writePackage'] = performance.now() - pkgStart;
+        const cleanupStart = performance.now();
+        await cleanupSourceMaps(sourcePath, outputDir);
+        timings['bundle:cleanupMaps'] = performance.now() - cleanupStart;
+        timings.bundle = performance.now() - bundleStart;
+        return {
+            type: 'success',
+            outputDir,
+            warnings: [],
+            cleanup: cleanupTmpDir,
+            timings,
+        };
+    }
+    catch (err) {
+        await cleanupTmpDir();
+        throw new Error(`Bundling of function failed: ${err instanceof Error ? err.message : err}`, {
+            cause: err,
+        });
+    }
+}
+async function writeBundledPackageJson(inputDir, outputFilePath) {
+    const baseName = path.basename(outputFilePath);
+    let original;
+    try {
+        const pkgJsonPath = path.join(inputDir, 'package.json');
+        original = JSON.parse(await readFile(pkgJsonPath, 'utf-8'));
+    }
+    catch {
+        original = undefined;
+    }
+    const bundled = {
+        // One could argue that we should strip this down significantly.
+        // Theoretically though, a function may reach into it to get dependency versions
+        // and whatnot, so maybe it makes more sense to keep it as close to the original
+        // as possible?
+        ...original,
+        main: baseName, // This should never be the input file, always the built output name
+        type: 'module', // We explicitly create ESM output
+    };
+    const pkgJsonOutputPath = path.join(path.dirname(outputFilePath), 'package.json');
+    await writeFile(pkgJsonOutputPath, JSON.stringify(bundled, null, 2));
+}
+async function getBundleOutputPath(entryDir, fnName) {
+    const tmpPath = path.resolve(entryDir, '.build', `function-${fnName}`);
+    await rm(tmpPath, { recursive: true, force: true }).catch(logCleanupFailure);
+    await mkdir(tmpPath, { recursive: true });
+    return tmpPath;
+}
+/**
+ * Minor convenience/niceness to keep the same input filename, but change the extension
+ */
+function getOutputFilename(entryFileName) {
+    const baseName = path.basename(entryFileName, path.extname(entryFileName));
+    return baseName ? `${baseName}.js` : 'index.js';
+}
+function logCleanupFailure(err) {
+    console.warn(`[warn] Failed to clean up temporary files: ${err instanceof Error ? err.message : err}`);
+}

package/dist/utils/bundle/cleanup-source-maps.d.ts

@@ -0,0 +1,10 @@
+/**
+ * "Clean up" source maps by removing absolute paths and making paths relative to the
+ * _input_ (eg source) rather than the _output_ (eg bundle) directory. Note that this
+ * process is not critical since the source content is inlined, but it helps with
+ * debugging to have (approximate) paths to the original source files.
+ *
+ * @param inputDir - The directory where the source files are located
+ * @param outputDir - The directory where the bundled files are located
+ */
+export declare function cleanupSourceMaps(inputDir: string, outputDir: string): Promise<void>;

package/dist/utils/bundle/cleanup-source-maps.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'node:fs';
+import { isAbsolute, join, relative } from 'node:path';
+/**
+ * "Clean up" source maps by removing absolute paths and making paths relative to the
+ * _input_ (eg source) rather than the _output_ (eg bundle) directory. Note that this
+ * process is not critical since the source content is inlined, but it helps with
+ * debugging to have (approximate) paths to the original source files.
+ *
+ * @param inputDir - The directory where the source files are located
+ * @param outputDir - The directory where the bundled files are located
+ */
+export async function cleanupSourceMaps(inputDir, outputDir) {
+    const entries = await fs.readdir(outputDir, { withFileTypes: true });
+    const sourceMaps = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.map'));
+    for (const entry of sourceMaps) {
+        const filePath = join(outputDir, entry.name);
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        let map;
+        try {
+            const json = JSON.parse(raw);
+            map = isRelevantSourceMap(json) ? json : undefined;
+        }
+        catch {
+            return;
+        }
+        if (!map) {
+            return;
+        }
+        map.sources = map.sources.map((source) => {
+            const fullPath = isAbsolute(source) ? source : join(outputDir, source);
+            return relative(inputDir, fullPath);
+        });
+        try {
+            await fs.writeFile(filePath, JSON.stringify(map));
+        }
+        catch {
+            // ignore write errors
+        }
+    }
+}
+function isRelevantSourceMap(map) {
+    return (typeof map === 'object' &&
+        map !== null &&
+        'sources' in map &&
+        Array.isArray(map.sources) &&
+        map.sources.every((source) => typeof source === 'string'));
+}

package/dist/utils/bundle/find-up.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Walks up the directory tree from a starting point to find a given file/directory.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The path to the file if found, otherwise undefined.
+ */
+export declare function findUp(fileName: string, startDir?: string): Promise<string | undefined>;
+/**
+ * Finds the directory containing a specific file/directory by walking up the directory tree.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The directory containing the file if found, otherwise undefined.
+ */
+export declare function findDirUp(fileName: string, startDir?: string): Promise<string | undefined>;

package/dist/utils/bundle/find-up.js

@@ -0,0 +1,39 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Walks up the directory tree from a starting point to find a given file/directory.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The path to the file if found, otherwise undefined.
+ */
+export async function findUp(fileName, startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, fileName);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break; // Reached root
+            dir = parent;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the directory containing a specific file/directory by walking up the directory tree.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The directory containing the file if found, otherwise undefined.
+ */
+export async function findDirUp(fileName, startDir = process.cwd()) {
+    const filePath = await findUp(fileName, startDir);
+    if (!filePath)
+        return undefined;
+    return path.dirname(filePath);
+}

package/dist/utils/bundle/verify-handler.d.ts

@@ -0,0 +1,2 @@
+import type { build } from 'vite';
+export declare function verifyHandler(result: Awaited<ReturnType<typeof build>>): Promise<void>;

package/dist/utils/bundle/verify-handler.js

@@ -0,0 +1,13 @@
+export async function verifyHandler(result) {
+    if ('close' in result) {
+        throw new Error('Incorrect build output, got watcher');
+    }
+    const outputs = (Array.isArray(result) ? result : [result]).flatMap(({ output }) => output);
+    const bundledIndex = outputs.find((output) => output.type === 'chunk' && output.isEntry && output.name === 'index');
+    if (!bundledIndex || bundledIndex.type !== 'chunk') {
+        throw new Error('Unexpected build output, no bundled index found');
+    }
+    if (!bundledIndex.exports.includes('handler')) {
+        throw new Error('Unexpected build output, no `handler` export found');
+    }
+}

package/dist/utils/child-process-wrapper.js

@@ -1,16 +1,18 @@
 import {existsSync, statSync} from 'node:fs'
-import {join} from 'node:path'
+import {isAbsolute, join} from 'node:path'
 import process from 'node:process'
 
 export function getFunctionSource(src) {
-  if (statSync(src).isDirectory()) {
-    const indexPath = join(src, 'index.js')
+  const pathToCheck = isAbsolute(src) ? src : join(process.cwd(), src)
+
+  if (statSync(pathToCheck).isDirectory()) {
+    const indexPath = join(pathToCheck, 'index.js')
     if (!existsSync(indexPath)) {
-      throw Error(`Function directory ${src} has no index.js`)
+      throw Error(`Function directory ${pathToCheck} has no index.js`)
     }
     return indexPath
   }
-  return src
+  return pathToCheck
 }
 
 // Start when payload data arrives from parent process
@@ -28,7 +30,7 @@ process.on('message', async (data) => {
   let json = null
 
   // Import the function code
-  const {handler} = await import(getFunctionSource(join(process.cwd(), srcPath)))
+  const {handler} = await import(getFunctionSource(srcPath))
 
   // backup stdout
   const originalStdoutWrite = process.stdout.write.bind(process.stdout)

package/dist/utils/functions/find-entry-point.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolves the source path to an executable entry file path.
+ *
+ * If the source path is a directory, it looks for `package.json#main`, then `index.ts`, then `index.js`.
+ *
+ * @param srcPath - The source path (can be a file or directory).
+ * @param displayName - Optional display name for the function, used in error messages.
+ * @returns The absolute path to the entry file.
+ * @throws If the entry file cannot be determined.
+ */
+export declare function findFunctionEntryPoint(srcPath: string, displayName?: string): Promise<string>;

package/dist/utils/functions/find-entry-point.js

@@ -0,0 +1,75 @@
+import { readFile, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+/**
+ * Resolves the source path to an executable entry file path.
+ *
+ * If the source path is a directory, it looks for `package.json#main`, then `index.ts`, then `index.js`.
+ *
+ * @param srcPath - The source path (can be a file or directory).
+ * @param displayName - Optional display name for the function, used in error messages.
+ * @returns The absolute path to the entry file.
+ * @throws If the entry file cannot be determined.
+ */
+export async function findFunctionEntryPoint(srcPath, displayName) {
+    const absolutePath = resolve(cwd(), srcPath);
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch (err) {
+        throw new Error(`Source path not found or inaccessible: ${srcPath}`, { cause: err });
+    }
+    if (stats.isFile()) {
+        // It's already an entry file path
+        return absolutePath;
+    }
+    if (stats.isDirectory()) {
+        // 1. Check package.json#main
+        try {
+            const pkgJsonPath = join(absolutePath, 'package.json');
+            const pkgJsonContent = await readFile(pkgJsonPath, 'utf8');
+            const pkgJson = JSON.parse(pkgJsonContent);
+            if (pkgJson.main) {
+                const mainPath = resolve(absolutePath, pkgJson.main);
+                if (await fileExists(mainPath)) {
+                    return mainPath;
+                }
+                // If pkgJson.main points to a non-existent file, we continue checking index files
+            }
+        }
+        catch {
+            // Ignore errors (missing package.json, invalid JSON, etc.)
+            // Consider warning the user on invalid JSON though?
+        }
+        // 2. Check index.ts
+        const indexTs = join(absolutePath, 'index.ts');
+        if (await fileExists(indexTs)) {
+            return indexTs;
+        }
+        // 3. Check index.js
+        const indexJs = join(absolutePath, 'index.js');
+        if (await fileExists(indexJs)) {
+            return indexJs;
+        }
+        const nameHint = displayName ? ` for function "${displayName}"` : '';
+        throw new Error(`Could not determine entry file${nameHint} in directory: ${srcPath}. Looked for package.json#main, index.ts, index.js.`);
+    }
+    // Should not happen if stat succeeded, but defensively handle
+    throw new Error(`Source path is neither a file nor a directory: ${srcPath}`);
+}
+/**
+ * Checks if a file exists and is a file.
+ */
+async function fileExists(filePath) {
+    try {
+        const stats = await stat(filePath);
+        return stats.isFile();
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            return false;
+        }
+        throw err; // Re-throw other errors
+    }
+}

package/dist/utils/functions/should-bundle.d.ts

@@ -0,0 +1,2 @@
+import type { LocalFunctionResource } from '../types.js';
+export declare function shouldBundleFunction(resource: LocalFunctionResource): Promise<boolean>;

package/dist/utils/functions/should-bundle.js

@@ -0,0 +1,23 @@
+import { findFunctionEntryPoint } from './find-entry-point.js';
+export async function shouldBundleFunction(resource) {
+    // 1. Explicit configuration takes precedence
+    if (typeof resource.bundle === 'boolean') {
+        return resource.bundle;
+    }
+    if (!resource.src) {
+        // Cannot determine without a source path
+        return false;
+    }
+    try {
+        // 2. Find the actual entry point
+        const entryPoint = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+        // 3. Check if the resolved entry point is a TypeScript file
+        return entryPoint.endsWith('.ts');
+    }
+    catch (err) {
+        // If we cannot find the entry point, we cannot determine if it's TS.
+        // Log a warning and default to false (don't bundle).
+        console.warn(`[warn] Could not determine entry point for function "${resource.displayName ?? resource.name}" while checking if bundling is needed: ${err instanceof Error ? err.message : err}`);
+        return false;
+    }
+}

package/dist/utils/invoke-local.d.ts

@@ -1,3 +1,3 @@
-import type { InvocationResponse, InvokeContextOptions } from './types.js';
+import type { InvocationResponse, InvokeContextOptions, LocalFunctionResource } from './types.js';
 export declare function sanitizeLogs(logs: string): string;
-export default function invoke(srcPath: string, data: null | object, context: InvokeContextOptions, timeout?: number): Promise<InvocationResponse>;
+export default function invoke(resource: LocalFunctionResource, data: Record<string, unknown> | null, context: InvokeContextOptions, timeout?: number): Promise<InvocationResponse>;

package/dist/utils/invoke-local.js

@@ -1,42 +1,80 @@
 import { spawn } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
 import { setTimeout } from 'node:timers';
 import config from '../config.js';
+import { bundleFunction } from './bundle/bundle-function.js';
+import { findFunctionEntryPoint } from './functions/find-entry-point.js';
+import { shouldBundleFunction } from './functions/should-bundle.js';
 function getChildProcessWrapperPath() {
     return new URL('./child-process-wrapper.js', import.meta.url).pathname;
 }
 export function sanitizeLogs(logs) {
     return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
 }
-export default async function invoke(srcPath, data, context, timeout = 5) {
+export default async function invoke(resource, data, context, timeout = 5) {
+    if (!resource.src) {
+        throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+    }
+    let cleanupBundle = async () => { };
+    let functionPath = '';
+    let bundleTimings = undefined;
+    if (await shouldBundleFunction(resource)) {
+        const bundleResult = await bundleFunction(resource);
+        functionPath = await findFunctionEntryPoint(bundleResult.outputDir);
+        bundleTimings = bundleResult.timings;
+        cleanupBundle = bundleResult.cleanup;
+    }
+    else {
+        functionPath = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+    }
     return new Promise((resolve, reject) => {
         let child;
         let timer;
+        let executionStart;
         function start() {
-            child = spawn('node', [getChildProcessWrapperPath()], {
+            executionStart = performance.now();
+            child = spawn('node', ['--enable-source-maps', getChildProcessWrapperPath()], {
                 cwd: cwd(),
                 stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
             });
-            // Note: start a timeout so child process doesn't run forever
             child.on('message', (data) => {
+                const executionTimeMs = performance.now() - executionStart;
                 const { json, logs } = JSON.parse(data.toString());
                 shutdown();
-                resolve({ json, logs: sanitizeLogs(logs), error: '' });
+                resolve({
+                    json,
+                    logs: sanitizeLogs(logs),
+                    error: undefined,
+                    timings: {
+                        ...bundleTimings,
+                        execute: executionTimeMs,
+                    },
+                });
             });
             child.on('error', (error) => {
+                shutdown();
                 reject(new Error(`encountered error ${error.message}`));
             });
             child.on('exit', (code) => {
+                const executionTimeMs = performance.now() - executionStart;
                 shutdown();
                 if (code !== 0) {
                     reject(new Error(`exited with code ${code}`));
                 }
                 else {
-                    resolve({ json: {}, logs: '', error: '' });
+                    resolve({
+                        json: {},
+                        logs: '',
+                        error: undefined,
+                        timings: {
+                            ...bundleTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
                 }
             });
             timer = setTimeout(() => {
-                // timedOut = true
                 shutdown();
                 reject(new Error(`Timed out after hitting its ${timeout}s timeout!`));
             }, timeout * 1000);
@@ -51,11 +89,14 @@ export default async function invoke(srcPath, data, context, timeout = 5) {
                     },
                 },
             };
-            child.send(JSON.stringify({ srcPath, payload }, null, 2));
+            child.send(JSON.stringify({ srcPath: functionPath, payload }, null, 2));
         }
         function shutdown() {
             clearTimeout(timer);
-            child.kill();
+            if (child && !child.killed) {
+                child.kill();
+            }
+            cleanupBundle().catch((err) => console.warn('Bundle cleanup failed:', err));
         }
         start();
     });

package/dist/utils/is-record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/utils/is-record.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/utils/parse-json-object.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonObject(jsonString: string): null | Record<string, unknown>;

package/dist/utils/parse-json-object.js

@@ -0,0 +1,10 @@
+import { isRecord } from './is-record.js';
+export function parseJsonObject(jsonString) {
+    try {
+        const o = JSON.parse(jsonString);
+        return isRecord(o) ? o : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/types.d.ts

@@ -12,7 +12,7 @@ export interface LocalBlueprint {
     /** @link https://github.com/sanity-io/blueprints-rfc/blob/main/readme.md#outputs */
     outputs?: Array<Record<string, unknown>>;
     /** @link https://github.com/sanity-io/blueprints-rfc/blob/main/readme.md#resources */
-    resources?: Array<LocalResource>;
+    resources?: Array<LocalResource | LocalFunctionResource>;
     /** @link https://github.com/sanity-io/blueprints-rfc/blob/main/readme.md#parameters */
     parameters?: Array<{
         name: string;
@@ -51,6 +51,7 @@ export declare function isLocalFunctionResource(r: LocalResource): r is LocalFun
 /** @internal */
 export interface LocalFunctionResource extends LocalResource {
     src?: string;
+    bundle?: boolean;
     memory?: number;
     timeout?: number;
     env?: Record<string, string>;
@@ -115,6 +116,7 @@ export interface InvocationResponse {
     error: undefined | unknown;
     json: object | undefined;
     logs: string | undefined;
+    timings?: Record<string, number>;
 }
 /** @internal */
 export interface BlueprintLog {

package/oclif.manifest.json

@@ -769,5 +769,5 @@
       ]
     }
   },
-  "version": "4.4.0"
+  "version": "4.5.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -47,6 +47,7 @@
     "postbuild": "oclif manifest && oclif readme",
     "build:ts": "shx rm -rf dist *.tsbuildinfo && tsc -b",
     "build:static": "npm run copy:wrapper && npm run copy:server",
+    "clean": "shx rm -rf dist oclif.manifest.json",
     "copy:server": "shx cp -r ./src/server/static ./dist/server",
     "copy:wrapper": "shx cp ./src/utils/child-process-wrapper.js ./dist/utils/child-process-wrapper.js",
     "lint": "biome ci",
@@ -68,6 +69,8 @@
     "eventsource": "^3.0.6",
     "inquirer": "^12.5.2",
     "mime-types": "^3.0.1",
+    "vite": "^6.3.3",
+    "vite-tsconfig-paths": "^5.1.4",
     "xdg-basedir": "^5.1.0",
     "yocto-spinner": "^0.2.1"
   },

package/dist/utils/is-json.d.ts

@@ -1 +0,0 @@
-export default function isJson(jsonString: string): null | object;

package/dist/utils/is-json.js

@@ -1,12 +0,0 @@
-export default function isJson(jsonString) {
-    try {
-        const o = JSON.parse(jsonString);
-        if (o && typeof o === 'object') {
-            return o;
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}