@sanity/runtime-cli 17.9.0-blueprinit.g14aaebd → 17.10.0-next.g5e0bba6

package/dist/cores/blueprints/plan.js

@@ -3,6 +3,7 @@ import { planStack, resolveStackIdByNameOrId } from '../../actions/blueprints/st
 import { extractDurableConfig } from '../../utils/blueprints/extract-durable-config.js';
 import { createHintCollector } from '../../utils/blueprints/hints.js';
 import { formatDeploymentPlan, formatResourceTree, hasActionableChanges, } from '../../utils/display/blueprints-formatting.js';
+import { runCommand } from '../../utils/package-manager.js';
 import { styleText } from '../../utils/style-text.js';
 import { getWarnings } from '../../utils/warnings.js';
 export async function blueprintPlanCore(options) {
@@ -18,12 +19,14 @@ export async function blueprintPlanCore(options) {
             ? {
                 success: false,
                 error: 'Missing authentication token',
-                suggestions: [`Run \`npx ${bin} login\` to authenticate.`],
+                suggestions: [`Run \`${runCommand(bin)} login\` to authenticate.`],
             }
             : {
                 success: false,
                 error: 'Missing Blueprint configuration',
-                suggestions: [`Run \`npx ${bin} blueprints doctor --fix\` to fix your configuration.`],
+                suggestions: [
+                    `Run \`${runCommand(bin)} blueprints doctor --fix\` to fix your configuration.`,
+                ],
             };
     }
     const stackId = flags.stack
@@ -34,7 +37,9 @@ export async function blueprintPlanCore(options) {
         return {
             success: false,
             error: 'Missing Stack deployment configuration',
-            suggestions: [`Run \`npx ${bin} blueprints doctor --fix\` to fix your configuration.`],
+            suggestions: [
+                `Run \`${runCommand(bin)} blueprints doctor --fix\` to fix your configuration.`,
+            ],
         };
     }
     const auth = { token, scopeType, scopeId };
@@ -69,7 +74,7 @@ export async function blueprintPlanCore(options) {
             error: 'Deployment plan has problems',
             suggestions: [
                 ...hints.getSuggestions(),
-                `Fix the issues above, then run \`npx ${bin} blueprints deploy\`.`,
+                `Fix the issues above, then run \`${runCommand(bin)} blueprints plan\` again.`,
             ],
         };
     }
@@ -77,10 +82,10 @@ export async function blueprintPlanCore(options) {
     log('');
     log(formatDeploymentPlan(planResponse.deploymentPlan));
     if (hasActionableChanges(planResponse.deploymentPlan)) {
-        log(`\n  Run "${styleText(['bold', 'magenta'], `npx ${bin} blueprints deploy`)}" to apply these Stack changes`);
+        log(`\n  Run "${styleText(['bold', 'magenta'], `${runCommand(bin)} blueprints deploy`)}" to apply these Stack changes`);
     }
     else {
-        log(`\n  ${styleText('dim', `No significant changes to deploy. Run \`npx ${bin} blueprints deploy\` to apply.`)}`);
+        log(`\n  ${styleText('dim', `No significant changes to deploy. Run \`${runCommand(bin)} blueprints deploy\` to apply.`)}`);
     }
     return {
         success: true,

package/dist/cores/blueprints/promote.js

@@ -2,6 +2,7 @@ import { confirm } from '@inquirer/prompts';
 import { patchConfigFile } from '../../actions/blueprints/config.js';
 import { promoteStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
+import { runCommand } from '../../utils/package-manager.js';
 export async function blueprintPromoteCore(options) {
     const { bin = 'sanity', log, stackId, auth, flags, deployedStack, blueprint } = options;
     const newStackName = flags['new-stack-name'];
@@ -47,7 +48,7 @@ export async function blueprintPromoteCore(options) {
             if (error && /access|permission|forbidden/i.test(error)) {
                 suggestions.push('Verify you have organization admin access.');
             }
-            suggestions.push(`Run \`npx ${bin} blueprints info\` to check the current Stack scope.`);
+            suggestions.push(`Run \`${runCommand(bin)} blueprints info\` to check the current Stack scope.`);
             return { success: false, error: error || 'Failed to promote Stack', suggestions };
         }
         spinner.stop().clear();
