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

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-process-wrapper.js

@@ -41,7 +41,7 @@ process.on('message', async (data) => {
 
   // Otherwise this is the initial start message. Support the legacy untyped
   // `{srcPath, payload}` shape as well as the new `{type: 'start', ...}`.
-  const {srcPath, payload, isDurable} = jsonData
+  const {srcPath, payload, isDurable, noWait} = jsonData
   const {context, ...event} = payload
 
   let logs = ''
@@ -83,9 +83,10 @@ process.on('message', async (data) => {
     if (isDurable) {
       json = await runDurable(
         handler,
-        {context, event, logger: console},
+        {context, event},
         {
           emit: (e) => process.send(JSON.stringify({type: 'step-event', event: e})),
+          wait: (ms) => new Promise((resolve) => setTimeout(resolve, noWait ? 0 : ms)),
         },
       )
     } else {

package/dist/utils/functions/child-runtime/durable.d.ts

@@ -1,5 +1,5 @@
 import type {DurableContext, DurableHandler, DurableLogger, GenericEvent} from '@sanity/functions'
-import type {DurableStepEvent} from '../../types.js'
+import type {DurableRuntimeEvent} from '../../types.js'
 
 type RunDurableArgs = {
   context: DurableContext
@@ -8,7 +8,7 @@ type RunDurableArgs = {
 }
 
 type DurableIO = {
-  emit: (event: DurableStepEvent) => void
+  emit: (event: DurableRuntimeEvent) => void
 }
 
 export function runDurable(

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

@@ -1,17 +1,60 @@
 import {performance} from 'node:perf_hooks'
+import {inspect} from 'node:util'
+
+/**
+ *
+ * @param duration
+ * @return {number}
+ */
+const durationToMs = (duration = {}) => {
+  const {days = 0, hours = 0, minutes = 0, seconds = 0} = duration
+  return (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000
+}
+
+/**
+ *
+ * @param args
+ */
+const formatArgs = (args) =>
+  args.map((a) => (typeof a === 'string' ? a : inspect(a, {depth: null}))).join(' ')
 
 /**
  * Runs a durable function handler
  * @param handler - callback being run
  * @param context - data to send to the operation
  * @param event - the step being run
- * @param logger
  * @param io
  */
-export async function runDurable(handler, {context, event, logger}, io) {
+export async function runDurable(handler, {context, event}, io) {
+  let currentStep = null
+  const streamLog = (level, args) => {
+    const date = new Date()
+    const timestamp = `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`
+
+    return io.emit({
+      timestamp,
+      kind: 'log',
+      phase: 'log',
+      step: currentStep,
+      level,
+      message: formatArgs(args),
+    })
+  }
+
+  // @todo: need to throw error for use of `console.log` in a durable function
+  const logger = {
+    log: (...a) => streamLog('info', a),
+    info: (...a) => streamLog('info', a),
+    warn: (...a) => streamLog('warn', a),
+    error: (...a) => streamLog('error', a),
+  }
+
   const track = async (name, kind, produce) => {
     io.emit({name, kind, phase: 'start'})
     const startedAt = performance.now()
+    const prev = currentStep
+    currentStep = name
+
     try {
       const value = await produce()
       io.emit({
@@ -35,11 +78,35 @@ export async function runDurable(handler, {context, event, logger}, io) {
         durationMs: performance.now() - startedAt,
       })
       throw err
+    } finally {
+      currentStep = prev
     }
   }
 
   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 () => {
+        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/functions/durable-logs.d.ts

@@ -0,0 +1,16 @@
+import type { DurableLogEvent, DurableRuntimeEvent, DurableStepEvent } from '../types.js';
+type DurableLogLine = Pick<DurableLogEvent, 'level' | 'message'>;
+type DurableJsonStep = DurableStepEvent & {
+    logs: DurableLogLine[];
+};
+/**
+ * Records a durable log event
+ */
+export declare const createDurableJsonCollector: () => {
+    record: (event: DurableRuntimeEvent) => void;
+    result: () => {
+        steps: DurableJsonStep[];
+        logs: DurableLogLine[];
+    };
+};
+export {};

package/dist/utils/functions/durable-logs.js

@@ -0,0 +1,52 @@
+/**
+ * Records a durable log event
+ */
+export const createDurableJsonCollector = () => {
+    const steps = [];
+    const logLines = [];
+    const activeSteps = new Map();
+    function record(event) {
+        if (event.kind === 'log') {
+            const logLine = {
+                level: event.level,
+                message: event.message,
+            };
+            if (event.step === null) {
+                logLines.push(logLine);
+                return;
+            }
+            const step = activeSteps.get(event.step);
+            if (step) {
+                step.logs.push(logLine);
+                return;
+            }
+            logLines.push(logLine);
+            return;
+        }
+        if (event.phase === 'start') {
+            const step = {
+                ...event,
+                logs: [],
+            };
+            steps.push(step);
+            activeSteps.set(event.name, step);
+            return;
+        }
+        const step = activeSteps.get(event.name);
+        if (!step)
+            return;
+        step.phase = event.phase;
+        step.durationMs = event.durationMs;
+        if (event.phase === 'complete') {
+            step.output = event.output;
+        }
+        if (event.phase === 'error') {
+            step.error = event.error;
+        }
+        activeSteps.delete(event.name);
+    }
+    return {
+        record,
+        result: () => ({ steps, logs: logLines }),
+    };
+};

package/dist/utils/functions/invoke/local.js

@@ -47,7 +47,7 @@ export default async function invoke(resource, payload, context, options) {
     if (!resource.src) {
         throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
     }
-    const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [], onStepEvent = () => { }, } = options;
+    const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [], onStepEvent = () => { }, noWait = false, } = options;
     // `payload.payload` is the event body for every function type: the document for
     // GROQ-based events, whatever the producer sent for the rest. The handler always
     // receives it as `event.data` (see the `payload` built in `start()` below).
@@ -306,6 +306,7 @@ export default async function invoke(resource, payload, context, options) {
                 srcPath: functionPath,
                 payload,
                 isDurable: resource.type === SANITY_FUNCTION_DURABLE,
+                noWait,
             };
             child.send(JSON.stringify(startMessage));
         }

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

@@ -162,7 +162,9 @@ export interface InvokeExecutionOptions {
     /** Function names already on the invoke call stack (innermost last), used to detect cycles. @internal */
     callStack?: string[];
     /** Stream a durable step transition to the caller. @internal */
-    onStepEvent?: (event: DurableStepEvent) => void;
+    onStepEvent?: (event: DurableRuntimeEvent) => void;
+    /** Don't wait the full duration during a wait durable event @internal */
+    noWait?: boolean;
 }
 /**
  * Re-entrant callback that executes a named function from the blueprint on behalf
@@ -181,6 +183,7 @@ export type ParentToChildMessage = {
     srcPath: string;
     payload: unknown;
     isDurable?: boolean;
+    noWait?: boolean;
 } | {
     type: 'invoke-response';
     id: string;
@@ -195,7 +198,7 @@ export type ParentToChildMessage = {
     error: InvocationError;
 } | {
     type: 'step-event';
-    event: DurableStepEvent;
+    event: DurableRuntimeEvent;
 };
 /**
  * IPC messages sent from a function child process back up to the parent.
@@ -217,7 +220,7 @@ export type ChildToParentMessage = {
     error?: InvocationError;
 } | {
     type: 'step-event';
-    event: DurableStepEvent;
+    event: DurableRuntimeEvent;
 };
 /** @internal */
 export interface InvocationResponse {
@@ -259,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",
@@ -301,7 +313,7 @@ export type Warning = {
     suggestions: string[];
 };
 /** @internal */
-export type DurableOperationSteps = 'run';
+export type DurableOperationSteps = 'run' | 'wait' | 'waitForCondition';
 /** @internal */
 export type DurableStepPhase = 'start' | 'complete' | 'error';
 /**
@@ -315,6 +327,15 @@ export interface DurableStepEvent {
     error?: InvocationError;
     durationMs?: number;
 }
+export interface DurableLogEvent {
+    kind: 'log';
+    phase: 'log';
+    step: string | null;
+    level: 'info' | 'warn' | 'error';
+    message: string;
+    timestamp?: string;
+}
+export type DurableRuntimeEvent = DurableStepEvent | DurableLogEvent;
 export interface FunctionTestFlags {
     data?: string;
     event?: string;
@@ -333,5 +354,7 @@ export interface FunctionTestFlags {
     'document-id-before'?: string;
     'document-id-after'?: string;
     'media-library-id'?: string;
+    'no-wait'?: boolean;
+    json?: boolean;
 }
 export {};

package/oclif.manifest.json

@@ -2755,6 +2755,13 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "no-wait": {
+          "description": "Skip durable wait delays instead of sleeping",
+          "name": "no-wait",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -3141,5 +3148,5 @@
       ]
     }
   },
-  "version": "17.9.0"
+  "version": "17.10.0-next.g5e0bba6"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.9.0",
+  "version": "17.10.0-next.g5e0bba6",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -100,7 +100,7 @@
     "@oclif/test": "^4.1.22",
     "@playwright/test": "^1.62.1",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@sanity/functions": "^1.6.6",
+    "@sanity/functions": "^1.7.1",
     "@types/adm-zip": "^0.5.8",
     "@types/cardinal": "^2.1.1",
     "@types/mime-types": "^3.0.1",