@sanity/runtime-cli 17.12.0 → 17.12.1

package/dist/actions/blueprints/pre-deploy.js

@@ -1,15 +1,51 @@
+import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
+import { prepareAsset as prepareFunctionAsset } from '../../utils/functions/prepare-asset.js';
 import { runCommand } from '../../utils/package-manager.js';
-import { styleText } from '../../utils/style-text.js';
-import { isAssetResource, } from '../../utils/types.js';
+import { prepareStudioAsset } from '../../utils/studios/prepare-asset.js';
+import { setupLogPolling } from './logs-polling.js';
+import { getOperationStateInfo } from './operations-state.js';
 import { processAssets } from './process-assets.js';
 import { updateStack } from './stacks.js';
-import { waitForOperation } from './wait-for-operation.js';
+/**
+ * A list of configurations for pre-deployment of resources. The first resourceType to match in the list will take precedence.
+ */
+const preDeployConfigs = [
+    {
+        resourceType: 'sanity.studio',
+        async prepareAsset(options) {
+            return prepareStudioAsset({
+                resource: options.resource,
+                blueprintFileDir: options.blueprintFileDir,
+            });
+        },
+    },
+    {
+        resourceType: (type) => type.startsWith(SANITY_FUNCTION_PREFIX),
+        async prepareAsset(options) {
+            return prepareFunctionAsset({
+                resource: options.resource,
+                blueprintFileDir: options.blueprintFileDir,
+                installer: options.installer,
+            });
+        },
+    },
+];
+function hasPreDeployResources(resources) {
+    return resources.some((r) => {
+        return !!getPredeployConfig(r);
+    });
+}
+function getPredeployConfig(r) {
+    return preDeployConfigs.find((c) => {
+        return ((typeof c.resourceType === 'function' && c.resourceType(r.type)) ||
+            (typeof c.resourceType !== 'function' && c.resourceType === r.type));
+    });
+}
 export async function preDeploy(options) {
-    const { resources, stackId, auth, blueprintFileDir, installer, logger } = options;
-    const hasAssetResources = resources.some(isAssetResource);
-    if (hasAssetResources) {
+    const { resources, stackId, auth, blueprintFileDir, installer, fetchFn } = options;
+    if (hasPreDeployResources(resources)) {
         const preDeployStackResult = await preDeployStack(options);
         if (!preDeployStackResult.success) {
             return preDeployStackResult;
@@ -19,17 +55,23 @@ export async function preDeploy(options) {
             resources,
             stackId,
             auth,
-            logger,
+            fetchFn,
         });
-        const assetResources = resolvedResources.filter(isAssetResource);
-        let processedAssets;
+        const assetResources = [];
+        for (const r of resolvedResources) {
+            const config = getPredeployConfig(r);
+            if (typeof config !== 'undefined' && typeof config.prepareAsset === 'function') {
+                assetResources.push({ resource: r, prepareAsset: config.prepareAsset });
+            }
+        }
+        let processedAssets = [];
         try {
             processedAssets = await processAssets({
                 assetResources,
                 auth,
                 blueprintFileDir,
                 installer,
-                logger,
+                fetchFn,
                 onProgress: (progress) => options.onAssetEvent?.({ type: 'progress', progress }),
                 onResult: (result) => options.onAssetEvent?.({ type: 'result', result }),
             });
@@ -52,8 +94,8 @@ export async function preDeploy(options) {
     return { success: true };
 }
 async function preDeployStack(options) {
-    const { scopeType, scopeId, stackId, stackName, resources, auth, logger, bin, verbose } = options;
-    const spinner = logger.ora('Starting pre-deploy...').start();
+    const { scopeType, scopeId, stackId, stackName, resources, auth, bin, fetchFn, waitForFn } = options;
+    options.onPreDeployStackStart?.();
     const stackMutation = {
         scopeType,
         scopeId,
@@ -61,9 +103,9 @@ async function preDeployStack(options) {
         preDeploy: true,
         document: { resources },
     };
-    const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackMutation, auth, logger });
+    const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId, stackMutation, auth, fetchFn });
     if (!deployOk) {
-        spinner.fail(`${styleText('red', 'Failed')} to complete Stack pre-deployment`);
+        options.onPreDeployStackFail?.();
         return {
             success: false,
             error: deployError || 'Failed to complete Stack pre-deployment',
@@ -73,22 +115,37 @@ async function preDeployStack(options) {
             ],
         };
     }
-    spinner.stop().clear();
+    options.onPreDeployStackDone?.();
     if (stack.changeCount === 0)
         return { success: true };
-    logger(styleText('dim', 'Stack deployment progress:'));
-    logger('');
-    const outcome = await waitForOperation({
-        stackId,
-        operationId: stack.operationId,
-        auth,
-        log: logger,
-        bin,
-        verbose,
-        progressNoun: 'pre-deployment',
+    options.onPreDeployOperationStart?.();
+    const outcome = await waitForFn({
+        getIdleMessage() {
+            return `The pre-deployment is still running on Sanity servers.`;
+        },
+        async onRequestLatestState() {
+            return await getOperationStateInfo({
+                stackId,
+                operationId: stack.operationId,
+                auth,
+                fetchFn,
+                includeDestroyed: false,
+                progressNoun: 'pre-deployment',
+            });
+        },
+        onStartLogPolling(options) {
+            return setupLogPolling({
+                auth,
+                fetchFn,
+                operationId: stack.operationId,
+                stackId,
+                onActivity: options.onActivity,
+                onLogEntry: options.onLogEntry,
+            });
+        },
     });
     if (outcome.type === 'completed') {
-        logger(styleText(['bold', 'green'], 'Stack pre-deployment completed!'));
+        options.onPreDeployOperationDone?.();
     }
     else if (outcome.type === 'unconfirmed') {
         return {

package/dist/actions/blueprints/process-assets.d.ts

@@ -1,29 +1,30 @@
-import type { Logger } from '../../utils/logger.js';
+import type { BlueprintResource } from '@sanity/blueprints';
 import type { AssetResource, AuthParams, InstallerType } from '../../utils/types.js';
-type ProcessAssetsOptions = {
-    assetResources: AssetResource[];
+type ProcessAssetsOptions<R extends BlueprintResource> = {
+    assetResources: AssetResource<R>[];
     auth: AuthParams;
     blueprintFileDir: string;
     installer: InstallerType;
-    logger: Logger;
+    fetchFn: typeof fetch;
     onProgress?: (progress: ProcessAssetsProgress) => void;
-    onResult?: (result: ProcessedAsset) => void;
+    onResult?: (result: ProcessedAsset<R>) => void;
 };
 export type ProcessAssetsProgress = {
     completed: number;
     total: number;
     slow: boolean;
 };
-export type ProcessedAsset = {
+export type ProcessedAsset<R extends BlueprintResource> = {
     success: false;
-    resource: AssetResource;
+    resource: R;
     error: string;
     failureKind: 'processing' | 'upload';
 } | {
     success: true;
-    resource: AssetResource;
-    hash?: string;
-    exists?: boolean;
+    resource: R;
+    assetParameter: string;
+    hash: string;
+    exists: boolean;
 };
-export declare function processAssets(options: ProcessAssetsOptions): Promise<ProcessedAsset[]>;
+export declare function processAssets<R extends BlueprintResource>(options: ProcessAssetsOptions<R>): Promise<ProcessedAsset<R>[]>;
 export {};

package/dist/actions/blueprints/process-assets.js

@@ -21,8 +21,8 @@ export async function processAssets(options) {
     try {
         for (let start = 0; start < total; start += concurrency) {
             const batch = assetResources.slice(start, start + concurrency);
-            const batchResults = await Promise.all(batch.map(async (resource) => {
-                const result = await processAsset(resource, options);
+            const batchResults = await Promise.all(batch.map(async (assetResource) => {
+                const result = await processAsset(assetResource.resource, assetResource.prepareAsset, options);
                 completed += 1;
                 reportProgress();
                 onResult?.(result);
@@ -42,13 +42,13 @@ function getAssetConcurrency() {
     const configured = Number(env.SANITY_ASSET_CONCURRENCY);
     return Number.isSafeInteger(configured) && configured > 0 ? configured : DEFAULT_ASSET_CONCURRENCY;
 }
-async function processAsset(resource, options) {
-    const { auth, blueprintFileDir, installer, logger } = options;
+async function processAsset(resource, prepAsset, options) {
+    const { auth, blueprintFileDir, installer, fetchFn } = options;
     let assetTimeoutTimer;
     let result;
     try {
         result = await Promise.race([
-            stashAsset({ resource, blueprintFileDir, auth, logger, installer }),
+            stashAsset({ resource, prepAsset, blueprintFileDir, auth, fetchFn, installer }),
             new Promise((_, reject) => {
                 assetTimeoutTimer = setTimeout(() => {
                     reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
@@ -66,7 +66,8 @@ async function processAsset(resource, options) {
     if (result.success && result.assetId) {
         return {
             success: true,
-            resource: { ...resource, src: result.assetId },
+            resource: { ...resource, [result.assetParameter]: result.assetId },
+            assetParameter: result.assetParameter,
             hash: result.hash,
             exists: result.exists,
         };
@@ -74,7 +75,7 @@ async function processAsset(resource, options) {
     return {
         success: false,
         resource,
-        error: result.error || 'Failed to process asset',
+        error: ('error' in result && result.error) || 'Failed to process asset',
         failureKind: 'upload',
     };
 }

package/dist/actions/blueprints/stacks.d.ts

@@ -25,10 +25,10 @@ type GetStackResponse = {
     stack?: unknown;
     response?: Response;
 };
-export declare function getStack({ stackId, auth, logger, }: {
+export declare function getStack({ stackId, auth, fetchFn, }: {
     stackId: string;
     auth: AuthParams;
-    logger: Logger;
+    fetchFn: typeof fetch;
 }): Promise<GetStackResponse>;
 type CreateStackResponse = GetStackResponse;
 export declare function createStack({ stackMutation, auth, logger, }: {
@@ -55,11 +55,11 @@ type UpdateStackResponse = {
     error: string;
     stack?: unknown;
 };
-export declare function updateStack({ stackId, stackMutation, auth, logger, }: {
+export declare function updateStack({ stackId, stackMutation, auth, fetchFn, }: {
     stackId: string;
     stackMutation: StackMutation;
     auth: AuthParams;
-    logger: Logger;
+    fetchFn: typeof fetch;
 }): Promise<UpdateStackResponse>;
 interface PlanResourceSnapshot {
     name: string;

package/dist/actions/blueprints/stacks.js

@@ -24,8 +24,7 @@ export async function listStacks(auth, logger) {
         };
     }
 }
-export async function getStack({ stackId, auth, logger, }) {
-    const fetchFn = createTracedFetch(logger);
+export async function getStack({ stackId, auth, fetchFn, }) {
     try {
         const response = await fetchFn(`${stacksUrl}/${stackId}`, {
             method: 'GET',
@@ -92,8 +91,7 @@ export async function createEmptyStack({ token, scopeType, scopeId, name, logger
     }
     return response.stack;
 }
-export async function updateStack({ stackId, stackMutation, auth, logger, }) {
-    const fetchFn = createTracedFetch(logger);
+export async function updateStack({ stackId, stackMutation, auth, fetchFn, }) {
     try {
         const response = await fetchFn(`${stacksUrl}/${stackId}`, {
             method: 'PUT',

package/dist/actions/blueprints/wait-for-operation.d.ts

@@ -1,15 +1,6 @@
+import { type OperationOutcome } from '../../utils/blueprints/wait-for.js';
 import type { Logger } from '../../utils/logger.js';
 import type { AuthParams } from '../../utils/types.js';
-/** Result of waiting for a deploy/destroy operation to settle. */
-export type OperationOutcome = {
-    type: 'completed';
-} | {
-    type: 'failed';
-    logHints: string[];
-} | {
-    type: 'unconfirmed';
-    error?: string;
-};
 export interface WaitForOperationOptions {
     stackId: string;
     operationId: string;

package/dist/actions/blueprints/wait-for-operation.js

@@ -1,10 +1,7 @@
-import { setTimeout as sleep } from 'node:timers/promises';
-import { createHintCollector } from '../../utils/blueprints/hints.js';
-import { runCommand } from '../../utils/package-manager.js';
+import { createWaitFor } from '../../utils/blueprints/wait-for.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { setupLogPolling } from './logs-polling.js';
-import { classifyOperationPoll, getOperation, OPERATION_POLL_INITIAL_DELAY_MS, OPERATION_POLL_INTERVAL_MS, OPERATION_POLL_MAX_CONSECUTIVE_ERRORS, } from './operations.js';
-const IDLE_SPINNER_DELAY_MS = 30_000;
-const IDLE_SPINNER_UPDATE_INTERVAL_MS = 15_000;
+import { classifyOperationPoll, getOperation } from './operations.js';
 /**
  * Stream logs and poll an operation until it settles.
  * handles log-stream lifecycle, retry budget, and idle messaging;
@@ -12,107 +9,65 @@ const IDLE_SPINNER_UPDATE_INTERVAL_MS = 15_000;
  */
 export async function waitForOperation(options) {
     const { stackId, operationId, auth, log, bin, verbose = false, includeDestroyed, progressNoun, } = options;
-    const logHints = createHintCollector(bin);
-    let logStreamCleanup = null;
-    let idleSpinner;
-    const stopIdleSpinner = (restoreOperationProgress = false) => {
-        if (!idleSpinner)
-            return;
-        idleSpinner.stop();
-        idleSpinner = undefined;
-        if (restoreOperationProgress)
-            log.showProgress();
-    };
-    try {
-        log.showProgress();
-        let lastLogAt = Date.now();
-        let nextIdleSpinnerUpdateAt = IDLE_SPINNER_DELAY_MS;
-        let consecutiveErrors = 0;
-        let lastStatus;
-        logStreamCleanup = setupLogPolling({
-            stackId,
-            operationId,
-            auth,
-            log,
-            verbose,
-            onActivity: () => {
-                lastLogAt = Date.now();
-                nextIdleSpinnerUpdateAt = IDLE_SPINNER_DELAY_MS;
-                stopIdleSpinner(true);
-            },
-            onLogEntry: (logEntry) => logHints.inspectLog(logEntry),
-        });
-        // balk in case read replica lags
-        await sleep(OPERATION_POLL_INITIAL_DELAY_MS);
-        while (true) {
-            const { ok, error: pollError, operation, response, } = await getOperation({
+    const fetchFn = createTracedFetch(log);
+    const waitFor = createWaitFor({
+        bin,
+        log,
+        verbose,
+    });
+    return await waitFor({
+        async onRequestLatestState() {
+            const { ok, error, operation, response } = await getOperation({
                 stackId,
                 operationId,
                 auth,
-                logger: log,
+                fetchFn,
                 includeDestroyed,
             });
             const httpStatus = response?.status;
             const state = classifyOperationPoll({ ok, httpStatus, operation });
-            if (state === 'completed') {
-                if (logStreamCleanup)
-                    logStreamCleanup();
-                stopIdleSpinner();
-                log('');
-                return { type: 'completed' };
+            switch (state) {
+                case 'completed':
+                case 'failed':
+                    return {
+                        state,
+                    };
+                case 'error':
+                    return {
+                        state,
+                        error,
+                        verboseError: `Could not read ${progressNoun} status (HTTP ${httpStatus ?? 'unknown'}${error ? `: ${error}` : ''})`,
+                    };
+                case 'pending':
+                    if (httpStatus === 404 || !operation) {
+                        return {
+                            state: 'not_found',
+                            verboseError: `Waiting for ${progressNoun} status (HTTP 404); retrying.`,
+                        };
+                    }
+                    else {
+                        return {
+                            state,
+                            latestStatus: operation.status,
+                            verboseMessage: `${progressNoun} operation status: ${operation.status}.`,
+                        };
+                    }
+                default:
+                    throw new Error(`Unexpected poll state: ${state}`);
             }
-            if (state === 'failed') {
-                if (logStreamCleanup)
-                    logStreamCleanup();
-                stopIdleSpinner();
-                log('');
-                return { type: 'failed', logHints: logHints.getSuggestions() };
-            }
-            // tolerate a few consecutive errors; the operation was accepted and may still be running
-            if (state === 'error') {
-                consecutiveErrors += 1;
-                log.verbose(`Could not read ${progressNoun} status (HTTP ${httpStatus ?? 'unknown'}${pollError ? `: ${pollError}` : ''}); retrying (${consecutiveErrors}/${OPERATION_POLL_MAX_CONSECUTIVE_ERRORS}).`);
-                if (consecutiveErrors >= OPERATION_POLL_MAX_CONSECUTIVE_ERRORS) {
-                    if (logStreamCleanup)
-                        logStreamCleanup();
-                    stopIdleSpinner();
-                    log('');
-                    return { type: 'unconfirmed', error: pollError ?? undefined };
-                }
-            }
-            else {
-                consecutiveErrors = 0;
-                if (httpStatus === 404) {
-                    log.verbose(`Waiting for ${progressNoun} status (HTTP 404); retrying.`);
-                }
-                else if (operation && operation.status !== lastStatus) {
-                    log.verbose(`${progressNoun} operation status: ${operation.status}.`);
-                    lastStatus = operation.status;
-                }
-            }
-            const idleFor = Date.now() - lastLogAt;
-            if (idleFor >= nextIdleSpinnerUpdateAt) {
-                const elapsedIdleMs = IDLE_SPINNER_DELAY_MS +
-                    Math.floor((idleFor - IDLE_SPINNER_DELAY_MS) / IDLE_SPINNER_UPDATE_INTERVAL_MS) *
-                        IDLE_SPINNER_UPDATE_INTERVAL_MS;
-                const elapsedIdleSeconds = elapsedIdleMs / 1000;
-                const text = `No new activity for ${elapsedIdleSeconds} seconds. The ${progressNoun} is still running on Sanity servers. You can safely exit and check status later with \`${runCommand(bin)} blueprints info\`.`;
-                if (idleSpinner)
-                    idleSpinner.start(text);
-                else
-                    idleSpinner = log.ora(text).start();
-                nextIdleSpinnerUpdateAt = elapsedIdleMs + IDLE_SPINNER_UPDATE_INTERVAL_MS;
-            }
-            await sleep(OPERATION_POLL_INTERVAL_MS);
-        }
-    }
-    catch (error) {
-        if (logStreamCleanup)
-            logStreamCleanup();
-        throw error;
-    }
-    finally {
-        stopIdleSpinner();
-        log.clearProgress();
-    }
+        },
+        onStartLogPolling(options) {
+            return setupLogPolling({
+                stackId,
+                operationId,
+                auth,
+                fetchFn,
+                onActivity: options.onActivity,
+                onLogEntry: options.onLogEntry,
+            });
+        },
+        getIdleMessage() {
+            return `The ${progressNoun} is still running on Sanity servers.`;
+        },
+    });
 }

package/dist/baseCommands.js

@@ -9,6 +9,7 @@ import { CI_SETUP_DOCS_URL } from './constants.js';
 import { presentBlueprintParserErrors } from './utils/display/errors.js';
 import { Logger } from './utils/logger.js';
 import { styleText } from './utils/style-text.js';
+import { createTracedFetch } from './utils/traced-fetch.js';
 import { validTokenOrErrorMessage } from './utils/validated-token.js';
 /**
  * Fallback error-to-hint patterns for RuntimeCommand.catch().
@@ -378,7 +379,11 @@ export class ResolvedCommand extends RuntimeCommand {
         // 8. Deployed Stack
         if (needsDeployedStack) {
             const spinner = log.ora('Loading Stack deployment...').start();
-            const response = await getStack({ stackId: this.stackId, auth: this.auth, logger: log });
+            const response = await getStack({
+                stackId: this.stackId,
+                auth: this.auth,
+                fetchFn: createTracedFetch(log),
+            });
             if (!response.ok) {
                 spinner.fail('Could not load Stack deployment');
                 this.error('Missing Stack deployment', {

package/dist/cores/blueprints/deploy.js

@@ -5,10 +5,12 @@ import { waitForOperation } from '../../actions/blueprints/wait-for-operation.js
 import { checkUserPermission } from '../../actions/sanity/access.js';
 import { extractDurableConfig } from '../../utils/blueprints/extract-durable-config.js';
 import { createHintCollector } from '../../utils/blueprints/hints.js';
+import { createWaitFor } from '../../utils/blueprints/wait-for.js';
 import { check, niceId, severe } from '../../utils/display/presenters.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
 import { runCommand } from '../../utils/package-manager.js';
 import { styleText } from '../../utils/style-text.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { getWarnings } from '../../utils/warnings.js';
 export async function blueprintDeployCore(options) {
     const { bin = 'sanity', log: logger, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
@@ -20,7 +22,8 @@ export async function blueprintDeployCore(options) {
     const workspaceWarnings = getWarnings({ dir: blueprintFileDir });
     logger(`Deploying "${stackName}" ${niceId(deployedStack.id)}...`);
     try {
-        const { ok: checkOk, stack: currentStack } = await getStack({ stackId, auth, logger });
+        const fetchFn = createTracedFetch(logger);
+        const { ok: checkOk, stack: currentStack } = await getStack({ stackId, auth, fetchFn });
         if (!checkOk) {
             return { success: false, error: 'Failed to check current Stack status' };
         }
@@ -37,6 +40,7 @@ export async function blueprintDeployCore(options) {
         }
         const resources = [...blueprint.resources];
         await extractDurableConfig(resources, blueprintFileDir);
+        let spinner;
         const preDeployResult = await preDeploy({
             scopeType,
             scopeId,
@@ -46,10 +50,26 @@ export async function blueprintDeployCore(options) {
             auth,
             blueprintFileDir,
             installer,
-            logger,
             bin,
-            verbose,
+            fetchFn,
+            waitForFn: createWaitFor({ bin, log: logger, verbose }),
             onAssetEvent: createAssetEventHandler(logger),
+            onPreDeployStackStart() {
+                spinner = logger.ora('Starting pre-deploy...').start();
+            },
+            onPreDeployStackFail() {
+                spinner.fail(`${styleText('red', 'Failed')} to complete Stack pre-deployment`);
+            },
+            onPreDeployStackDone() {
+                spinner.stop().clear();
+            },
+            onPreDeployOperationStart() {
+                logger(styleText('dim', 'Stack pre-deployment progress:'));
+                logger('');
+            },
+            onPreDeployOperationDone() {
+                logger(styleText(['bold', 'green'], 'Stack pre-deployment completed!'));
+            },
         });
         if (!preDeployResult?.success)
             return preDeployResult;
@@ -64,7 +84,7 @@ export async function blueprintDeployCore(options) {
                 userMessage: flags.message,
             },
             auth,
-            logger,
+            fetchFn,
         });
         if (!deployOk) {
             deploySpinner.fail(`${styleText('red', 'Failed')} to update Stack deployment`);
@@ -192,8 +212,10 @@ function createAssetEventHandler(logger) {
                 logger.error(`   ${result.error}`);
                 continue;
             }
-            logger(` ${check(`${resource.name} ${niceId(resource.src)}`)}`);
-            logger(`   Source: ${resource.src}`);
+            const r = resource;
+            const assetParameter = String(r[result.assetParameter]);
+            logger(` ${check(`${resource.name} ${niceId(assetParameter)}`)}`);
+            logger(`   Source: ${assetParameter}`);
             if (result.hash) {
                 const hash = result.hash;
                 const h = hash.length > 24 ? `${hash.slice(0, 8)}...${hash.slice(-12)}` : hash;

package/dist/cores/blueprints/destroy.js

@@ -7,6 +7,7 @@ import { niceId } from '../../utils/display/presenters.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
 import { runCommand } from '../../utils/package-manager.js';
 import { styleText } from '../../utils/style-text.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 export async function blueprintDestroyCore(options) {
     const { bin = 'sanity', log, token, scopeType, scopeId, localStackId, blueprintConfig, flags, } = options;
     const { force = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, stack: flagStack, 'no-wait': noWait = false, verbose = false, } = flags;
@@ -48,14 +49,15 @@ export async function blueprintDestroyCore(options) {
         : undefined;
     let stack;
     try {
+        const fetchFn = createTracedFetch(log);
         if (resolvedStackId) {
-            const overrideStack = await getStack({ stackId: resolvedStackId, auth, logger: log });
+            const overrideStack = await getStack({ stackId: resolvedStackId, auth, fetchFn });
             if (!overrideStack.ok)
                 return { success: false, error: overrideStack.error || 'Failed to get Stack' };
             stack = overrideStack.stack;
         }
         else if (localStackId) {
-            const blueprintStack = await getStack({ stackId: localStackId, auth, logger: log });
+            const blueprintStack = await getStack({ stackId: localStackId, auth, fetchFn });
             if (!blueprintStack.ok)
                 return { success: false, error: blueprintStack.error || 'Failed to get Stack' };
             stack = blueprintStack.stack;

package/dist/cores/blueprints/doctor.js

@@ -172,7 +172,7 @@ export async function blueprintDoctorCore(options) {
             const stackResponse = await getStack({
                 auth: { token, scopeType, scopeId },
                 stackId,
-                logger: log,
+                fetchFn,
             });
             if (stackResponse.ok) {
                 diagnostics.stackReady = { status: true };

package/dist/cores/blueprints/init.js

@@ -15,6 +15,7 @@ import { CancelledError, promptForBlueprintType, promptForInitLocation, promptFo
 import { isInteractive } from '../../utils/interactive.js';
 import { installCommand, runCommand } from '../../utils/package-manager.js';
 import { styleText } from '../../utils/style-text.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { blueprintConfigCore } from './config.js';
 /** Derive scope type and ID from mutually exclusive flag values. */
 function resolveScopeFromFlags(projectId, organizationId) {
@@ -288,11 +289,12 @@ export async function resolveScopeAndStack(params) {
         }
         // --stack-id: validate it exists
         if (resolvedStackId && resolvedStackId === stackId) {
+            const fetchFn = createTracedFetch(log);
             const spinner = log.ora('Validating Stack...').start();
             const { ok, error } = await getStack({
                 stackId: resolvedStackId,
                 auth: { token, scopeType, scopeId },
-                logger: log,
+                fetchFn,
             });
             spinner.stop();
             if (!ok) {