@sanity/runtime-cli 17.15.0 → 17.16.0-app-functions.gab0267c

package/dist/functions/contracts.js

@@ -0,0 +1,119 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript-compiler';
+import { findFunctionEntryPoint } from '../utils/functions/find-entry-point.js';
+import { contractType, schemaFromType } from './contracts/schema.js';
+import { jsonGuard, validatorSource } from './contracts/validation.js';
+/** Discover input and output types without loading or executing function code. */
+export async function generateFunctionContracts(options) {
+    const entries = await Promise.all(options.functions.map(async (fn) => ({
+        ...fn,
+        entryPoint: await findFunctionEntryPoint(path.resolve(options.workDir, fn.src), fn.name),
+    })));
+    const config = readProjectConfig(options.workDir);
+    const program = ts.createProgram(entries.map((fn) => fn.entryPoint), {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        ...config?.options,
+        allowJs: true,
+        checkJs: true,
+        noEmit: true,
+        strict: true,
+        strictNullChecks: true,
+        skipLibCheck: true,
+        composite: false,
+        incremental: false,
+        declaration: false,
+        declarationMap: false,
+        tsBuildInfoFile: undefined,
+    });
+    assertDiagnostics(ts.getPreEmitDiagnostics(program), options.workDir);
+    const checker = program.getTypeChecker();
+    return entries.map((fn) => readContract(checker, program, fn));
+}
+/** Check app consumers after regenerating their function registry. */
+export function checkFunctionTypes(workDir) {
+    const config = readProjectConfig(workDir);
+    if (!config)
+        return;
+    const program = ts.createProgram({
+        rootNames: config.fileNames,
+        options: { ...config.options, noEmit: true, incremental: false, tsBuildInfoFile: undefined },
+        projectReferences: config.projectReferences,
+    });
+    assertDiagnostics(ts.getPreEmitDiagnostics(program), workDir);
+}
+function readProjectConfig(workDir) {
+    const configPath = ts.findConfigFile(workDir, ts.sys.fileExists);
+    if (!configPath)
+        return undefined;
+    const config = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (config.error)
+        assertDiagnostics([config.error], workDir);
+    const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
+    assertDiagnostics(parsed.errors, workDir);
+    return parsed;
+}
+function assertDiagnostics(diagnostics, workDir) {
+    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    if (errors.length)
+        throw new Error(ts.formatDiagnostics(errors, {
+            getCanonicalFileName: (file) => file,
+            getCurrentDirectory: () => workDir,
+            getNewLine: () => '\n',
+        }));
+}
+function readContract(checker, program, fn) {
+    const source = program.getSourceFile(fn.entryPoint);
+    const module = source && checker.getSymbolAtLocation(source);
+    const exported = module && checker.getExportsOfModule(module).find((item) => item.getName() === 'handler');
+    if (!source || !exported)
+        throw new Error(`Function "${fn.name}" must export handler.`);
+    const signatures = checker.getTypeOfSymbolAtLocation(exported, source).getCallSignatures();
+    if (signatures.length !== 1)
+        throw new Error(`Function "${fn.name}" must have one handler signature.`);
+    const signature = signatures[0];
+    if (signature.parameters.length > 1)
+        throw new Error(`Function "${fn.name}" must accept a single FunctionArgs envelope.`);
+    let input = { kind: 'void' };
+    const parameter = signature.parameters[0];
+    if (parameter) {
+        const args = checker.getTypeOfSymbolAtLocation(parameter, source);
+        const event = args.getProperty('event');
+        const eventType = event && checker.getTypeOfSymbolAtLocation(event, source);
+        const data = eventType?.getProperty('data');
+        if (!data)
+            throw new Error(`Function "${fn.name}" must annotate its input with FunctionArgs<Input>.`);
+        input = schemaFromType(checker, checker.getTypeOfSymbolAtLocation(data, source), `${fn.name} input`, true);
+    }
+    const isObjectInput = (schema) => schema.kind === 'object' || (schema.kind === 'union' && schema.variants.every(isObjectInput));
+    if (input.kind !== 'void' && !isObjectInput(input))
+        throw new Error(`Function "${fn.name}" input must be a JSON object or omitted. Put scalar values inside an input object.`);
+    const returnType = checker.getReturnTypeOfSignature(signature);
+    const output = schemaFromType(checker, checker.getAwaitedType(returnType) ?? returnType, `${fn.name} output`, true);
+    return { ...fn, input, output };
+}
+const generatedHeader = '// Generated by Sanity CLI. Do not edit.\n';
+/** Emit a standalone declaration registry and browser-safe validators. */
+export async function writeFunctionContracts(workDir, contracts) {
+    const declarations = `${generatedHeader}import '@sanity/sdk'\n\ndeclare module '@sanity/sdk' {\n  interface AppFunctionRegistry {\n${contracts.map((fn) => `    ${JSON.stringify(fn.name)}: {input: ${contractType(fn.input)}; output: ${contractType(fn.output)}}`).join('\n')}\n  }\n}\n`;
+    const client = `${generatedHeader}${jsonGuard}\nexport const functionContracts = Object.fromEntries([\n${contracts.map((fn) => `[${JSON.stringify(fn.name)}, {hasInput: ${fn.input.kind !== 'void'}, validateInput: ${validatorSource(fn.input)}, validateOutput: ${validatorSource(fn.output)}}]`).join(',\n')}\n])\n`;
+    await writeGenerated(path.join(workDir, 'sanity.functions.d.ts'), declarations);
+    await writeGenerated(path.join(workDir, '.sanity', 'function-contracts.js'), client);
+}
+async function writeGenerated(file, content) {
+    try {
+        const previous = await readFile(file, 'utf8');
+        if (!previous.startsWith(generatedHeader))
+            throw new Error(`Refusing to overwrite non-generated file ${file}. Move it before generating function contracts.`);
+        if (previous === content)
+            return;
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
+            throw error;
+    }
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, content);
+}

