@sanity/runtime-cli 16.0.3 → 17.1.0

package/dist/utils/logger.d.ts

@@ -5,6 +5,7 @@ export declare function Logger(log: (msg: string) => void, flags?: {
     json?: boolean;
 }): {
     (msg: string): void;
+    isTraceEnabled: boolean;
     trace(formatter: unknown, ...args: unknown[]): false | void;
     verbose(formatter: unknown, ...args: unknown[]): false | void;
     info(formatter: unknown, ...args: unknown[]): false | void;

package/dist/utils/logger.js

@@ -13,6 +13,7 @@ export function Logger(log, flags = {}) {
         log(msg);
     };
     const level = flags.verbose ? LogLevel.VERBOSE : flags.trace ? LogLevel.TRACE : LogLevel.INFO;
+    logger.isTraceEnabled = level <= LogLevel.TRACE;
     logger.trace = (formatter, ...args) => level <= LogLevel.TRACE && logger(format(formatter, ...args));
     logger.verbose = (formatter, ...args) => level <= LogLevel.VERBOSE && logger(format(formatter, ...args));
     logger.info = (formatter, ...args) => level <= LogLevel.INFO && logger(format(formatter, ...args));

package/dist/utils/style-text.js

@@ -1,5 +1,6 @@
-import { env, stdout } from 'node:process';
+import { env } from 'node:process';
 import { styleText as nodeStyleText } from 'node:util';
+import { isInteractive } from './interactive.js';
 function supportsColor() {
     /*
      * https://force-color.org
@@ -32,10 +33,8 @@ function supportsColor() {
     if (env.NODE_DISABLE_COLORS !== undefined && env.NODE_DISABLE_COLORS !== '') {
         return false;
     }
-    /*
-     * If the stdout is a TTY, use colors.
-     */
-    return typeof stdout?.isTTY === 'boolean' && stdout.isTTY;
+    // if interactive, use colors
+    return isInteractive;
 }
 export const styleText = (format, text) => {
     if (!supportsColor())

package/dist/utils/traced-fetch.js

@@ -173,6 +173,8 @@ export function createTracedFetch(logger, options) {
         ...options,
     };
     return async (input, init) => {
+        if (!logger.isTraceEnabled)
+            return fetch(input, init);
         const requestId = randomUUID().slice(0, 3);
         const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
         const method = init?.method || 'GET';

package/dist/utils/types.d.ts

@@ -98,13 +98,14 @@ export interface InvokeGroqPayloadOptions {
     before: Record<string, unknown> | null;
     after: Record<string, unknown> | null;
 }
-export interface InvokeSchedulePayloadOptions {
+export interface InvokeNonGroqPayloadOptions {
     payload?: Record<string, unknown>;
-    event: 'scheduled';
+    event: NonGroqEventType;
 }
-export type InvokePayloadOptions = InvokeGroqPayloadOptions | InvokeSchedulePayloadOptions;
-export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'before' | 'after'> | Pick<InvokeSchedulePayloadOptions, 'event'>;
+export type InvokePayloadOptions = InvokeGroqPayloadOptions | InvokeNonGroqPayloadOptions;
+export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'before' | 'after'> | Pick<InvokeNonGroqPayloadOptions, 'event'>;
 export type EventType = 'create' | 'update' | 'delete';
+export type NonGroqEventType = 'scheduled' | 'nested';
 export declare function isEventType(arg: string): arg is EventType;
 /** @internal */
 export interface InvokeGroqContextOptions {
@@ -140,7 +141,64 @@ export declare function isGroqContextOptions(context: InvokeContextOptions): con
 export interface InvokeExecutionOptions {
     forceColor?: boolean;
     timeout?: number;
+    /**
+     * Callback used to resolve a nested `context.invoke(name, payload)` made from
+     * within a running function. When absent, nested invokes are rejected.
+     * @internal
+     */
+    onNestedInvoke?: NestedInvoke;
+    /** Current invocation depth, used to bound nested `context.invoke` recursion. @internal */
+    depth?: number;
+    /** Function names already on the invoke call stack (innermost last), used to detect cycles. @internal */
+    callStack?: string[];
 }
+/**
+ * Re-entrant callback that executes a named function from the blueprint on behalf
+ * of a nested `context.invoke(name, payload)` and returns its invocation result.
+ * @internal
+ */
+export type NestedInvoke = (name: string, payload: Record<string, unknown>, context: InvokeContextOptions, depth: number, callStack: string[]) => Promise<InvocationResponse & {
+    timings: Record<string, number>;
+}>;
+/**
+ * IPC messages sent from the parent (invoke-local) down to a function child process.
+ * @internal
+ */
+export type ParentToChildMessage = {
+    type: 'start';
+    srcPath: string;
+    payload: unknown;
+} | {
+    type: 'invoke-response';
+    id: string;
+    ok: true;
+    result: {
+        json: JsonInvocationResponse | undefined;
+    };
+} | {
+    type: 'invoke-response';
+    id: string;
+    ok: false;
+    error: InvocationError;
+};
+/**
+ * IPC messages sent from a function child process back up to the parent.
+ * `result` is terminal and triggers shutdown; `invoke-request` is a nested
+ * `context.invoke` awaiting a correlated `invoke-response`.
+ * @internal
+ */
+export type ChildToParentMessage = {
+    type: 'invoke-request';
+    id: string;
+    name: string;
+    payload: Record<string, unknown>;
+} | {
+    type: 'result';
+    json?: JsonInvocationResponse;
+    logs?: string;
+    errorLogs?: string;
+    error?: InvocationError;
+};
 /** @internal */
 export interface InvocationResponse {
     error: InvocationError | undefined;