@sanity/runtime-cli 3.2.0 → 4.1.0

package/dist/commands/blueprints/config.js

@@ -1,10 +1,11 @@
 import { Command, Flags } from '@oclif/core';
 import highlight from 'color-json';
 import inquirer from 'inquirer';
-import { readConfigFile, writeConfigFile } from '../../actions/blueprints/blueprint.js';
+import { readBlueprintOnDisk, writeConfigFile } from '../../actions/blueprints/blueprint.js';
 import { listProjects } from '../../actions/blueprints/projects.js';
 import { listStacks } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
+import { bold, dim, niceId } from '../../utils/display/colors.js';
 const { token } = config;
 export default class Config extends Command {
     static description = 'View or edit Blueprint configuration';
@@ -20,12 +21,15 @@ export default class Config extends Command {
     };
     async run() {
         const { flags } = await this.parse(Config);
-        const config = readConfigFile();
-        if (!config) {
-            this.error('No configuration found. Run `sanity blueprints init` first.');
+        const blueprint = await readBlueprintOnDisk();
+        const { stackId: configStackId, projectId: configProjectId, configPath, fileInfo } = blueprint;
+        const { extension: blueprintExtension, blueprintFilePath } = fileInfo;
+        if (!configStackId && !configProjectId) {
+            this.log('Project and Stack configuration is missing.');
         }
-        this.log('\nCurrent configuration:');
-        this.log(highlight(JSON.stringify(config, null, 2)));
+        this.log(bold('Current configuration:'));
+        this.log(`Sanity Project:  ${niceId(configProjectId)}`);
+        this.log(`Blueprint Stack: ${niceId(configStackId)}`);
         if (!flags.edit)
             return;
         const { ok, projects, error } = await listProjects({ token });
@@ -34,9 +38,9 @@ export default class Config extends Command {
         if (projects.length === 0) {
             this.error('No projects found. Please create a project in Sanity.io first.');
         }
-        const projectChoices = projects.map(({ displayName, id }) => ({
-            name: `${displayName} <${id}>`,
-            value: id,
+        const projectChoices = projects.map(({ displayName, id: projectId }) => ({
+            name: `"${displayName}" ${niceId(projectId)}`,
+            value: projectId,
         }));
         const { projectId } = await inquirer.prompt([
             {
@@ -44,7 +48,7 @@ export default class Config extends Command {
                 name: 'projectId',
                 message: 'Select your Sanity project:',
                 choices: projectChoices,
-                default: config.projectId,
+                default: configProjectId,
             },
         ]);
         const auth = { token, projectId };
@@ -54,22 +58,30 @@ export default class Config extends Command {
             this.error(stacksError ?? 'Unknown error listing stacks');
         let stackId;
         if (stacks.length > 0) {
-            const stackChoices = stacks.map(({ name, id }) => ({
-                name: `${name} <${id}>`,
-                value: id,
+            const stackChoices = stacks.map((s) => ({
+                name: `"${s.name}" ${niceId(s.id)} ${dim(`(${s.resources.length} res)`)}`,
+                value: s.id,
             }));
+            stackChoices.push({ name: 'Unset Stack association', value: 'unset' });
             const { stackId: selectedStackId } = await inquirer.prompt([
                 {
                     type: 'list',
                     name: 'stackId',
                     message: 'Select a stack:',
                     choices: stackChoices,
-                    default: config.stackId,
+                    default: configStackId,
                 },
             ]);
-            stackId = selectedStackId;
+            stackId = selectedStackId === 'unset' ? undefined : selectedStackId;
+        }
+        try {
+            // update or create .blueprint/config.json
+            writeConfigFile({ projectId, stackId });
+            this.log('Configuration updated successfully.');
+        }
+        catch (error) {
+            this.log('Unable to dynamically update config. Use these values in your blueprint:');
+            this.log(highlight(JSON.stringify({ metadata: { projectId, stackId } }, null, 2)));
         }
-        writeConfigFile({ projectId, stackId });
-        this.log('\nConfiguration updated successfully.');
     }
 }

package/dist/commands/blueprints/deploy.d.ts

@@ -2,5 +2,8 @@ import { Command } from '@oclif/core';
 export default class Deploy extends Command {
     static description: string;
     static examples: string[];
+    static flags: {
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/blueprints/deploy.js

@@ -1,55 +1,37 @@
-import { Command } from '@oclif/core';
-import inquirer from 'inquirer';
+import { setTimeout } from 'node:timers/promises';
+import { Command, Flags } from '@oclif/core';
 import Spinner from 'yocto-spinner';
 import { stashAsset } from '../../actions/blueprints/assets.js';
-import { readBlueprintOnDisk, writeConfigFile } from '../../actions/blueprints/blueprint.js';
-import { createStack, updateStack } from '../../actions/blueprints/stacks.js';
+import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
+import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
-import { bold, green, red, yellow } from '../../utils/display/colors.js';
+import { bold, niceId, red } from '../../utils/display/colors.js';
 import { isLocalFunctionResource } from '../../utils/types.js';
 const { token } = config;
 export default class Deploy extends Command {
     static description = 'Deploy a Blueprint';
     static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        'no-wait': Flags.boolean({
+            description: 'Do not wait for deployment to complete',
+            default: false,
+        }),
+    };
     async run() {
-        const { errors, projectId: configuredProjectId, stackId, parsedBlueprint: { resources }, deployedStack, } = await readBlueprintOnDisk({ getStack: true, token });
+        const { flags } = await this.parse(Deploy);
+        const { errors, projectId, stackId, parsedBlueprint: { resources }, deployedStack, } = await readBlueprintOnDisk({ getStack: true, token });
         if (errors.length > 0) {
             // printErrors(errors) // TODO: error printer in formatting
             this.log('Blueprint parse errors:');
             console.dir(errors, { depth: null });
             return;
         }
-        if (stackId && !deployedStack)
-            this.error('Stack ID defined but deployed stack not found');
-        let projectId = configuredProjectId;
-        if (!projectId) {
-            this.log('No Sanity Project context found in Blueprint configuration.');
-            const { maybeProjectId } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'maybeProjectId',
-                    message: 'Enter Sanity Project ID:',
-                },
-            ]);
-            projectId = maybeProjectId;
+        if (!deployedStack || !stackId || !projectId) {
+            this.error('Before deploying, run `sanity blueprints init`');
         }
-        if (!projectId)
-            this.error('Sanity Project context is required');
+        if (stackId !== deployedStack.id)
+            this.error('Stack ID mismatch');
         const auth = { token, projectId };
-        let name = deployedStack?.name;
-        if (!name) {
-            const { stackName } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'stackName',
-                    message: 'Enter stack name:',
-                    validate: (input) => input.length > 0 || 'Stack name is required',
-                },
-            ]);
-            name = stackName;
-        }
-        if (!name)
-            this.error('Stack name is required');
         const validResources = resources?.filter((r) => r.type);
         const functionResources = validResources?.filter(isLocalFunctionResource);
         // First stash all function assets
@@ -60,7 +42,7 @@ export default class Deploy extends Command {
                 if (result.success && result.assetId) {
                     const src = resource.src;
                     resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
-                    fnSpinner.success(`${resource.name} <${yellow(result.assetId)}>`);
+                    fnSpinner.success(`${resource.name} ${niceId(result.assetId)}`);
                     this.log(`   Source: ${src}`);
                 }
                 else {
@@ -71,23 +53,44 @@ export default class Deploy extends Command {
             }
         }
         const stackPayload = {
-            name,
             projectId,
+            name: deployedStack.name,
             document: { resources: validResources },
         };
         this.debug('BLUEPRINT DOCUMENT:', stackPayload);
         const spinner = Spinner({ text: 'Deploying stack...' }).start();
-        const { ok: deployOk, stack, error: deployError, } = deployedStack
-            ? await updateStack({ stackId: deployedStack.id, stackPayload, auth })
-            : await createStack({ stackPayload, auth });
+        const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId: deployedStack.id, stackPayload, auth });
         this.debug('STACK RESPONSE:', stack);
         if (deployOk) {
-            spinner.success(`${green('Success!')} Stack "${bold(stack.name)}" ${deployedStack ? 'updated' : 'created'} <${yellow(stack.id)}>`);
-            writeConfigFile({
-                projectId,
-                stackId: stack.id,
-            });
-            this.log('\nUse `sanity blueprints info` to check deployment status');
+            spinner.success(`Stack "${bold(stack.name)}" ${niceId(stack.id)} deployment started!`);
+            if (!flags['no-wait']) {
+                const waitSpinner = Spinner({ text: 'Waiting for deployment to complete...' }).start();
+                while (true) {
+                    // TODO: watch logs and print those while polling
+                    const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth });
+                    if (!ok) {
+                        waitSpinner.error('Failed to check deployment status');
+                        break;
+                    }
+                    const operation = currentStack.recentOperation;
+                    if (!operation) {
+                        waitSpinner.error('No operation found');
+                        break;
+                    }
+                    if (operation.status === 'COMPLETED') {
+                        waitSpinner.success('Deployment completed successfully');
+                        break;
+                    }
+                    if (operation.status === 'FAILED') {
+                        waitSpinner.error('Deployment failed');
+                        break;
+                    }
+                    await setTimeout(1000);
+                }
+            }
+            else {
+                this.log('Use `sanity blueprints info` to check deployment status');
+            }
         }
         else {
             this.debug('STACK ERROR RESPONSE:', stack);

package/dist/commands/blueprints/info.js

@@ -3,12 +3,13 @@ import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { getStack } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
 import { formatResourceTree, formatStackInfo } from '../../utils/display/blueprints-formatting.js';
+import { niceId } from '../../utils/display/colors.js';
 const { token } = config;
 export default class Info extends Command {
-    static description = 'Show information about a Blueprint';
+    static description = 'Show information about a deployed Blueprint Stack';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --id abc123',
+        '<%= config.bin %> <%= command.id %> --id ST-a1b2c3',
     ];
     static flags = {
         id: Flags.string({
@@ -18,25 +19,30 @@ export default class Info extends Command {
     };
     async run() {
         const { flags } = await this.parse(Info);
-        const { errors, deployedStack, projectId } = await readBlueprintOnDisk({ getStack: true, token });
+        const { errors, deployedStack, projectId, stackId } = await readBlueprintOnDisk({
+            getStack: true,
+            token,
+        });
         if (errors.length > 0) {
             // printErrors(errors)
             this.warn('Blueprint parse errors:');
             console.dir(errors, { depth: null });
             return;
         }
+        if (!stackId && !flags.id)
+            this.error('No Stack ID provided');
         if (!projectId)
-            this.error('Project resource not found in blueprint');
+            this.error('Missing Project ID for Blueprint');
         const auth = { token, projectId };
         let stack = deployedStack;
         if (flags.id) {
             const { ok, stack: foundStack, error } = await getStack({ stackId: flags.id, auth });
             if (!ok)
-                this.error(error || 'Failed to get stack');
+                this.error(`Failed to get Stack ${niceId(flags.id)}: ${error}`);
             stack = foundStack;
         }
         else if (!stack) {
-            this.error('No stack found');
+            this.error(`Stack ${niceId(stackId)} not found`);
         }
         if (!stack)
             this.error('Stack not found. Is it deployed?');

package/dist/commands/blueprints/init.js

@@ -4,13 +4,15 @@ import { Command } from '@oclif/core';
 import inquirer from 'inquirer';
 import { findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
 import { listProjects } from '../../actions/blueprints/projects.js';
+import { createStack, listStacks } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
+import { bold, dim, niceId, underline } from '../../utils/display/colors.js';
 const { token } = config;
 export default class Init extends Command {
     static description = 'Initialize a new Blueprint';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
-        const existingBlueprint = findBlueprintFile(undefined);
+        const existingBlueprint = findBlueprintFile();
         if (existingBlueprint) {
             this.error(`A blueprint file already exists: ${existingBlueprint.fileName}`);
         }
@@ -21,21 +23,21 @@ export default class Init extends Command {
                 message: 'Choose a blueprint type:',
                 choices: [
                     { name: 'JSON (Recommended)', value: 'json' },
-                    { name: 'JavaScript (Beta)', value: 'js' },
-                    { name: 'TypeScript (Alpha)', value: 'ts' },
+                    { name: 'JavaScript', value: 'js', disabled: true },
+                    { name: 'TypeScript', value: 'ts', disabled: true },
                 ],
                 default: 'json',
             },
         ]);
-        const { ok, projects, error } = await listProjects({ token });
-        if (!ok)
-            this.error(error ?? 'Unknown error listing projects');
+        const { ok: projectsOk, error: projectsErr, projects } = await listProjects({ token });
+        if (!projectsOk)
+            this.error(projectsErr ?? 'Unknown error listing projects');
         if (projects.length === 0) {
             this.error('No projects found. Please create a project in Sanity.io first.');
         }
-        const projectChoices = projects.map(({ displayName, id }) => ({
-            name: `${displayName} <${id}>`,
-            value: id,
+        const projectChoices = projects.map(({ displayName, id: projectId }) => ({
+            name: `"${displayName}" ${niceId(projectId)}`,
+            value: projectId,
         }));
         const { projectId } = await inquirer.prompt([
             {
@@ -45,11 +47,52 @@ export default class Init extends Command {
                 choices: projectChoices,
             },
         ]);
+        const { ok: stacksOk, error: stacksErr, stacks } = await listStacks({ token, projectId });
+        if (!stacksOk)
+            this.error(stacksErr || 'Failed to list Stacks');
+        const stackChoices = [{ name: bold('✨ Create a new Stack'), value: 'new' }];
+        if (stacks.length > 0) {
+            stackChoices.push(new inquirer.Separator(underline('Use an existing Stack:')));
+            stackChoices.push(...stacks.map((s) => ({
+                name: `"${s.name}" ${niceId(s.id)} ${dim(`(${s.resources.length} res)`)}`,
+                value: s.id,
+            })));
+        }
+        let stackId;
+        const { stackId: stackIdChoice } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'stackId',
+                message: 'Select your Blueprint Stack:',
+                choices: stackChoices,
+            },
+        ]);
+        if (stackIdChoice === 'new') {
+            const { stackName } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'stackName',
+                    message: 'Enter a name for your Stack:',
+                    validate: (input) => input.length > 0 || 'Stack name is required',
+                },
+            ]);
+            const { ok: stackOk, error: stackErr, stack, } = await createStack({
+                stackPayload: { name: stackName, projectId, document: { resources: [] } },
+                auth: { token, projectId },
+            });
+            if (!stackOk)
+                this.error(stackErr || 'Failed to create Stack');
+            stackId = stack.id;
+        }
+        else {
+            stackId = stackIdChoice;
+        }
         const fileName = `blueprint.${blueprintExtension}`;
         const filePath = join(cwd(), fileName);
-        writeBlueprintToDisk({ path: filePath, fileType: blueprintExtension });
-        writeConfigFile({ projectId });
+        writeBlueprintToDisk({ blueprintFilePath: filePath });
         this.log(`Created new blueprint: ./${fileName}`);
+        writeConfigFile({ blueprintFilePath: filePath, projectId, stackId });
+        this.log(`Created new config file: ./${fileName}.config.json`);
         if (blueprintExtension === 'ts') {
             this.log('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx');
         }

package/dist/commands/blueprints/logs.js

@@ -4,7 +4,7 @@ import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { findNewestLogTimestamp, getLogs, getRecentLogs, isNewerLog, streamLogs, } from '../../actions/blueprints/logs.js';
 import config from '../../config.js';
 import { formatTitle } from '../../utils/display/blueprints-formatting.js';
-import { bold, red, yellow } from '../../utils/display/colors.js';
+import { bold, niceId, red } from '../../utils/display/colors.js';
 import { formatLogEntry, formatLogsByDay, organizeLogsByDay, } from '../../utils/display/logs-formatting.js';
 const { token } = config;
 export default class Logs extends Command {
@@ -35,7 +35,7 @@ export default class Logs extends Command {
                 this.error('Stack not found'); // returns
             const { id: stackId, projectId, name } = deployedStack;
             const auth = { token, projectId };
-            const spinner = Spinner({ text: `Fetching logs for stack ${yellow(`<${stackId}>`)}` }).start();
+            const spinner = Spinner({ text: `Fetching logs for stack ${niceId(stackId)}` }).start();
             if (watchMode) {
                 const { ok, logs, error } = await getLogs(stackId, auth);
                 if (!ok) {
@@ -44,7 +44,7 @@ export default class Logs extends Command {
                     return;
                 }
                 spinner.stop().clear(); // stop and remove the spinner
-                this.log(`${formatTitle('Blueprint', name)} <${yellow(stackId)}> logs`);
+                this.log(`${formatTitle('Blueprint', name)} ${niceId(stackId)} logs`);
                 if (logs.length > 0) {
                     this.log('\nMost recent logs:');
                     const recentLogs = getRecentLogs(logs);
@@ -53,7 +53,7 @@ export default class Logs extends Command {
                     }
                 }
                 else {
-                    this.log(`No recent logs found for stack <${yellow(stackId)}>`);
+                    this.log(`No recent logs found for stack ${niceId(stackId)}`);
                 }
                 const onOpen = () => {
                     this.log(`Watching for new logs... ${bold('ctrl+c')} to stop`);
@@ -65,7 +65,7 @@ export default class Logs extends Command {
                     newestTimestamp = new Date(log.timestamp).getTime();
                     this.log(formatLogEntry(log, true));
                 };
-                this.debug(`${yellow('Debug:')} Connecting to streaming endpoint for stack ${stackId}...`);
+                this.debug(`Connecting to streaming endpoint for Stack ${niceId(stackId)}...`);
                 streamLogs(stackId, auth, renderLog, onOpen, (error) => this.log(`${red('Error:')} ${error}`));
                 return new Promise(() => {
                     // hold the line until the user terminates with Ctrl+C
@@ -82,7 +82,7 @@ export default class Logs extends Command {
                 return;
             }
             spinner.success(`${formatTitle('Blueprint', name)} Logs`);
-            this.log(`Found ${bold(logs.length.toString())} log entries for stack ${yellow(stackId)}\n`);
+            this.log(`Found ${bold(logs.length.toString())} log entries for Stack ${niceId(stackId)}\n`);
             // Organize and format logs by day
             const logsByDay = organizeLogsByDay(logs);
             this.log(formatLogsByDay(logsByDay));

package/dist/commands/blueprints/stacks.d.ts

@@ -2,5 +2,8 @@ import { Command } from '@oclif/core';
 export default class Stacks extends Command {
     static description: string;
     static examples: string[];
+    static flags: {
+        projectId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/blueprints/stacks.js

@@ -1,22 +1,46 @@
-import { Command } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
 import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { listStacks } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
 import { formatStacksListing } from '../../utils/display/blueprints-formatting.js';
-import { bold, yellow } from '../../utils/display/colors.js';
+import { bold, niceId } from '../../utils/display/colors.js';
 const { token } = config;
 export default class Stacks extends Command {
     static description = 'List all Blueprint stacks';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --projectId a1b2c3',
+    ];
+    static flags = {
+        projectId: Flags.string({
+            description: 'Project ID to show stacks for',
+            required: false,
+        }),
+    };
     async run() {
-        const { errors, projectId, stackId } = await readBlueprintOnDisk();
-        if (errors.length > 0) {
-            this.log('Blueprint parse errors:');
-            console.dir(errors, { depth: null });
+        const { flags } = await this.parse(Stacks);
+        let { projectId } = flags;
+        let stackId;
+        if (!projectId) {
+            try {
+                const { errors, projectId: projectIdFromBlueprint, stackId: stackIdFromBlueprint, } = await readBlueprintOnDisk();
+                if (errors.length > 0) {
+                    this.log('Blueprint parse errors:');
+                    console.dir(errors, { depth: null });
+                    return;
+                }
+                projectId = projectIdFromBlueprint;
+                stackId = stackIdFromBlueprint;
+            }
+            catch {
+                // continue to print error
+            }
+        }
+        if (!projectId) {
+            this.log('Unable to determine Project ID. Provide one with --projectId');
+            this.log('Or create a Blueprint with `sanity blueprints init`');
             return;
         }
-        if (!projectId)
-            this.error('Project resource not found in blueprint');
         const auth = { token, projectId };
         const { ok, stacks, error } = await listStacks(auth);
         if (!ok)
@@ -25,7 +49,7 @@ export default class Stacks extends Command {
             this.warn('No stacks found');
             return;
         }
-        this.log(`${bold('Project')} <${yellow(projectId)}> ${bold('Stacks')}:\n`);
+        this.log(`${bold('Project')} ${niceId(projectId)} ${bold('Stacks')}:\n`);
         this.log(formatStacksListing(stacks, stackId));
     }
 }

package/dist/commands/functions/test.js

@@ -51,9 +51,11 @@ export default class Test extends Command {
                 file: flags.file,
                 timeout: flags.timeout,
             }, {
-                apiVersion: flags.api,
-                dataset: flags.dataset,
-                projectId: flags.project,
+                clientOptions: {
+                    apiVersion: flags.api,
+                    dataset: flags.dataset,
+                    projectId: flags.project,
+                },
             });
             if (!error) {
                 this.log('Logs:');

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

@@ -21,9 +21,11 @@ class PayloadPanel extends ApiBaseElement {
     const payloadText = this.api.store.payload.state.doc.text.join('') || '{}'
     const event = JSON.parse(payloadText)
     const context = {
-      apiVersion: this.apiVersion.value,
-      dataset: this.api.store.selectedDataset,
-      projectId: this.api.store.selectedProject,
+      clientOptions: {
+        apiVersion: this.apiVersion.value,
+        dataset: this.api.store.selectedDataset,
+        projectId: this.api.store.selectedProject,
+      },
     }
     this.api.invoke({context, event})
   }

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

@@ -13,30 +13,6 @@ export function getFunctionSource(src) {
   return src
 }
 
-async function enhanceContext(context = {}) {
-  const {apiHost, apiVersion, dataset, projectId, token} = context
-  const enhancedContext = {...context}
-
-  try {
-    if (apiHost && apiVersion && dataset && projectId && token) {
-      // @ts-ignore
-      const {createClient} = await import('@sanity/client')
-      const client = createClient({
-        projectId,
-        dataset,
-        useCdn: true,
-        apiHost,
-        apiVersion,
-        token,
-      })
-      enhancedContext.client = client
-    }
-  } catch {
-    // ignore as user hasn't provided the @sanity/client
-  }
-  return enhancedContext
-}
-
 // Start when payload data arrives from parent process
 process.on('message', async (data) => {
   let jsonData = null
@@ -48,7 +24,6 @@ process.on('message', async (data) => {
   }
   const {srcPath, payload} = jsonData
   const {context, ...event} = payload
-  const enhancedContext = await enhanceContext(context)
   let logs = ''
   let json = null
 
@@ -67,7 +42,7 @@ process.on('message', async (data) => {
   }
 
   if (handler && typeof handler === 'function') {
-    json = await handler({context: enhancedContext, event})
+    json = await handler({context, event})
   }
 
   // revert changes to stdout