package/dist/functions/deploy.d.ts

@@ -0,0 +1,15 @@
+import type { CoreResult } from '../cores/index.js';
+/** Deploy already-built PubSub functions to an app-owned organization stack. */
+export declare function deployFunctions(options: {
+    appId: string;
+    organizationId: string;
+    stackId: string;
+    workDir: string;
+    functions: {
+        name: string;
+        src: string;
+    }[];
+    token: string;
+    fetchFn: typeof fetch;
+    log: (message: string) => void;
+}): Promise<CoreResult>;

package/dist/functions/deploy.js

@@ -0,0 +1,60 @@
+import { getStack } from '../actions/blueprints/stacks.js';
+import { deployResourcesCore } from '../cores/blueprints/deploy.js';
+import { Logger } from '../utils/logger.js';
+import { readFunctionBuild } from './artifacts.js';
+import { assertAppFunctionStack } from './stack.js';
+/** Deploy already-built PubSub functions to an app-owned organization stack. */
+export async function deployFunctions(options) {
+    const { organizationId, stackId, workDir, fetchFn } = options;
+    const auth = {
+        token: options.token,
+        scopeType: 'organization',
+        scopeId: organizationId,
+    };
+    const result = await getStack({ stackId, auth, fetchFn });
+    if (!result.ok)
+        return { success: false, error: result.error || 'Could not read app function stack' };
+    const stack = result.stack;
+    try {
+        assertAppFunctionStack(stack, options);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    if (stack.resources.some((resource) => resource.type !== 'sanity.function.pubsub')) {
+        return {
+            success: false,
+            error: 'The app function stack contains other resource types. Use a dedicated app function stack.',
+        };
+    }
+    const resources = [];
+    for (const fn of options.functions) {
+        let src;
+        try {
+            src = (await readFunctionBuild({ ...fn, workDir })).src;
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+        resources.push({
+            name: fn.name,
+            type: 'sanity.function.pubsub',
+            src,
+            transpile: false,
+            autoResolveDeps: false,
+        });
+    }
+    return deployResourcesCore({
+        auth,
+        stackId,
+        scopeType: 'organization',
+        scopeId: organizationId,
+        deployedStack: stack,
+        resources,
+        workDir,
+        fetchFn,
+        bin: 'sanity',
+        flags: {},
+        log: Logger(options.log, { json: true }),
+    });
+}

package/dist/functions/stack.d.ts

@@ -0,0 +1,37 @@
+import type { CoreResult } from '../cores/index.js';
+import type { Stack, StackSummary } from '../utils/types.js';
+interface AppFunctionIdentity {
+    appId: string;
+    organizationId: string;
+}
+/** Shared ownership check for provisioning and deploying an app's function stack. */
+export declare function assertAppFunctionStack(stack: Stack | StackSummary, { appId, organizationId }: AppFunctionIdentity): void;
+/** Resolve or create a dedicated app stack using the Blueprint stack operations. */
+export declare function ensureFunctionStack(options: AppFunctionIdentity & {
+    token: string;
+    fetchFn: typeof fetch;
+    stackId?: string;
+    dryRun?: boolean;
+}): Promise<{
+    created: boolean;
+    id: string;
+} | null>;
+export { BLUEPRINTS_API_VERSION } from '../config.js';
+/** Scope and transport for looking up an app's function stack. */
+export interface FunctionStackOptions extends AppFunctionIdentity {
+    token: string;
+    fetchFn: typeof fetch;
+    stackId?: string;
+}
+/** Read-only stack metadata for an undeploy plan. */
+export interface FunctionStackInfo {
+    id: string;
+    functions: string[];
+}
+/** Find an app-owned stack without creating one, and verify all resources are app functions. */
+export declare function inspectFunctionStack(options: FunctionStackOptions): Promise<FunctionStackInfo | null>;
+/** Destroy an app's stack using Blueprint deletion and operation polling. Missing stacks are already clean. */
+export declare function destroyFunctionStack(options: FunctionStackOptions & {
+    stackId: string;
+    log: (message: string) => void;
+}): Promise<CoreResult>;

package/dist/functions/stack.js

@@ -0,0 +1,148 @@
+import { createStack, destroyStack, getStack, listStacks } from '../actions/blueprints/stacks.js';
+import { waitForDestruction } from '../cores/blueprints/destroy.js';
+import { Logger } from '../utils/logger.js';
+/** Shared ownership check for provisioning and deploying an app's function stack. */
+export function assertAppFunctionStack(stack, { appId, organizationId }) {
+    if (!stack ||
+        typeof stack.id !== 'string' ||
+        !stack.id ||
+        stack.name !== appFunctionStackName(appId) ||
+        stack.scopeType !== 'organization' ||
+        stack.scopeId !== organizationId) {
+        throw new Error(`The function stack does not belong to app "${appId}" in organization "${organizationId}". Check .sanity/app-functions.json.`);
+    }
+}
+/** Resolve or create a dedicated app stack using the Blueprint stack operations. */
+export async function ensureFunctionStack(options) {
+    const { appId, organizationId, token, fetchFn, stackId, dryRun = false } = options;
+    const auth = { token, scopeType: 'organization', scopeId: organizationId };
+    const name = appFunctionStackName(appId);
+    const logger = Logger(() => { }, { json: true });
+    const resolved = (stack, created) => {
+        assertAppFunctionStack(stack, options);
+        return { created, id: stack.id };
+    };
+    if (stackId) {
+        const result = await getStack({ stackId, auth, fetchFn });
+        if (result.ok)
+            return resolved(result.stack, false);
+        if (result.response?.status !== 404)
+            throw stackRequestError(result);
+    }
+    async function findStack() {
+        let cursor;
+        const cursors = new Set();
+        do {
+            const result = await listStacks(auth, logger, { fetchFn, cursor, limit: 500 });
+            if (!result.ok)
+                throw stackRequestError(result);
+            if (!Array.isArray(result.stacks))
+                throw new Error('Invalid Blueprint stack list response.');
+            const stack = result.stacks.find((item) => item?.name === name);
+            if (stack)
+                return stack;
+            if (result.response?.headers.get('x-has-more') !== 'true')
+                return undefined;
+            cursor = result.response.headers.get('x-cursor') ?? undefined;
+            if (!cursor || cursors.has(cursor))
+                throw new Error('Cannot read the next page of Blueprint stacks. Try again.');
+            cursors.add(cursor);
+        } while (cursor);
+        return undefined;
+    }
+    const existing = await findStack();
+    if (existing)
+        return resolved(existing, false);
+    if (dryRun)
+        return null;
+    const result = await createStack({
+        auth,
+        logger,
+        fetchFn,
+        stackMutation: {
+            name,
+            scopeType: auth.scopeType,
+            scopeId: auth.scopeId,
+            document: { resources: [] },
+        },
+    });
+    if (result.ok)
+        return resolved(result.stack, true);
+    if (result.response?.status === 409) {
+        const concurrent = await findStack();
+        if (concurrent)
+            return resolved(concurrent, false);
+    }
+    throw stackRequestError(result);
+}
+function appFunctionStackName(appId) {
+    return `app-${appId}`;
+}
+function stackRequestError(result) {
+    const status = result.response ? ` (${result.response.status})` : '';
+    return new Error(`Blueprint stack request failed${status}: ${result.error || result.response?.statusText || 'Unknown error'}`);
+}
+export { BLUEPRINTS_API_VERSION } from '../config.js';
+/** Find an app-owned stack without creating one, and verify all resources are app functions. */
+export async function inspectFunctionStack(options) {
+    const found = await ensureFunctionStack({ ...options, dryRun: true });
+    if (!found)
+        return null;
+    const stack = await readOwnedFunctionStack({ ...options, stackId: found.id });
+    return stack ? { id: stack.id, functions: stack.resources.map((resource) => resource.name) } : null;
+}
+/** Destroy an app's stack using Blueprint deletion and operation polling. Missing stacks are already clean. */
+export async function destroyFunctionStack(options) {
+    try {
+        const stack = await readOwnedFunctionStack(options);
+        if (!stack)
+            return { success: true };
+        const log = Logger(options.log, { json: true });
+        const auth = {
+            token: options.token,
+            scopeType: 'organization',
+            scopeId: options.organizationId,
+        };
+        const result = await destroyStack({
+            stackId: stack.id,
+            auth,
+            logger: log,
+            fetchFn: options.fetchFn,
+        });
+        if (!result.ok) {
+            if (result.response?.status === 404)
+                return { success: true };
+            return { success: false, error: result.error, requestId: result.requestId };
+        }
+        return await waitForDestruction({
+            stackId: stack.id,
+            stackName: stack.name,
+            operationId: result.stack.operationId,
+            requestId: result.requestId,
+            auth,
+            log,
+            bin: 'sanity',
+            fetchFn: options.fetchFn,
+        });
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function readOwnedFunctionStack(options) {
+    const auth = {
+        token: options.token,
+        scopeType: 'organization',
+        scopeId: options.organizationId,
+    };
+    const result = await getStack({ stackId: options.stackId, auth, fetchFn: options.fetchFn });
+    if (!result.ok) {
+        if (result.response?.status === 404)
+            return null;
+        throw stackRequestError(result);
+    }
+    assertAppFunctionStack(result.stack, options);
+    if (result.stack.resources.some((resource) => resource.type !== 'sanity.function.pubsub'))
+        throw new Error('The app function stack contains other resource types. Manage it with sanity blueprints instead.');
+    return result.stack;
+}

package/dist/server/app.js

@@ -1,14 +1,14 @@
 import { existsSync, readFileSync, watchFile } from 'node:fs';
 import * as http from 'node:http';
 import { dirname } from 'node:path';
+import { resolveStackConfig } from '@sanity/blueprints/resolve';
 import { default as mime } from 'mime-types';
 import { WebSocket, WebSocketServer } from 'ws';
 import { findBlueprintFile, loadAndParseBlueprint } from '../actions/blueprints/blueprint.js';
 import { readConfigFile } from '../actions/blueprints/config.js';
-import { resolveIds } from '../actions/blueprints/resolve.js';
 import config from '../config.js';
 import { isRecord } from '../utils/is-record.js';
-import { isEventType, isGroqContextOptions, } from '../utils/types.js';
+import { isEventType, } from '../utils/types.js';
 import { handleInvokeRequest } from './handlers/invoke.js';
 const app = (host, port, validateResources, executionOptions) => {
     // Send a JSON envelope to every connected UI client.
@@ -47,7 +47,7 @@ const app = (host, port, validateResources, executionOptions) => {
                     const blueprint = await loadAndParseBlueprint(undefined, { validateResources });
                     const { parsedBlueprint, fileInfo, module: blueprintModule } = blueprint;
                     const blueprintConfig = readConfigFile(fileInfo.blueprintFilePath);
-                    const { projectId, organizationId } = resolveIds({
+                    const { projectId, organizationId } = resolveStackConfig({
                         module: blueprintModule,
                         config: blueprintConfig,
                     });
@@ -75,7 +75,7 @@ const app = (host, port, validateResources, executionOptions) => {
                             const { data, func: functionName, metadata, } = parseInvokeRequest(Buffer.concat(body), dirname(fileInfo.blueprintFilePath));
                             const { context, event } = data;
                             // replace user token if required
-                            if (isGroqContextOptions(context)) {
+                            if ('clientOptions' in context) {
                                 if (context.clientOptions.token) {
                                     context.clientOptions.token = config.token || undefined;
                                 }

package/dist/server/static/components/app.css

@@ -191,7 +191,7 @@ body {
 .border-right {
   border-right-width: 1px;
   border-right-style: solid;
-  border-top-color: var(--card-border-color);
+  border-right-color: var(--card-border-color);
 }
 
 .hr-border {
@@ -413,6 +413,13 @@ ol[type='content'] li:hover:not(.selected:not(.selected)) {
   border-right: none;
 }
 
+fieldset {
+  & :is(input:not([role='switch']), select, textarea) {
+    border: 1px solid light-dark(var(--gray-200), var(--gray-800)) !important;
+    border-radius: var(--radius-2);
+  }
+}
+
 & :is(input:not([is='switch']), select, textarea) {
   border: 1px solid light-dark(var(--gray-200), var(--gray-800)) !important;
   border-radius: var(--radius-2);

package/dist/utils/blueprints/group-resources.d.ts

@@ -1,8 +1,9 @@
 import type { BlueprintResource } from '@sanity/blueprints';
+import type { ResolvedResource } from '../types.js';
 export type GroupedBlueprintResource = {
     id: string;
     name: string;
     type: string;
 };
 export type GroupedBlueprintResources = Record<string, GroupedBlueprintResource[]>;
-export declare function groupBlueprintResources(blueprintResources: BlueprintResource[]): GroupedBlueprintResources;
+export declare function groupBlueprintResources(blueprintResources: ResolvedResource<BlueprintResource>[]): GroupedBlueprintResources;

package/dist/utils/blueprints/group-resources.js

@@ -8,7 +8,8 @@ const BLUEPRINT_TYPE_TO_KEY = {
 };
 export function groupBlueprintResources(blueprintResources) {
     const grouped = {};
-    for (const resource of blueprintResources) {
+    for (const resolvedResource of blueprintResources) {
+        const resource = resolvedResource.resource;
         if (resource.type === 'sanity.access.robot')
             continue;
         const key = (resource.type?.startsWith('sanity.function.')
@@ -18,9 +19,8 @@ export function groupBlueprintResources(blueprintResources) {
             continue;
         if (!grouped[key])
             grouped[key] = [];
-        const externalId = resource.externalId;
         grouped[key].push({
-            id: externalId || 'not-deployed',
+            id: resolvedResource.externalId || 'not-deployed',
             name: resource.name,
             type: resource.type,
         });

package/dist/utils/blueprints/resolve-deployed-resources.d.ts

@@ -1,5 +1,5 @@
 import type { BlueprintResource } from '@sanity/blueprints';
-import type { AuthParams } from '../types.js';
+import type { AuthParams, ResolvedResource } from '../types.js';
 interface ResolveOptions {
     resources: BlueprintResource[];
     stackId?: string;
@@ -12,5 +12,5 @@ interface ResolveOptions {
  * resources that aren't yet deployed are preserved without an externalId.
  * Any failure to fetch the stack falls back to the raw local resources.
  */
-export declare function resolveDeployedResources({ resources, stackId, auth, fetchFn, }: ResolveOptions): Promise<BlueprintResource[]>;
+export declare function resolveDeployedResources({ resources, stackId, auth, fetchFn, }: ResolveOptions): Promise<ResolvedResource<BlueprintResource>[]>;
 export {};

package/dist/utils/blueprints/resolve-deployed-resources.js

@@ -7,11 +7,11 @@ import { getStack } from '../../actions/blueprints/stacks.js';
  */
 export async function resolveDeployedResources({ resources, stackId, auth, fetchFn, }) {
     if (!stackId || !auth?.token || !auth.scopeType || !auth.scopeId)
-        return resources;
+        return resources.map((r) => ({ resource: r }));
     try {
         const response = await getStack({ stackId, auth, fetchFn });
         if (!response.ok || !Array.isArray(response.stack?.resources))
-            return resources;
+            return resources.map((r) => ({ resource: r }));
         const deployedByKey = new Map();
         for (const deployed of response.stack.resources) {
             if (deployed.externalId) {
@@ -20,10 +20,10 @@ export async function resolveDeployedResources({ resources, stackId, auth, fetch
         }
         return resources.map((resource) => {
             const externalId = deployedByKey.get(`${resource.type}:${resource.name}`);
-            return externalId ? { ...resource, externalId } : resource;
+            return { resource, externalId };
         });
     }
     catch {
-        return resources;
+        return resources.map((r) => ({ resource: r }));
     }
 }

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

@@ -1,7 +1,7 @@
 import type { BlueprintApplicationResource, BlueprintInstallationConfigResource, BlueprintStudioResource } from '@sanity/blueprints';
 import { type BuildStudioEventListener } from '@sanity/cli-build/_internal/build';
 import type { Output } from '@sanity/cli-core';
-import type { AssetPrepResult } from '../types.js';
+import type { AssetPrepResult, ResolvedResource } from '../types.js';
 export type BundleResource = BlueprintStudioResource | BlueprintApplicationResource | BlueprintInstallationConfigResource;
 type BuildContext<R extends BundleResource> = {
     resource: R;
@@ -28,9 +28,9 @@ export declare const BUNDLE_SPECS: {
         build: typeof buildInstallationConfigBundle;
     };
 };
-export declare function prepareBundleAsset<R extends BundleResource>({ blueprintFileDir, resource, }: {
+export declare function prepareBundleAsset<R extends BundleResource>({ blueprintFileDir, resolvedResource, }: {
     blueprintFileDir: string;
-    resource: R;
+    resolvedResource: ResolvedResource<R>;
 }): Promise<AssetPrepResult>;
 declare function buildStudioBundle({ resource, appId, workDir, outDir, output, eventListener, }: BuildContext<BlueprintStudioResource>): Promise<BuildResult>;
 declare function buildApplicationBundle({ resource, appId, workDir, outDir, output, eventListener, }: BuildContext<BlueprintApplicationResource>): Promise<BuildResult>;

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

@@ -12,10 +12,11 @@ export const BUNDLE_SPECS = {
     'sanity.application': { requiresAppId: true, build: buildApplicationBundle },
     'sanity.installation.config': { requiresAppId: false, build: buildInstallationConfigBundle },
 };
-export async function prepareBundleAsset({ blueprintFileDir, resource, }) {
+export async function prepareBundleAsset({ blueprintFileDir, resolvedResource, }) {
+    const resource = resolvedResource.resource;
     // The lookup can't prove it yields the spec matching this R, so it's asserted once here.
     const spec = BUNDLE_SPECS[resource.type];
-    const appId = getAppId(resource);
+    const appId = getAppId(resolvedResource);
     if (spec.requiresAppId && !appId) {
         return {
             success: false,
@@ -260,12 +261,12 @@ async function getInstalledSanityVersion(workDir) {
         return undefined;
     }
 }
-function getAppId(resource) {
-    if ('externalId' in resource && typeof resource.externalId === 'string' && resource.externalId) {
-        return resource.externalId;
+function getAppId(resolvedResource) {
+    if (resolvedResource.externalId) {
+        return resolvedResource.externalId;
     }
-    else if (resource.lifecycle?.ownershipAction?.type === 'attach') {
-        return resource.lifecycle.ownershipAction.id;
+    else if (resolvedResource.resource.lifecycle?.ownershipAction?.type === 'attach') {
+        return resolvedResource.resource.lifecycle.ownershipAction.id;
     }
     return undefined;
 }

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

@@ -86,7 +86,7 @@ process.on('message', async (data) => {
         {
           emit: (e) => process.send(JSON.stringify({type: 'step-event', event: e})),
           wait: (ms) => new Promise((resolve) => setTimeout(resolve, noWait ? 0 : ms)),
-          invoke: invoker.invoke,
+          invoke: invoker.delegate,
         },
       )
     } else {