@@ -66,7 +67,7 @@ export async function blueprintPromoteCore(options) {
                 success: false,
                 error: 'Stack promoted, but could not update Blueprint config (.sanity/blueprint.config.json).',
                 suggestions: [
-                    `Run \`npx ${bin} blueprints config --edit\` to update your Blueprint config manually.`,
+                    `Run \`${runCommand(bin)} blueprints config --edit\` to update your Blueprint config manually.`,
                 ],
             };
         }

package/dist/cores/functions/add.js

@@ -8,7 +8,9 @@ import { verifyExampleExists, writeExample } from '../../actions/sanity/examples
 import { EVENT_DOCUMENT_CREATE, EVENT_DOCUMENT_DELETE, EVENT_DOCUMENT_UPDATE, EVENT_MEDIA_LIBRARY_ASSET_CREATE, EVENT_MEDIA_LIBRARY_ASSET_DELETE, EVENT_MEDIA_LIBRARY_ASSET_UPDATE, EVENT_PUBSUB, EVENT_SCHEDULED, EVENT_SYNC_TAG_INVALIDATE, FUNCTION_TYPES, LABEL_DOCUMENT_CREATE, LABEL_DOCUMENT_DELETE, LABEL_DOCUMENT_UPDATE, LABEL_MEDIA_LIBRARY_ASSET_CREATE, LABEL_MEDIA_LIBRARY_ASSET_DELETE, LABEL_MEDIA_LIBRARY_ASSET_UPDATE, LABEL_PUBSUB, LABEL_SCHEDULED, LABEL_SYNC_TAG_INVALIDATE, MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
 import { check, indent, warn } from '../../utils/display/presenters.js';
 import { validateFunctionName } from '../../utils/functions/validate-name.js';
+import { detectPackageManager } from '../../utils/package-manager.js';
 import { styleText } from '../../utils/style-text.js';
+import { INSTALLER_OPTIONS } from '../../utils/types.js';
 import { getWarnings } from '../../utils/warnings.js';
 export const generateFunctionBlueprintResourceTemplate = (fnName, eventNames) => {
     const functionType = MAP_EVENT_TO_FUNCTION_TYPE[eventNames[0]];
@@ -44,7 +46,8 @@ export async function functionAddCore(options) {
     const root = cwd();
     const { log, blueprint, flags } = options;
     const { blueprintFilePath } = blueprint.fileInfo;
-    const warnings = getWarnings({ dir: dirname(blueprintFilePath) });
+    const blueprintFileDir = dirname(blueprintFilePath);
+    const warnings = getWarnings({ dir: blueprintFileDir });
     const { example: flagExample, name: flagResourceName, type: flagType, javascript: flagJs, helpers: flagHelpers, install: flagI, installer: flagInstaller, } = flags;
     let { language: flagLang } = flags;
     flagLang = flagJs ? 'js' : flagLang;
@@ -183,7 +186,7 @@ export async function functionAddCore(options) {
         }
         else {
             addHelpers = flagHelpers || (await promptForAddHelpers());
-            installCommand = addHelpers ? await promptForInstallCommand() : null;
+            installCommand = addHelpers ? await promptForInstallCommand(blueprintFileDir) : null;
         }
         if (installCommand)
             log(`${styleText('magenta', 'Installing')} with ${installCommand}...`);
@@ -286,16 +289,17 @@ async function promptForAddHelpers() {
     });
     return addHelpers;
 }
-async function promptForInstallCommand() {
+async function promptForInstallCommand(dir) {
+    // hydrate only supports these three; a detected bun falls back to npm
+    const detected = detectPackageManager(dir);
+    const preferred = INSTALLER_OPTIONS.find((option) => option === detected) ?? 'npm';
     const command = await select({
         message: 'How to install the @sanity/functions helpers:',
         choices: [
-            { name: 'npm', value: 'npm' },
-            { name: 'pnpm', value: 'pnpm' },
-            { name: 'yarn', value: 'yarn' },
+            ...INSTALLER_OPTIONS.map((option) => ({ name: option, value: option })),
             { name: 'Skip install', value: null },
         ],
-        default: 'npm',
+        default: preferred,
     });
     return command;
 }

package/dist/cores/functions/logs.js

@@ -58,8 +58,7 @@ async function streamLogs({ name, externalId, auth, log, }) {
             alreadyOpened = true;
         };
         const renderLog = (logEntry) => {
-            const { time, level, message } = logEntry;
-            log(formatLog(time, level, message, true));
+            log(formatLog(logEntry, true));
         };
         streamLogsAction(externalId, auth, renderLog, onOpen, (error) => log.error(`${styleText('red', 'Error:')} ${error}`), log);
         // Return a special key for streaming mode
@@ -92,27 +91,72 @@ async function getLogs({ name, externalId, auth, limit, json, utc, log, }) {
         const logLength = filteredLogs.length;
         log(`Found ${styleText('bold', logLength.toString())} log ${logLength === 1 ? 'entry' : 'entries'} for function ${styleText('yellow', name)}`);
         log('\n');
-        for (const { time, level, message } of filteredLogs) {
-            log(formatLog(time, level, message, utc));
+        for (const entry of filteredLogs) {
+            log(formatLog(entry, utc));
         }
     }
     else {
-        return { success: true, json: { logs: filteredLogs } };
+        const cleaned = filteredLogs.map(({ time, level, message, operationName, attempt, requestId, executionArn, }) => {
+            const isDurable = executionArn !== undefined;
+            const isStep = operationName !== undefined || attempt !== undefined;
+            const durableContext = isDurable ? (isStep ? 'step' : 'handler') : undefined;
+            return {
+                time,
+                level,
+                message,
+                requestId,
+                ...(durableContext ? { durableContext } : {}),
+                ...(operationName !== undefined ? { step: operationName } : {}),
+                ...(attempt !== undefined ? { attempt } : {}),
+            };
+        });
+        return { success: true, json: { logs: cleaned } };
     }
     return { success: true };
 }
-function formatLog(time, level, message, utc) {
+/**
+ * Formats a log entry for display in the console.
+ * @param entry
+ * @param utc
+ */
+function formatLog(entry, utc) {
+    const { time, level, message, operationName, attempt, executionArn } = entry;
     const date = new Date(time);
     const [dateString, timeString] = utc
         ? date.toISOString().slice(0, 19).split('T')
         : [date.toLocaleDateString(), date.toLocaleTimeString()];
+    const durableAnnotation = durableLogAnnotation({ operationName, attempt, executionArn });
     return [
         styleText('bold', dateString),
         styleText(['bold', 'blue'], timeString),
         logLevel(level.toUpperCase()),
+        ...(durableAnnotation ? [durableAnnotation] : []),
         message,
     ].join(' ');
 }
+/**
+ * Log annotation for durable functions.
+ * @param operationName
+ * @param attempt
+ * @param executionArn
+ */
+function durableLogAnnotation({ operationName, attempt, executionArn, }) {
+    /**
+     * executionArn is included on durable function logs, but not on regular function logs.
+     * If executionArn is defined, we can assume the log is from a durable function.
+     * If executionArn is defined and operationName and attempt are undefined, the logger is in the handler context
+     */
+    const annotationParts = [
+        executionArn !== undefined && operationName === undefined && attempt === undefined
+            ? 'handler'
+            : undefined,
+        ...(operationName ? [operationName] : []),
+        attempt !== undefined ? `attempt:${attempt}` : undefined,
+    ].filter((part) => part !== undefined);
+    return annotationParts.length > 0
+        ? styleText('grey', `[${annotationParts.join('|')}]`)
+        : undefined;
+}
 function logLevel(level) {
     switch (level) {
         case 'ERROR':

package/dist/cores/index.d.ts

@@ -39,6 +39,11 @@ export type CoreResult = {
     ref?: string;
     /** A machine-readable error code. */
     code?: string;
+    /**
+     * The user cancelled a prompt. A calling core reads it to keep its own message.
+     * Not printed: `code` would surface as `Code:` in the command output.
+     */
+    cancelled?: true;
     /** Overrides the process exit code (defaults to oclif's 2). */
     exitCode?: number;
     streaming?: never;

package/dist/utils/blueprints/hints.js

@@ -1,3 +1,5 @@
+import { runCommand } from '../package-manager.js';
+const promoteToOrganization = (bin) => `Run \`${runCommand(bin)} blueprints promote\` to move from project to organization scope.`;
 /**
  * Patterns matched against ERROR/FATAL log entries during streaming operations
  * like deploy and destroy. Each entry is a [regex, suggestionFactory] tuple.
@@ -13,9 +15,12 @@ export const HINT_PATTERNS = [
     [
         // Function requires organization scope
         /must be attached to an organization scoped stack/,
-        (_match, bin) => [
-            `Run \`npx ${bin} blueprints promote\` to move from project to organization scope.`,
-        ],
+        (_match, bin) => [promoteToOrganization(bin)],
+    ],
+    [
+        // Resource needs an organization the project-scoped Stack cannot supply
+        /[Cc]annot resolve organization scope/,
+        (_match, bin) => [promoteToOrganization(bin)],
     ],
 ];
 /**

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

@@ -3,6 +3,16 @@ import type { Logger } from '../logger.js';
 import type { ScopeType } from '../types.js';
 export declare const BACK: unique symbol;
 export type Back = typeof BACK;
+/** Thrown when the user picks "Cancel" in a prompt. Cores translate it to a clean result. */
+export declare class CancelledError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Ask where a new Blueprint should go.
+ * Returns the chosen directory, or null to use the current one.
+ * @throws CancelledError when the user cancels.
+ */
+export declare function promptForInitLocation(currentDir: string): Promise<string | null>;
 export declare function promptForBlueprintType(): Promise<string>;
 /**
  * Fetches organizations and prompts the user to pick one (if multiple).
@@ -48,12 +58,14 @@ export declare function promptForProjectInOrg({ projects, knownProjectId, logger
  * Prompt the user for a Stack after scope has been determined.
  * Can create a new Stack or select an existing one.
  */
-export declare function promptForStack({ scopeType, scopeId, token, logger, allowBack, }: {
+export declare function promptForStack({ scopeType, scopeId, token, logger, allowBack, suggestedName, }: {
     scopeType: ScopeType;
     scopeId: string;
     token: string;
     logger: Logger;
     allowBack?: boolean;
+    /** Prefilled name for a new Stack, usually the project directory name. */
+    suggestedName?: string;
 }): Promise<{
     stackId: string;
     name: string;
@@ -62,11 +74,12 @@ export declare function promptForStack({ scopeType, scopeId, token, logger, allo
  * Full wizard: Organization -> Scope -> Project (if project-scoped) -> Stack.
  * Supports back-navigation between steps.
  */
-export declare function runScopeAndStackWizard({ token, knownOrganizationId, knownProjectId, logger, }: {
+export declare function runScopeAndStackWizard({ token, knownOrganizationId, knownProjectId, logger, suggestedStackName, }: {
     token: string;
     knownOrganizationId?: string;
     knownProjectId?: string;
     logger: Logger;
+    suggestedStackName?: string;
 }): Promise<{
     scopeType: ScopeType;
     scopeId: string;

package/dist/utils/display/prompt.js

@@ -5,6 +5,13 @@ import { styleText } from '../style-text.js';
 import { niceId } from './presenters.js';
 // --- Wizard infrastructure ---
 export const BACK = Symbol('back');
+/** Thrown when the user picks "Cancel" in a prompt. Cores translate it to a clean result. */
+export class CancelledError extends Error {
+    constructor(message = 'Cancelled by user.') {
+        super(message);
+        this.name = 'CancelledError';
+    }
+}
 /**
  * Runs a sequence of prompt steps with back-navigation support.
  * Each step can return BACK to go to the previous non-skipped step.
@@ -57,13 +64,53 @@ function withBackChoice(choices, allowBack) {
     ];
 }
 // --- Standalone prompts ---
+/**
+ * Ask where a new Blueprint should go.
+ * Returns the chosen directory, or null to use the current one.
+ * @throws CancelledError when the user cancels.
+ */
+export async function promptForInitLocation(currentDir) {
+    const HERE = 'here';
+    const ELSEWHERE = 'elsewhere';
+    const CANCEL = 'cancel';
+    const choice = await select({
+        message: 'Where should the Blueprint go?',
+        choices: [
+            { name: 'Here', value: HERE, description: currentDir },
+            { name: 'In a new folder', value: ELSEWHERE, description: 'Name a folder to create' },
+            { name: 'Cancel', value: CANCEL, description: 'Stop here and change nothing' },
+        ],
+        default: HERE,
+    });
+    if (choice === CANCEL)
+        throw new CancelledError();
+    if (choice === HERE)
+        return null;
+    const folder = await input({
+        message: 'Folder name:',
+        validate: (val) => val.trim().length > 0 || 'A folder name is required',
+    });
+    return folder.trim();
+}
 export async function promptForBlueprintType() {
     return await select({
         message: 'Choose a Blueprint file type:',
         choices: [
-            { name: 'TypeScript', value: 'ts' },
-            { name: 'JavaScript', value: 'js' },
-            { name: 'JSON', value: 'json' },
+            {
+                name: 'TypeScript',
+                value: 'ts',
+                description: 'Editor completion and type checks. Adds @sanity/blueprints.',
+            },
+            {
+                name: 'JavaScript',
+                value: 'js',
+                description: 'The same define* helpers, without type checks. Adds @sanity/blueprints.',
+            },
+            {
+                name: 'JSON',
+                value: 'json',
+                description: 'No dependency and no install step. Write each resource by hand.',
+            },
         ],
         default: 'ts',
     });
@@ -203,7 +250,7 @@ export async function promptForProjectInOrg({ projects, knownProjectId, logger,
  * Prompt the user for a Stack after scope has been determined.
  * Can create a new Stack or select an existing one.
  */
-export async function promptForStack({ scopeType, scopeId, token, logger, allowBack = false, }) {
+export async function promptForStack({ scopeType, scopeId, token, logger, allowBack = false, suggestedName, }) {
     if (!scopeId) {
         throw new Error(`Cannot list Stacks: no ${scopeType} ID provided. ` +
             'Provide --project-id or --organization-id, or select a scope in the wizard.');
@@ -247,16 +294,30 @@ export async function promptForStack({ scopeType, scopeId, token, logger, allowB
         pickedStackId = answer;
     }
     else if (allowBack) {
+        const CANCEL = 'cancel';
         const proceed = await select({
-            message: 'No existing Stacks. Create a new one?',
-            choices: withBackChoice([{ name: 'Yes, create a new Stack', value: 'yes' }], allowBack),
+            message: 'This scope has no Stacks yet:',
+            choices: withBackChoice([
+                {
+                    name: 'Create the first Stack',
+                    value: NEW_STACK_ID,
+                    description: 'A Blueprint needs a Stack before it can deploy',
+                },
+                { name: 'Cancel', value: CANCEL, description: 'Stop here and change nothing' },
+            ], allowBack),
         });
         if (proceed === BACK)
             return BACK;
+        if (proceed === CANCEL)
+            throw new CancelledError();
     }
     if (pickedStackId === NEW_STACK_ID) {
+        // only suggest a free name; the API rejects a duplicate within a scope
+        const isTaken = stacks.some((s) => s.name === suggestedName);
+        logger(styleText('dim', 'The name is a label. Sanity assigns the Stack ID.'));
         const stackName = await input({
-            message: 'Enter a name for your new Stack:',
+            message: 'Name your new Stack:',
+            default: isTaken ? undefined : suggestedName,
             validate: (val) => val.length > 0 || 'Stack name is required',
         });
         const stack = await createEmptyStack({
@@ -277,7 +338,7 @@ export async function promptForStack({ scopeType, scopeId, token, logger, allowB
  * Full wizard: Organization -> Scope -> Project (if project-scoped) -> Stack.
  * Supports back-navigation between steps.
  */
-export async function runScopeAndStackWizard({ token, knownOrganizationId, knownProjectId, logger, }) {
+export async function runScopeAndStackWizard({ token, knownOrganizationId, knownProjectId, logger, suggestedStackName, }) {
     const steps = [
         {
             key: 'organization',
@@ -336,6 +397,7 @@ export async function runScopeAndStackWizard({ token, knownOrganizationId, known
                     token,
                     logger,
                     allowBack: true,
+                    suggestedName: suggestedStackName,
                 });
             },
         },

package/dist/utils/functions/child-runtime/durable.js

@@ -84,12 +84,29 @@ export async function runDurable(handler, {context, event}, io) {
   }
 
   const step = {
-    run: ({name, handler: fn}) => track(name || 'step-run', 'run', () => fn({logger, attempt: 1})),
+    run: ({name, handler: fn}) => track(name || '', 'run', () => fn({logger, attempt: 1})),
     wait: ({name, duration}) =>
-      track(name, 'wait', async () => {
+      track(name || '', 'wait', async () => {
         await io.wait(durationToMs(duration))
         return undefined
       }),
+    waitForCondition: ({name, initial, poller, next}) =>
+      track(name || '', 'wait-for-condition', async () => {
+        let state = initial
+        let attempt = 1
+        let polling = true
+        while (polling) {
+          state = await poller(state, {logger, attempt})
+          const decision = next(state, {attempt})
+          if (decision.shouldRetry) {
+            await io.wait(durationToMs(decision.delay))
+            attempt += 1
+          } else {
+            polling = false
+          }
+        }
+        return state
+      }),
   }
 
   return handler({context, event, step, logger})

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,20 @@
+/** Package managers this CLI can name in the commands it prints. */
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+/**
+ * Detect the package manager for a project.
+ *
+ * `npm_config_user_agent` is first then lockfile detection.
+ */
+export declare function detectPackageManager(dir?: string): PackageManager | undefined;
+/**
+ * The command that runs this CLI, matched to the detected package manager.
+ * Falls back to `npx`
+ *
+ * Yarn is weird: detected from a lockfile alone also falls bac
+ * lockfile name does not differentiate Yarn 1 vs Yarn 2+
+ */
+export declare function runCommand(bin: string, dir?: string): string;
+/** The command that installs dependencies, matched to the detected package manager. */
+export declare function installCommand(dir?: string): string;
+/** Clear the lockfile lookup cache. Tests use this after they move fixtures. */
+export declare function resetPackageManagerCache(): void;

package/dist/utils/package-manager.js

@@ -0,0 +1,63 @@
+import { basename } from 'node:path';
+import { getBinCommand, getRunningPackageManager } from '@sanity/cli-core/package-manager';
+import * as find from 'empathic/find';
+/**
+ * Lockfile names in priority order
+ */
+const LOCKFILES = {
+    'pnpm-lock.yaml': 'pnpm',
+    'yarn.lock': 'yarn',
+    'bun.lock': 'bun',
+    'bun.lockb': 'bun',
+    'package-lock.json': 'npm',
+};
+const LOCKFILE_NAMES = Object.keys(LOCKFILES);
+/** Minimal user agents, so the lockfile path reuses the same command mapping. */
+const SYNTHETIC_USER_AGENTS = {
+    npm: 'npm/0',
+    pnpm: 'pnpm/0',
+    yarn: 'yarn/0',
+    bun: 'bun/0',
+};
+const lockfileCache = new Map();
+/** Find the package manager a lockfile at or above `dir` implies. */
+function detectFromLockfile(dir) {
+    if (lockfileCache.has(dir))
+        return lockfileCache.get(dir);
+    const found = find.any(LOCKFILE_NAMES, { cwd: dir });
+    const manager = found ? LOCKFILES[basename(found)] : undefined;
+    lockfileCache.set(dir, manager);
+    return manager;
+}
+/**
+ * Detect the package manager for a project.
+ *
+ * `npm_config_user_agent` is first then lockfile detection.
+ */
+export function detectPackageManager(dir = process.cwd()) {
+    return getRunningPackageManager() ?? detectFromLockfile(dir);
+}
+/**
+ * The command that runs this CLI, matched to the detected package manager.
+ * Falls back to `npx`
+ *
+ * Yarn is weird: detected from a lockfile alone also falls bac
+ * lockfile name does not differentiate Yarn 1 vs Yarn 2+
+ */
+export function runCommand(bin, dir) {
+    const running = getRunningPackageManager();
+    if (running)
+        return getBinCommand({ bin });
+    const fromLockfile = detectFromLockfile(dir ?? process.cwd());
+    if (!fromLockfile || fromLockfile === 'yarn')
+        return `npx ${bin}`;
+    return getBinCommand({ bin, userAgent: SYNTHETIC_USER_AGENTS[fromLockfile] });
+}
+/** The command that installs dependencies, matched to the detected package manager. */
+export function installCommand(dir) {
+    return `${detectPackageManager(dir) ?? 'npm'} install`;
+}
+/** Clear the lockfile lookup cache. Tests use this after they move fixtures. */
+export function resetPackageManagerCache() {
+    lockfileCache.clear();
+}

package/dist/utils/types.d.ts

@@ -262,8 +262,17 @@ export interface FunctionLog {
     requestId: string;
     level: string;
     message: string;
+    operationName?: string;
+    attempt?: number;
+    operationId?: string;
+    executionArn?: string;
 }
 /** @internal */
+export type FunctionLogJson = Omit<FunctionLog, 'executionArn' | 'operationId' | 'operationName'> & {
+    durableContext?: 'handler' | 'step';
+    step?: string;
+};
+/** @internal */
 export declare enum BlueprintParserErrorType {
     InvalidProperty = "invalid_property",
     InvalidVersion = "invalid_version",
@@ -304,7 +313,7 @@ export type Warning = {
     suggestions: string[];
 };
 /** @internal */
-export type DurableOperationSteps = 'run' | 'wait';
+export type DurableOperationSteps = 'run' | 'wait' | 'waitForCondition';
 /** @internal */
 export type DurableStepPhase = 'start' | 'complete' | 'error';
 /**