@sanity/runtime-cli 12.4.0 → 13.0.1

package/dist/utils/functions/fetch-document.js

@@ -1,7 +1,7 @@
 import { createClient } from '@sanity/client';
-import ora from 'ora';
-export async function fetchDocument(documentId, { projectId, dataset, useCdn = true, apiVersion = '2025-02-06', apiHost, token }) {
-    const spinner = ora(`Fetching document ID ${documentId}...`).start();
+import { createTracedFetch } from '../traced-fetch.js';
+export async function fetchDocument(documentId, { projectId, dataset, useCdn = true, apiVersion = '2025-02-06', apiHost, token }, logger) {
+    const spinner = logger.ora(`Fetching document ID ${documentId}...`).start();
     const client = createClient({ projectId, dataset, useCdn, apiVersion, apiHost, token });
     const data = await client.fetch(`*[_id == "${documentId}"]`);
     spinner.stop();
@@ -10,10 +10,11 @@ export async function fetchDocument(documentId, { projectId, dataset, useCdn = t
     }
     return data[0];
 }
-export async function fetchAsset(documentId, { mediaLibraryId, apiVersion = '2025-03-24', apiHost, token }) {
-    const spinner = ora(`Fetching document ID ${documentId}...`).start();
+export async function fetchAsset(documentId, { mediaLibraryId, apiVersion = '2025-03-24', apiHost, token }, logger) {
+    const spinner = logger.ora(`Fetching document ID ${documentId}...`).start();
+    const fetchFn = createTracedFetch(logger);
     const url = `${apiHost}/v${apiVersion}/media-libraries/${mediaLibraryId}/doc/${documentId}`;
-    const response = await fetch(url, {
+    const response = await fetchFn(url, {
         headers: {
             Authorization: `Bearer ${token}`,
         },

package/dist/utils/index.d.ts

@@ -1,6 +1,8 @@
 export * as display from './display/index.js';
 export * as findFunction from './find-function.js';
 export * as invokeLocal from './invoke-local.js';
+export * as logger from './logger.js';
+export * as tracedFetch from './traced-fetch.js';
 export * as types from './types.js';
 export * as validate from './validate/index.js';
 export * as validatedToken from './validated-token.js';

package/dist/utils/index.js

@@ -1,6 +1,8 @@
 export * as display from './display/index.js';
 export * as findFunction from './find-function.js';
 export * as invokeLocal from './invoke-local.js';
+export * as logger from './logger.js';
+export * as tracedFetch from './traced-fetch.js';
 export * as types from './types.js';
 export * as validate from './validate/index.js';
 export * as validatedToken from './validated-token.js';

package/dist/utils/logger.d.ts

@@ -0,0 +1,13 @@
+import ora from 'ora';
+export declare function Logger(log: (msg: string) => void, flags?: {
+    verbose?: boolean;
+    trace?: boolean;
+}): {
+    (msg: string): void;
+    trace(formatter: unknown, ...args: unknown[]): false | void;
+    verbose(formatter: unknown, ...args: unknown[]): false | void;
+    info(formatter: unknown, ...args: unknown[]): false | void;
+    warn(formatter: unknown, ...args: unknown[]): false | void;
+    error(formatter: unknown, ...args: unknown[]): false | void;
+    ora: typeof ora;
+};

package/dist/utils/logger.js

@@ -0,0 +1,61 @@
+import { format } from 'node:util';
+import ora from 'ora';
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
+    LogLevel[LogLevel["VERBOSE"] = 1] = "VERBOSE";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+export function Logger(log, flags = {}) {
+    const logger = (msg) => {
+        log(msg);
+    };
+    const level = flags.verbose ? LogLevel.VERBOSE : flags.trace ? LogLevel.TRACE : LogLevel.INFO;
+    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));
+    logger.warn = (formatter, ...args) => level <= LogLevel.WARN && logger(format(formatter, ...args));
+    logger.error = (formatter, ...args) => level <= LogLevel.ERROR && logger(format(formatter, ...args));
+    const oraWrapper = (opts) => {
+        if (level >= LogLevel.INFO)
+            return ora(opts);
+        return createOraLineLoggingWrapper(opts, logger);
+    };
+    logger.ora = oraWrapper;
+    return logger;
+}
+/**
+ * An ora-like wrapper that uses standard line output logging instead of rendering a spinner; used in verbose and trace modes.
+ */
+function createOraLineLoggingWrapper(opts, logger) {
+    const text = typeof opts === 'string' ? opts : (typeof opts === 'object' ? opts.text : '') || '';
+    const wrapper = {
+        clear() {
+            logger('');
+            return wrapper;
+        },
+        fail(subtext) {
+            logger.error(subtext);
+            return wrapper;
+        },
+        info(subtext) {
+            logger(subtext || wrapper.text);
+            return wrapper;
+        },
+        start(subtext) {
+            logger(subtext || wrapper.text);
+            return wrapper;
+        },
+        stop() {
+            return wrapper;
+        },
+        succeed(subtext) {
+            logger(subtext || wrapper.text);
+            return wrapper;
+        },
+        text,
+    };
+    return wrapper;
+}

package/dist/utils/other/github.d.ts

@@ -1,2 +1,3 @@
+import type { Logger } from '../logger.js';
 export declare const GITHUB_API_URL = "https://api.github.com";
-export declare function gitHubRequest(path: string): Promise<Response>;
+export declare function gitHubRequest(path: string, logger: ReturnType<typeof Logger>): Promise<Response>;

package/dist/utils/other/github.js

@@ -1,8 +1,10 @@
 // ! Making requests to the GitHub API will be rate limited at 60 requests per hour per IP address
 // https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#primary-rate-limit-for-unauthenticated-users
+import { createTracedFetch } from '../traced-fetch.js';
 export const GITHUB_API_URL = 'https://api.github.com';
-export async function gitHubRequest(path) {
-    const response = await fetch(`${GITHUB_API_URL}${path}`, {
+export async function gitHubRequest(path, logger) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${GITHUB_API_URL}${path}`, {
         headers: { Accept: 'application/vnd.github.v3+json' },
     });
     if (response.ok) {

package/dist/utils/other/npmjs.d.ts

@@ -1 +1,2 @@
-export declare function getLatestNpmVersion(pkg: string): Promise<string>;
+import type { Logger } from '../logger.js';
+export declare function getLatestNpmVersion(pkg: string, logger: ReturnType<typeof Logger>): Promise<string>;

package/dist/utils/other/npmjs.js

@@ -1,7 +1,9 @@
-export async function getLatestNpmVersion(pkg) {
+import { createTracedFetch } from '../traced-fetch.js';
+export async function getLatestNpmVersion(pkg, logger) {
+    const fetchFn = createTracedFetch(logger);
     const url = `https://registry.npmjs.org/${pkg}/latest`;
     try {
-        const res = await fetch(url);
+        const res = await fetchFn(url);
         if (!res.ok)
             throw new Error(`Failed to fetch version for ${pkg}`);
         const data = await res.json();

package/dist/utils/traced-fetch.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from './logger.js';
+/**
+ * Configuration options for traced fetch
+ */
+export interface TracedFetchOptions {
+    /** Whether to log request headers. Default: true */
+    logRequestHeaders?: boolean;
+    /** Whether to log response headers. Default: true */
+    logResponseHeaders?: boolean;
+    /** Whether to log request body. Default: true */
+    logRequestBody?: boolean;
+    /** Whether to log response body. Default: true */
+    logResponseBody?: boolean;
+    /** Maximum length for body preview. Default: 500 */
+    maxBodyLength?: number;
+    /** Headers to redact (case-insensitive). Default: ['authorization', 'cookie', 'set-cookie', 'x-api-key', 'x-auth-token', 'proxy-authorization'] */
+    redactedHeaders?: string[];
+}
+/**
+ * Creates a traced fetch function with HTTP request/response introspection.
+ * Logs HTTP details to the provided logger when set to TRACE log level.
+ * Includes request timing, headers, and optional body previews.
+ * Headers containing sensitive data are redacted by default.
+ * @param logger - Logger instance from Logger() factory
+ * @param options - Configuration options for logging behavior
+ * @returns A fetch-compatible function with tracing capabilities
+ *
+ * @example
+ * ```typescript
+ * const logger = Logger(console.log, {trace: true})
+ * const tracedFetch = createTracedFetch(logger)
+ * const response = await tracedFetch('https://api.example.com/data')
+ * ```
+ */
+export declare function createTracedFetch(logger: ReturnType<typeof Logger>, options?: TracedFetchOptions): typeof fetch;

package/dist/utils/traced-fetch.js

@@ -0,0 +1,238 @@
+import { randomUUID } from 'node:crypto';
+import { performance } from 'node:perf_hooks';
+import { env } from 'node:process';
+import chalk from 'chalk';
+let defaultMaxLength = env.SANITY_TRACE_MAX_LENGTH
+    ? Number.parseInt(env.SANITY_TRACE_MAX_LENGTH, 10)
+    : 500;
+if (Number.isNaN(defaultMaxLength))
+    defaultMaxLength = 500;
+const DEFAULT_OPTIONS = {
+    logRequestHeaders: true,
+    logResponseHeaders: true,
+    logRequestBody: true,
+    logResponseBody: true,
+    maxBodyLength: defaultMaxLength,
+    redactedHeaders: [
+        'authorization',
+        'cookie',
+        'set-cookie',
+        'x-api-key',
+        'x-auth-token',
+        'proxy-authorization',
+    ],
+};
+/**
+ * Content types that are safe to log as text
+ */
+const SAFE_CONTENT_TYPES = [
+    'application/json',
+    'application/xml',
+    'application/x-www-form-urlencoded',
+    'text/',
+];
+/**
+ * Check if content type is safe to log
+ */
+function isSafeContentType(contentType) {
+    const lower = contentType.toLowerCase();
+    return SAFE_CONTENT_TYPES.some((safe) => lower.startsWith(safe));
+}
+/**
+ * Redact sensitive headers
+ */
+function redactHeaders(headers, redactedKeys) {
+    if (!headers)
+        return {};
+    const result = {};
+    const redactedLower = redactedKeys.map((k) => k.toLowerCase());
+    // Handle Headers object
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => {
+            result[key] = redactedLower.includes(key.toLowerCase()) ? '[REDACTED]' : value;
+        });
+    }
+    // Handle array of tuples
+    else if (Array.isArray(headers)) {
+        for (const [key, value] of headers) {
+            result[key] = redactedLower.includes(key.toLowerCase()) ? '[REDACTED]' : value;
+        }
+    }
+    // Handle plain object
+    else {
+        for (const [key, value] of Object.entries(headers)) {
+            result[key] = redactedLower.includes(key.toLowerCase()) ? '[REDACTED]' : value;
+        }
+    }
+    return result;
+}
+/**
+ * Create a preview of body content
+ */
+function createBodyPreview(body, maxLength, contentType) {
+    if (body === null) {
+        return '[empty]';
+    }
+    // Handle string bodies
+    if (typeof body === 'string') {
+        if (!contentType || isSafeContentType(contentType)) {
+            if (body.length <= maxLength) {
+                return body;
+            }
+            return `${body.slice(0, maxLength)}... [truncated]`;
+        }
+        return `[non-text content, ${body.length} chars]`;
+    }
+    // Handle Buffer
+    if (Buffer.isBuffer(body)) {
+        if (contentType && isSafeContentType(contentType)) {
+            const text = body.toString('utf8');
+            if (text.length <= maxLength) {
+                return text;
+            }
+            return `${text.slice(0, maxLength)}... [truncated]`;
+        }
+        return `[${contentType} binary, ${body.length} bytes]`;
+    }
+    return '[unknown content type]';
+}
+/**
+ * Extract body from RequestInit if present
+ */
+async function extractRequestBody(init) {
+    if (!init?.body) {
+        return { body: null, contentType: null };
+    }
+    const contentType = init.headers ? new Headers(init.headers).get('content-type') : null;
+    // init.body in node can be string, buffer, blob, formdata, url search params or a readable stream, so handle each case.
+    if (typeof init.body === 'string') {
+        return { body: init.body, contentType };
+    }
+    if (init.body instanceof FormData) {
+        return { body: '[FormData]', contentType };
+    }
+    if (init.body instanceof URLSearchParams) {
+        return { body: init.body.toString(), contentType };
+    }
+    if (init.body instanceof Blob) {
+        return { body: '[FormData]', contentType: contentType || init.body.type };
+    }
+    if (init.body instanceof ReadableStream) {
+        return { body: '[ReadableStream]', contentType };
+    }
+    if (Buffer.isBuffer(init.body)) {
+        return { body: init.body, contentType };
+    }
+    return { body: '[unknown body type]', contentType };
+}
+/**
+ * Extract body from Response
+ */
+async function extractResponseBody(response, maxLength) {
+    const contentType = response.headers.get('content-type');
+    // Don't try to read body for streaming responses (event-stream)
+    if (contentType?.includes('text/event-stream')) {
+        return '[streaming response]';
+    }
+    // Clone response to avoid consuming it
+    const cloned = response.clone();
+    try {
+        // Try to read as text
+        const text = await cloned.text();
+        if (!contentType || isSafeContentType(contentType)) {
+            if (text.length <= maxLength) {
+                return text;
+            }
+            return `${text.slice(0, maxLength)}... [truncated]`;
+        }
+        return `[binary content, ${text.length} bytes]`;
+    }
+    catch (error) {
+        return `[unable to read body: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+}
+/**
+ * Creates a traced fetch function with HTTP request/response introspection.
+ * Logs HTTP details to the provided logger when set to TRACE log level.
+ * Includes request timing, headers, and optional body previews.
+ * Headers containing sensitive data are redacted by default.
+ * @param logger - Logger instance from Logger() factory
+ * @param options - Configuration options for logging behavior
+ * @returns A fetch-compatible function with tracing capabilities
+ *
+ * @example
+ * ```typescript
+ * const logger = Logger(console.log, {trace: true})
+ * const tracedFetch = createTracedFetch(logger)
+ * const response = await tracedFetch('https://api.example.com/data')
+ * ```
+ */
+export function createTracedFetch(logger, options) {
+    const opts = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+    return async (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';
+        const startTime = performance.now();
+        function trace(type, msgTemplate, ...args) {
+            const arrow = type === 'req' ? '→' : type === 'res' ? '←' : chalk.red('✗');
+            logger.trace(`${chalk.dim('[%s]')} HTTP ${arrow} ${msgTemplate}`, requestId, ...args);
+        }
+        // Log request URL
+        trace('req', '%s %s', method, url);
+        // Log request headers
+        if (opts.logRequestHeaders && init?.headers) {
+            const redacted = redactHeaders(init.headers, opts.redactedHeaders);
+            trace('req', 'Headers: %j', redacted);
+        }
+        // Log request body
+        if (opts.logRequestBody && init?.body) {
+            try {
+                const { body, contentType } = await extractRequestBody(init);
+                const preview = createBodyPreview(body, opts.maxBodyLength, contentType);
+                trace('req', 'Body: %s', preview);
+            }
+            catch (error) {
+                trace('err', 'Body: [error reading body: %s]', error instanceof Error ? error.message : String(error));
+            }
+        }
+        try {
+            // Make the actual fetch call
+            const response = await fetch(input, init);
+            const endTime = performance.now();
+            const duration = Math.round(endTime - startTime);
+            // Log response
+            trace('res', '%d %s (%dms)', response.status, response.statusText, duration);
+            // Log response headers
+            if (opts.logResponseHeaders) {
+                const headers = {};
+                response.headers.forEach((value, key) => {
+                    headers[key] = value;
+                });
+                trace('res', 'Headers: %j', headers);
+            }
+            // Log response body
+            if (opts.logResponseBody) {
+                try {
+                    const bodyPreview = await extractResponseBody(response, opts.maxBodyLength);
+                    trace('res', 'Body: %s', bodyPreview);
+                }
+                catch (error) {
+                    trace('err', 'Body: [error reading body: %s]', error instanceof Error ? error.message : String(error));
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            const endTime = performance.now();
+            const duration = Math.round(endTime - startTime);
+            // Log error
+            trace('err', '%s %s (%dms) - %s', method, url, duration, error instanceof Error ? error.message : String(error));
+            // Re-throw the error
+            throw error;
+        }
+    };
+}

package/dist/utils/validated-token.d.ts

@@ -1,6 +1,7 @@
+import type { Logger } from './logger.js';
 import type { Result } from './types.js';
-export declare function validToken(maybeToken?: string): Promise<string>;
-export declare function validTokenOrErrorMessage(maybeToken?: string): Promise<Result<string, {
+export declare function validToken(logger: ReturnType<typeof Logger>, maybeToken?: string): Promise<string>;
+export declare function validTokenOrErrorMessage(logger: ReturnType<typeof Logger>, maybeToken?: string): Promise<Result<string, {
     e: Error | unknown;
     message: string;
 }>>;

package/dist/utils/validated-token.js

@@ -1,12 +1,14 @@
 import config from '../config.js';
-export async function validToken(maybeToken) {
+import { createTracedFetch } from './traced-fetch.js';
+export async function validToken(logger, maybeToken) {
     if (config.isTest)
         return maybeToken ?? 'token';
+    const fetchFn = createTracedFetch(logger);
     const token = maybeToken ?? config.token;
     if (!token)
         throw new Error('NO_TOKEN');
     const url = `${config.apiUrl}v2025-04-23/users/me`;
-    const response = await fetch(url, {
+    const response = await fetchFn(url, {
         method: 'GET',
         headers: {
             Accept: 'application/json',
@@ -21,9 +23,9 @@ export async function validToken(maybeToken) {
     }
     throw new Error('SERVER_ERROR', { cause: response.statusText });
 }
-export async function validTokenOrErrorMessage(maybeToken) {
+export async function validTokenOrErrorMessage(logger, maybeToken) {
     try {
-        const token = await validToken(maybeToken);
+        const token = await validToken(logger, maybeToken);
         return { ok: true, value: token };
     }
     catch (e) {