@sanity/runtime-cli 12.4.0 → 13.0.0

package/dist/actions/blueprints/config.js

@@ -81,13 +81,13 @@ export function patchConfigFile(blueprintFilePath, updateableProperties) {
  * @throws {Error} if unable to fetch project
  * @returns {Promise<string>} the discovered organizationId
  */
-export async function backfillOrganizationId({ blueprintFilePath, projectId, }) {
+export async function backfillOrganizationId({ blueprintFilePath, projectId, logger, }) {
     const token = config.token;
     if (!token)
         throw new Error('No token found');
     let organizationId;
     try {
-        const response = await getProject({ token, scopeType: 'project', scopeId: projectId });
+        const response = await getProject({ token, scopeType: 'project', scopeId: projectId, logger });
         if (!response.ok)
             throw new Error('Failed to get project');
         if (!response.project)
@@ -102,7 +102,7 @@ export async function backfillOrganizationId({ blueprintFilePath, projectId, })
     patchConfigFile(blueprintFilePath, { organizationId });
     return organizationId;
 }
-export async function backfillProjectBasedStackId({ blueprintFilePath, projectId, }) {
+export async function backfillProjectBasedStackId({ blueprintFilePath, projectId, logger, }) {
     const token = config.token;
     if (!token)
         throw new Error('No token found');
@@ -112,7 +112,7 @@ export async function backfillProjectBasedStackId({ blueprintFilePath, projectId
         token,
         scopeType: 'project',
         scopeId: projectId,
-    });
+    }, logger);
     if (!ok)
         throw new Error(error || 'Failed to list stacks');
     if (stacks.length === 1 &&

package/dist/actions/blueprints/logs-streaming.d.ts

@@ -1,10 +1,11 @@
+import type { Logger } from '../../utils/logger.js';
 import type { AuthParams, BlueprintLog } from '../../utils/types.js';
 export interface LogStreamingConfig {
     stackId: string;
     after?: string;
     auth: AuthParams;
     showBanner?: boolean;
-    log: (message: string) => void;
+    log: ReturnType<typeof Logger>;
 }
 export interface StreamLogsOptions {
     stackId: string;
@@ -13,8 +14,9 @@ export interface StreamLogsOptions {
     onLog: (log: BlueprintLog) => void;
     onOpen: () => void;
     onError: (error: string) => void;
+    logger: ReturnType<typeof Logger>;
 }
-export declare function streamLogs({ stackId, after, auth, onLog, onOpen, onError, }: StreamLogsOptions): () => void;
+export declare function streamLogs({ stackId, after, auth, onLog, onOpen, onError, logger, }: StreamLogsOptions): () => void;
 /** Check if a log is newer than a given timestamp */
 export declare function isNewerLog(log: BlueprintLog, timestamp: number): boolean;
 /**

package/dist/actions/blueprints/logs-streaming.js

@@ -2,15 +2,17 @@ import chalk from 'chalk';
 import { EventSource } from 'eventsource';
 import { formatLogEntry } from '../../utils/display/logs-formatting.js';
 import getHeaders from '../../utils/get-headers.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { logsUrl } from './logs.js';
-export function streamLogs({ stackId, after, auth, onLog, onOpen, onError, }) {
+export function streamLogs({ stackId, after, auth, onLog, onOpen, onError, logger, }) {
+    const fetchFn = createTracedFetch(logger);
     const url = new URL(`${logsUrl}/stream`);
     url.searchParams.append('stackId', stackId);
     if (after)
         url.searchParams.append('after', after);
     const headers = getHeaders(auth);
     const eventSource = new EventSource(url.toString(), {
-        fetch: (input, init) => fetch(input, {
+        fetch: (input, init) => fetchFn(input, {
             ...init,
             headers: {
                 ...init?.headers,
@@ -96,5 +98,6 @@ export async function setupLogStreaming(config) {
         onLog: onLogReceived,
         onOpen: onStreamOpen,
         onError: onStreamError,
+        logger: log,
     });
 }

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

@@ -1,6 +1,7 @@
+import type { Logger } from '../../utils/logger.js';
 import type { AuthParams, BlueprintLog } from '../../utils/types.js';
 export declare const logsUrl: string;
-export declare function getLogs(stackId: string, auth: AuthParams): Promise<{
+export declare function getLogs(stackId: string, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<{
     logs: BlueprintLog[];
     ok: boolean;
     error: string | null;

package/dist/actions/blueprints/logs.js

@@ -1,11 +1,13 @@
 import config from '../../config.js';
 import getHeaders from '../../utils/get-headers.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 const { apiUrl } = config;
 export const logsUrl = `${apiUrl}vX/blueprints/logs`;
-export async function getLogs(stackId, auth) {
+export async function getLogs(stackId, auth, logger) {
+    const fetchFn = createTracedFetch(logger);
     const url = new URL(logsUrl);
     url.searchParams.append('stackId', stackId);
-    const response = await fetch(url.toString(), {
+    const response = await fetchFn(url.toString(), {
         headers: getHeaders(auth),
         method: 'GET',
     });

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

@@ -1,3 +1,4 @@
+import type { Logger } from '../../utils/logger.js';
 import type { FunctionResourceBase } from '../../utils/types.js';
 interface FunctionResourceOptions {
     name: string;
@@ -10,7 +11,7 @@ interface FunctionResourceOptions {
 /**
  * Creates a new function resource file and adds it to the blueprint
  */
-export declare function createFunctionResource(options: FunctionResourceOptions): Promise<{
+export declare function createFunctionResource(options: FunctionResourceOptions, logger: ReturnType<typeof Logger>): Promise<{
     filePath: string;
     resourceAdded: boolean;
     resource: FunctionResourceBase;

package/dist/actions/blueprints/resources.js

@@ -18,7 +18,7 @@ export const handler = documentEventHandler(async ({ context, event }) => {
 /**
  * Creates a new function resource file and adds it to the blueprint
  */
-export async function createFunctionResource(options) {
+export async function createFunctionResource(options, logger) {
     const { name, type, lang, blueprintFilePath, addHelpers = false, installCommand } = options;
     let workingDir = cwd();
     if (blueprintFilePath) {
@@ -44,7 +44,7 @@ export async function createFunctionResource(options) {
     writeFileSync(indexPath, addHelpers ? DEFAULT_HELPER_FUNCTION_TEMPLATE : DEFAULT_FUNCTION_TEMPLATE);
     if (addHelpers && blueprintFilePath) {
         try {
-            await writeOrUpdateNodeDependency(blueprintFilePath, '@sanity/functions');
+            await writeOrUpdateNodeDependency(blueprintFilePath, '@sanity/functions', logger);
         }
         catch (err) {
             throw new Error('Unable to add @sanity/functions to your project.', { cause: err });

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

@@ -1,3 +1,4 @@
+import type { Logger } from '../../utils/logger.js';
 import type { AuthParams, ScopeType, Stack, StackMutation } from '../../utils/types.js';
 export declare const stacksUrl: string;
 type ListStacksResponse = {
@@ -9,49 +10,54 @@ type ListStacksResponse = {
     error: string;
     stacks: unknown;
 };
-export declare function listStacks(auth: AuthParams): Promise<ListStacksResponse>;
+export declare function listStacks(auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<ListStacksResponse>;
 interface GetStackResponse {
     ok: boolean;
     error: string | null;
     stack: Stack;
     response?: Response;
 }
-export declare function getStack({ stackId, auth, }: {
+export declare function getStack({ stackId, auth, logger, }: {
     stackId: string;
     auth: AuthParams;
+    logger: ReturnType<typeof Logger>;
 }): Promise<GetStackResponse>;
 interface CreateStackResponse {
     ok: boolean;
     error: string | null;
     stack: Stack;
 }
-export declare function createStack({ stackMutation, auth, }: {
+export declare function createStack({ stackMutation, auth, logger, }: {
     stackMutation: StackMutation;
     auth: AuthParams;
+    logger: ReturnType<typeof Logger>;
 }): Promise<CreateStackResponse>;
-export declare function createEmptyStack({ token, scopeType, scopeId, name, }: {
+export declare function createEmptyStack({ token, scopeType, scopeId, name, logger, }: {
     token: string;
     scopeType: ScopeType;
     scopeId: string;
     name: string;
+    logger: ReturnType<typeof Logger>;
 }): Promise<Stack>;
 interface UpdateStackResponse {
     ok: boolean;
     error: string | null;
     stack: Stack;
 }
-export declare function updateStack({ stackId, stackMutation, auth, }: {
+export declare function updateStack({ stackId, stackMutation, auth, logger, }: {
     stackId: string;
     stackMutation: StackMutation;
     auth: AuthParams;
+    logger: ReturnType<typeof Logger>;
 }): Promise<UpdateStackResponse>;
 interface DestroyStackResponse {
     ok: boolean;
     error: string | null;
     stack: Stack;
 }
-export declare function destroyStack({ stackId, auth, }: {
+export declare function destroyStack({ stackId, auth, logger, }: {
     stackId: string;
     auth: AuthParams;
+    logger: ReturnType<typeof Logger>;
 }): Promise<DestroyStackResponse>;
 export {};

package/dist/actions/blueprints/stacks.js

@@ -1,9 +1,11 @@
 import config from '../../config.js';
 import getHeaders from '../../utils/get-headers.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 const { apiUrl } = config;
 export const stacksUrl = `${apiUrl}vX/blueprints/stacks`;
-export async function listStacks(auth) {
-    const response = await fetch(stacksUrl, {
+export async function listStacks(auth, logger) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(stacksUrl, {
         method: 'GET',
         headers: getHeaders(auth),
     });
@@ -14,8 +16,9 @@ export async function listStacks(auth) {
         stacks: data,
     };
 }
-export async function getStack({ stackId, auth, }) {
-    const response = await fetch(`${stacksUrl}/${stackId}`, {
+export async function getStack({ stackId, auth, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${stacksUrl}/${stackId}`, {
         method: 'GET',
         headers: getHeaders(auth),
     });
@@ -27,8 +30,9 @@ export async function getStack({ stackId, auth, }) {
         response,
     };
 }
-export async function createStack({ stackMutation, auth, }) {
-    const response = await fetch(stacksUrl, {
+export async function createStack({ stackMutation, auth, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(stacksUrl, {
         method: 'POST',
         headers: getHeaders(auth),
         body: JSON.stringify({ ...stackMutation, useProjectBasedId: false }), // API defaults to true as of 2025-11-26
@@ -40,7 +44,7 @@ export async function createStack({ stackMutation, auth, }) {
         stack: data,
     };
 }
-export async function createEmptyStack({ token, scopeType, scopeId, name, }) {
+export async function createEmptyStack({ token, scopeType, scopeId, name, logger, }) {
     const stackMutation = {
         name,
         scopeType,
@@ -50,14 +54,16 @@ export async function createEmptyStack({ token, scopeType, scopeId, name, }) {
     const response = await createStack({
         stackMutation,
         auth: { token, scopeType, scopeId },
+        logger,
     });
     if (!response.ok) {
         throw new Error(response.error || 'Failed to create new Stack');
     }
     return response.stack;
 }
-export async function updateStack({ stackId, stackMutation, auth, }) {
-    const response = await fetch(`${stacksUrl}/${stackId}`, {
+export async function updateStack({ stackId, stackMutation, auth, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${stacksUrl}/${stackId}`, {
         method: 'PUT',
         headers: getHeaders(auth),
         body: JSON.stringify(stackMutation),
@@ -69,8 +75,9 @@ export async function updateStack({ stackId, stackMutation, auth, }) {
         stack: data,
     };
 }
-export async function destroyStack({ stackId, auth, }) {
-    const response = await fetch(`${stacksUrl}/${stackId}`, {
+export async function destroyStack({ stackId, auth, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${stacksUrl}/${stackId}`, {
         method: 'DELETE',
         headers: getHeaders(auth),
     });

package/dist/actions/functions/dev.d.ts

@@ -1,2 +1,3 @@
+import type { Logger } from '../../utils/logger.js';
 import type { InvokeExecutionOptions } from '../../utils/types.js';
-export declare function dev(host: string, port: number, executionOptions?: Partial<InvokeExecutionOptions>): Promise<void>;
+export declare function dev(host: string, port: number, logger: ReturnType<typeof Logger>, executionOptions?: Partial<InvokeExecutionOptions>): Promise<void>;

package/dist/actions/functions/dev.js

@@ -1,4 +1,4 @@
 import { app } from '../../server/app.js';
-export async function dev(host, port, executionOptions) {
-    app(host, Number(port), executionOptions);
+export async function dev(host, port, logger, executionOptions) {
+    app(host, Number(port), logger, executionOptions);
 }

package/dist/actions/functions/env/list.d.ts

@@ -1,5 +1,6 @@
+import type { Logger } from '../../../utils/logger.js';
 import type { AuthParams } from '../../../utils/types.js';
-export declare function list(id: string, auth: AuthParams): Promise<{
+export declare function list(id: string, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<{
     ok: boolean;
     envvars: any;
     error: any;

package/dist/actions/functions/env/list.js

@@ -1,8 +1,10 @@
 import config from '../../../config.js';
 import getHeaders from '../../../utils/get-headers.js';
+import { createTracedFetch } from '../../../utils/traced-fetch.js';
 const { apiUrl } = config;
-export async function list(id, auth) {
-    const response = await fetch(`${apiUrl}v2025-07-30/functions/${id}/envvars`, {
+export async function list(id, auth, logger) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${apiUrl}v2025-07-30/functions/${id}/envvars`, {
         headers: getHeaders(auth),
         method: 'GET',
     });

package/dist/actions/functions/env/remove.d.ts

@@ -1,5 +1,6 @@
+import type { Logger } from '../../../utils/logger.js';
 import type { AuthParams } from '../../../utils/types.js';
-export declare function remove(id: string, key: string, auth: AuthParams): Promise<{
+export declare function remove(id: string, key: string, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<{
     ok: boolean;
     error: any;
 }>;

package/dist/actions/functions/env/remove.js

@@ -1,8 +1,10 @@
 import config from '../../../config.js';
 import getHeaders from '../../../utils/get-headers.js';
+import { createTracedFetch } from '../../../utils/traced-fetch.js';
 const { apiUrl } = config;
-export async function remove(id, key, auth) {
-    const response = await fetch(`${apiUrl}v2025-07-30/functions/${id}/envvars/${key}`, {
+export async function remove(id, key, auth, logger) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${apiUrl}v2025-07-30/functions/${id}/envvars/${key}`, {
         headers: getHeaders(auth),
         method: 'DELETE',
     });

package/dist/actions/functions/env/update.d.ts

@@ -1,5 +1,6 @@
+import type { Logger } from '../../../utils/logger.js';
 import type { AuthParams } from '../../../utils/types.js';
-export declare function update(id: string, key: string, value: string, auth: AuthParams): Promise<{
+export declare function update(id: string, key: string, value: string, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<{
     ok: boolean;
     error: any;
 }>;

package/dist/actions/functions/env/update.js

@@ -1,8 +1,10 @@
 import config from '../../../config.js';
 import getHeaders from '../../../utils/get-headers.js';
+import { createTracedFetch } from '../../../utils/traced-fetch.js';
 const { apiUrl } = config;
-export async function update(id, key, value, auth) {
-    const response = await fetch(`${apiUrl}v2025-07-30/functions/${id}/envvars/${key}`, {
+export async function update(id, key, value, auth, logger) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${apiUrl}v2025-07-30/functions/${id}/envvars/${key}`, {
         body: JSON.stringify({ value }),
         headers: getHeaders(auth),
         method: 'PUT',

package/dist/actions/functions/logs.d.ts

@@ -1,16 +1,17 @@
+import type { Logger } from '../../utils/logger.js';
 import type { AuthParams, FunctionLog } from '../../utils/types.js';
 /** @internal */
 export interface LoggingOptions {
     limit: number;
 }
-export declare function logs(id: string, options: LoggingOptions, auth: AuthParams): Promise<{
+export declare function logs(id: string, options: LoggingOptions, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<{
     ok: boolean;
     error: any;
     logs: any;
     total: any;
 }>;
-export declare function deleteLogs(id: string, auth: AuthParams): Promise<{
+export declare function deleteLogs(id: string, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<{
     ok: boolean;
     error: any;
 }>;
-export declare function streamLogs(id: string, auth: AuthParams, onLog: (log: FunctionLog) => void, onOpen: () => void, onError: (error: string) => void): () => void;
+export declare function streamLogs(id: string, auth: AuthParams, onLog: (log: FunctionLog) => void, onOpen: () => void, onError: (error: string) => void, logger: ReturnType<typeof Logger>): () => void;

package/dist/actions/functions/logs.js

@@ -1,10 +1,12 @@
 import { EventSource } from 'eventsource';
 import config from '../../config.js';
 import getHeaders from '../../utils/get-headers.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 const { apiUrl } = config;
-export async function logs(id, options, auth) {
+export async function logs(id, options, auth, logger) {
     const { limit } = options;
-    const response = await fetch(`${apiUrl}v2025-07-30/functions/${id}/logs?limit=${limit}`, {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${apiUrl}v2025-07-30/functions/${id}/logs?limit=${limit}`, {
         headers: getHeaders(auth),
         method: 'GET',
     });
@@ -16,8 +18,9 @@ export async function logs(id, options, auth) {
         total: response.ok ? json.total : 0,
     };
 }
-export async function deleteLogs(id, auth) {
-    const response = await fetch(`${apiUrl}v2025-07-30/functions/${id}/logs`, {
+export async function deleteLogs(id, auth, logger) {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${apiUrl}v2025-07-30/functions/${id}/logs`, {
         headers: getHeaders(auth),
         method: 'DELETE',
     });
@@ -28,11 +31,12 @@ export async function deleteLogs(id, auth) {
     };
 }
 // Create streaming logs connection
-export function streamLogs(id, auth, onLog, onOpen, onError) {
+export function streamLogs(id, auth, onLog, onOpen, onError, logger) {
     const url = new URL(`${apiUrl}v2025-07-30/functions/${id}/logs/stream`);
     const headers = getHeaders(auth);
+    const fetchFn = createTracedFetch(logger);
     const eventSource = new EventSource(url.toString(), {
-        fetch: (input, init) => fetch(input, {
+        fetch: (input, init) => fetchFn(input, {
             ...init,
             headers: {
                 ...init?.headers,

package/dist/actions/node.d.ts

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

package/dist/actions/node.js

@@ -1,12 +1,12 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join } from 'node:path';
 import { getLatestNpmVersion } from '../utils/other/npmjs.js';
-export async function writeOrUpdateNodeDependency(nearFilePath, dependency) {
+export async function writeOrUpdateNodeDependency(nearFilePath, dependency, logger) {
     const dir = dirname(nearFilePath);
     const extension = extname(nearFilePath);
     if (extension === '.json')
         return; // ? why do we bail out here?
-    const version = await getLatestNpmVersion(dependency);
+    const version = await getLatestNpmVersion(dependency, logger);
     const packageJsonPath = join(dir, 'package.json');
     const packageExists = existsSync(packageJsonPath);
     if (!packageExists) {

package/dist/actions/sanity/examples.d.ts

@@ -1,22 +1,25 @@
+import type { Logger } from '../../utils/logger.js';
 export declare const EXAMPLES_CACHE_DIR: string;
 declare const EXAMPLE_TYPES: {
     blueprint: string;
     function: string;
 };
-export declare function verifyExampleExists({ type, name, }: {
+export declare function verifyExampleExists({ type, name, logger, }: {
     type: keyof typeof EXAMPLE_TYPES;
     name: string;
+    logger: ReturnType<typeof Logger>;
 }): Promise<boolean>;
 /**
  * Downloads an example from the examples repo and writes it to disk.
  * @sideEffect Creates the example directory and writes the example to disk.
  * @returns The example files and directory and the function config if it exists.
  */
-export declare function writeExample({ ownerRepo, exampleType, exampleName, dir, }: {
+export declare function writeExample({ ownerRepo, exampleType, exampleName, dir, logger, }: {
     ownerRepo?: string;
     exampleType: keyof typeof EXAMPLE_TYPES;
     exampleName: string;
     dir?: string;
+    logger: ReturnType<typeof Logger>;
 }): Promise<false | {
     files: Record<string, string>;
     dir: string;

package/dist/actions/sanity/examples.js

@@ -14,13 +14,13 @@ const EXAMPLE_TYPES = {
     blueprint: BLUEPRINTS_DIR,
     function: FUNCTIONS_DIR,
 };
-export async function verifyExampleExists({ type, name, }) {
+export async function verifyExampleExists({ type, name, logger, }) {
     const examplePath = `${EXAMPLE_TYPES[type]}/${name}`;
     const path = `/repos/${EXAMPLES_REPO}/contents/${examplePath}`;
-    const response = await gitHubRequest(path);
+    const response = await gitHubRequest(path, logger);
     return response.ok;
 }
-async function downloadRepoArchive(ownerRepo, ref = 'main') {
+async function downloadRepoArchive(logger, ownerRepo, ref = 'main') {
     // cache the archive in a temp directory
     const cacheKey = `${ownerRepo.replace('/', '-')}-${ref}.tar.gz`;
     const cacheDir = EXAMPLES_CACHE_DIR;
@@ -33,7 +33,7 @@ async function downloadRepoArchive(ownerRepo, ref = 'main') {
     }
     const path = `/repos/${ownerRepo}/tarball/${ref}`;
     try {
-        const response = await gitHubRequest(path);
+        const response = await gitHubRequest(path, logger);
         if (!response.ok)
             throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
         if (!response.body)
@@ -154,8 +154,8 @@ function extractInstructions(exampleFiles) {
  * @sideEffect Creates the example directory and writes the example to disk.
  * @returns The example files and directory and the function config if it exists.
  */
-export async function writeExample({ ownerRepo = EXAMPLES_REPO, exampleType, exampleName, dir = './tmp', }) {
-    const archiveStream = await downloadRepoArchive(ownerRepo);
+export async function writeExample({ ownerRepo = EXAMPLES_REPO, exampleType, exampleName, dir = './tmp', logger, }) {
+    const archiveStream = await downloadRepoArchive(logger, ownerRepo);
     if (!archiveStream)
         return false;
     const exampleFiles = await extractExampleFromArchive({

package/dist/actions/sanity/projects.d.ts

@@ -1,3 +1,4 @@
+import type { Logger } from '../../utils/logger.js';
 import type { ScopeType } from '../../utils/types.js';
 export declare const projectsApiPath: string;
 export declare const orgsApiPath: string;
@@ -18,8 +19,9 @@ interface ListProjectsResponse {
     error: string | null;
     projects: Project[];
 }
-export declare function listProjects({ token }: {
+export declare function listProjects({ token, logger, }: {
     token: string;
+    logger: ReturnType<typeof Logger>;
 }): Promise<ListProjectsResponse>;
 interface GroupedProjectsByOrganizationResponse {
     ok: boolean;
@@ -33,17 +35,19 @@ interface GroupedProjects {
     };
     projects?: Project[];
 }
-export declare function groupProjectsByOrganization({ token, }: {
+export declare function groupProjectsByOrganization({ token, logger, }: {
     token: string;
+    logger: ReturnType<typeof Logger>;
 }): Promise<GroupedProjectsByOrganizationResponse>;
 interface GetProjectResponse {
     ok: boolean;
     error: string | null;
     project: Project;
 }
-export declare function getProject({ token, scopeId, scopeType, }: {
+export declare function getProject({ token, scopeId, scopeType, logger, }: {
     token: string;
     scopeId: string;
     scopeType: ScopeType;
+    logger: ReturnType<typeof Logger>;
 }): Promise<GetProjectResponse>;
 export {};

package/dist/actions/sanity/projects.js

@@ -1,9 +1,11 @@
 import config from '../../config.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 const { apiUrl } = config;
 export const projectsApiPath = `${apiUrl}v2021-06-07/projects`;
 export const orgsApiPath = `${apiUrl}v2021-06-07/organizations`;
-export async function listProjects({ token }) {
-    const projectsFetch = await fetch(projectsApiPath, {
+export async function listProjects({ token, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const projectsFetch = await fetchFn(projectsApiPath, {
         method: 'GET',
         headers: {
             Authorization: `Bearer ${token}`,
@@ -17,8 +19,9 @@ export async function listProjects({ token }) {
         projects,
     };
 }
-export async function groupProjectsByOrganization({ token, }) {
-    const projectsResponse = await listProjects({ token });
+export async function groupProjectsByOrganization({ token, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const projectsResponse = await listProjects({ token, logger });
     if (!projectsResponse.ok) {
         return {
             ok: false,
@@ -26,7 +29,7 @@ export async function groupProjectsByOrganization({ token, }) {
             organizations: [],
         };
     }
-    const orgsFetch = await fetch(orgsApiPath, {
+    const orgsFetch = await fetchFn(orgsApiPath, {
         method: 'GET',
         headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
     });
@@ -48,11 +51,12 @@ export async function groupProjectsByOrganization({ token, }) {
         organizations: orgsWithProjects,
     };
 }
-export async function getProject({ token, scopeId, scopeType, }) {
+export async function getProject({ token, scopeId, scopeType, logger, }) {
     if (scopeType !== 'project') {
         throw new Error('Scope type must be project');
     }
-    const response = await fetch(`${projectsApiPath}/${scopeId}`, {
+    const fetchFn = createTracedFetch(logger);
+    const response = await fetchFn(`${projectsApiPath}/${scopeId}`, {
         method: 'GET',
         headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
     });

package/dist/baseCommands.d.ts

@@ -7,6 +7,7 @@ export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
 export declare const baseFlags: {
     json: Interfaces.BooleanFlag<boolean>;
     path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    trace: Interfaces.BooleanFlag<boolean>;
     verbose: Interfaces.BooleanFlag<boolean>;
 };
 /**
@@ -25,6 +26,7 @@ export declare abstract class RuntimeCommand<T extends typeof Command> extends C
     static baseFlags: {
         json: Interfaces.BooleanFlag<boolean>;
         path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        trace: Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
     };
     static enableJsonFlag: boolean;
@@ -49,6 +51,7 @@ export declare abstract class LocalBlueprintCommand<T extends typeof Command> ex
     static baseFlags: {
         json: Interfaces.BooleanFlag<boolean>;
         path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        trace: Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
     };
     init(): Promise<void>;
@@ -71,6 +74,7 @@ export declare abstract class DeployedStackCommand<T extends typeof Command> ext
     static baseFlags: {
         json: Interfaces.BooleanFlag<boolean>;
         path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        trace: Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
     };
     init(): Promise<void>;