@sanity/runtime-cli 14.7.2 → 14.8.1

package/dist/actions/blueprints/assets.js

@@ -1,131 +1,102 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import AdmZip from 'adm-zip';
 import config from '../../config.js';
 import { CONVERT_BYTES_TO_MB, MAX_ASSET_SIZE } from '../../constants.js';
 import { detectNativeModules } from '../../utils/functions/detect-native-modules.js';
-import { prepareAsset } from '../../utils/functions/prepare-asset.js';
+import { prepareAsset as prepareFunctionAsset } from '../../utils/functions/prepare-asset.js';
 import getHeaders from '../../utils/get-headers.js';
 import { createTracedFetch } from '../../utils/traced-fetch.js';
-import { isLocalFunctionCollection } from '../../utils/types.js';
+import { isLocalFunctionResource, isStudioResource } from '../../utils/types.js';
 const { apiUrl } = config;
 const ASSETS_URL = `${apiUrl}vX/blueprints/assets`;
 export const ASSET_CHECK_URL = `${ASSETS_URL}/check`;
 export const ASSET_STASH_URL = `${ASSETS_URL}/stash`;
 export async function stashAsset({ resource, auth, logger, installer, }) {
-    const isCollection = isLocalFunctionCollection(resource);
-    const functions = isCollection ? resource.functions : [resource];
-    const combinedAsset = [];
-    const prepareErrors = [];
     try {
-        for (const func of functions) {
-            const prepResult = await prepareAsset({ resource: func }, { installer });
-            if (prepResult.success && prepResult.outputPath && prepResult.cleanup) {
-                combinedAsset.push({
-                    name: func.name,
-                    partAsset: { outputPath: prepResult.outputPath, cleanup: prepResult.cleanup },
-                });
+        let b64;
+        let hash;
+        let extension;
+        let cleanup;
+        if (isLocalFunctionResource(resource)) {
+            const prepResult = await prepareFunctionAsset({ resource }, { installer });
+            if (prepResult.success === false) {
+                return {
+                    success: false,
+                    error: prepResult.error,
+                };
             }
-            else if (prepResult.error) {
-                prepareErrors.push({ name: func.name, error: prepResult.error });
+            const zipResult = await pathToB64ZipHash(prepResult.outputPath);
+            b64 = zipResult.b64;
+            hash = zipResult.hash;
+            extension = 'zip';
+            cleanup = prepResult.cleanup;
+        }
+        else if (isStudioResource(resource)) {
+            const prepResult = await prepareStudioAsset({ resource });
+            if (prepResult.success === false) {
+                return {
+                    success: false,
+                    error: prepResult.error,
+                };
             }
+            const buffer = await fs.promises.readFile(prepResult.outputPath);
+            b64 = buffer.toString('base64');
+            hash = hashBuffer(buffer);
+            extension = 'tar.gz';
+            cleanup = prepResult.cleanup;
         }
-        if (combinedAsset.length !== functions.length) {
-            const processedNames = new Set(combinedAsset.map((asset) => asset.name));
-            const failedFunctions = functions.filter((func) => !processedNames.has(func.name));
-            const failedNames = failedFunctions.map((f) => f.name).join(', ');
-            const errorDetails = prepareErrors.map((e) => `${e.name}: ${e.error}`).join('; ');
+        else {
             return {
                 success: false,
-                error: `Failed to prepare ${failedFunctions.length} function(s) in blueprint: ${failedNames}${errorDetails ? `. Details: ${errorDetails}` : ''}`,
+                error: `Invalid resource type ${resource.type} for asset processing`,
             };
         }
-        let result = { success: false };
-        if (isCollection) {
-            const combinedResult = await combineAssets(combinedAsset);
-            if (combinedResult.combinedPath && combinedResult.cleanup) {
-                result = await stashSingleAsset({
-                    outputPath: combinedResult.combinedPath,
-                    cleanup: combinedResult.cleanup,
-                    resource: resource,
-                    auth,
-                    logger,
-                    collectionInfo: {
-                        name: resource.name,
-                        functionCount: resource.functions.length,
-                    },
-                });
-            }
-            else if (combinedResult.error) {
-                result = { success: false, error: combinedResult.error };
-            }
-        }
-        else {
-            result = await stashSingleAsset({
-                outputPath: combinedAsset[0].partAsset.outputPath,
-                cleanup: combinedAsset[0].partAsset.cleanup,
-                resource: resource,
-                auth,
-                logger,
-            });
-        }
-        return result;
+        return await stashSingleAsset({
+            b64,
+            hash,
+            extension,
+            cleanup,
+            resource,
+            auth,
+            logger,
+        });
     }
     catch (err) {
         return { success: false, error: err instanceof Error ? err.message : `${err}` };
     }
 }
-async function combineAssets(allAssets) {
-    const combinedPath = path.join(os.tmpdir(), `assets-${Date.now()}`);
-    await fs.promises.mkdir(combinedPath, { recursive: true });
-    try {
-        for (const asset of allAssets) {
-            try {
-                await fs.promises.mkdir(path.join(combinedPath, asset.name), { recursive: true });
-                await fs.promises.cp(asset.partAsset.outputPath, path.join(combinedPath, asset.name), {
-                    recursive: true,
-                });
-                await asset.partAsset.cleanup();
-            }
-            catch (err) {
-                // Clean up any partial work
-                try {
-                    await fs.promises.rm(combinedPath, { recursive: true, force: true });
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-                // Clean up remaining individual assets
-                await Promise.allSettled(allAssets.map((a) => a.partAsset.cleanup()));
-                return {
-                    error: `Failed to combine asset for function '${asset.name}': ${err instanceof Error ? err.message : String(err)}`,
-                };
-            }
-        }
-        const cleanupCombined = async () => {
-            await fs.promises.rm(combinedPath, { recursive: true, force: true });
+async function prepareStudioAsset({ resource }) {
+    if (!('src' in resource) || typeof resource.src !== 'string') {
+        return {
+            success: false,
+            async cleanup() {
+                // no op
+            },
+            error: `Resource of type '${resource.type}' must have a 'src' property`,
         };
-        return { combinedPath, cleanup: cleanupCombined };
     }
-    catch (err) {
-        // Clean up any partial work
-        try {
-            await fs.promises.rm(combinedPath, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-        // Clean up individual assets that were successfully prepared
-        await Promise.allSettled(allAssets.map((asset) => asset.partAsset.cleanup()));
-        return { error: err instanceof Error ? err.message : `${err}` };
+    else if (!fs.existsSync(resource.src)) {
+        return {
+            success: false,
+            async cleanup() {
+                // no op
+            },
+            error: `Property 'src' on resource with type '${resource.type}' must be a directory`,
+        };
     }
+    return {
+        success: true,
+        async cleanup() {
+            // no op
+        },
+        // studio must be pre built (e.g. with `npm run build`) and tarred/gzipped
+        outputPath: resource.src,
+    };
 }
-async function stashSingleAsset({ outputPath, cleanup, resource, auth, logger, collectionInfo, }) {
+async function stashSingleAsset({ b64, hash, cleanup, resource, auth, logger, extension = 'zip', }) {
     const fetchFn = createTracedFetch(logger);
     try {
-        const { b64, hash } = await pathToB64ZipHash(outputPath);
         try {
             const checkResponse = await fetchFn(`${ASSET_CHECK_URL}/${hash}`, {
                 method: 'GET',
@@ -143,19 +114,16 @@ async function stashSingleAsset({ outputPath, cleanup, resource, auth, logger, c
             headers: getHeaders(auth),
             body: JSON.stringify({
                 file: b64,
-                filename: `${resource.name}.zip`,
+                filename: `${resource.name}.${extension}`,
             }),
         });
         const assetJson = await assetResponse.json();
         if (assetResponse.ok) {
             return { success: true, assetId: assetJson.id, exists: false, hash };
         }
-        const contextMsg = collectionInfo
-            ? ` (part of collection '${collectionInfo.name}' with ${collectionInfo.functionCount} functions)`
-            : '';
         return {
             success: false,
-            error: `Failed to stash asset for ${resource.name}${contextMsg}: ${assetJson.message || 'Unknown error'}`,
+            error: `Failed to stash asset for ${resource.name}: ${assetJson.message || 'Unknown error'}`,
         };
     }
     catch (err) {

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

@@ -1,7 +1,7 @@
 import type { BlueprintResource } from '@sanity/blueprints';
 import { type Blueprint } from '@sanity/blueprints-parser';
 import type { Logger } from '../../utils/logger.js';
-import { type BlueprintParserError, type ScopeType } from '../../utils/types.js';
+import type { BlueprintParserError, ScopeType } from '../../utils/types.js';
 import { type LocatedBlueprintsConfig } from './config.js';
 declare const SUPPORTED_FILE_EXTENSIONS: readonly [".json", ".js", ".mjs", ".ts"];
 type BlueprintFileExtension = (typeof SUPPORTED_FILE_EXTENSIONS)[number];
@@ -65,7 +65,7 @@ export interface ReadBlueprintResult {
  * @param blueprintPath - The path of the blueprint file or directory- will search up the directory tree!
  * @returns Known information about the Blueprint, config, and Stack
  */
-export declare function readLocalBlueprint(logger: ReturnType<typeof Logger>, validate: {
+export declare function readLocalBlueprint(logger: Logger, validate: {
     resources: boolean;
 }, blueprintPath?: string): Promise<ReadBlueprintResult>;
 export declare function writeBlueprintToDisk({ blueprintFilePath, jsonContent, }: {

package/dist/actions/blueprints/blueprint.js

@@ -6,9 +6,7 @@ import blueprintParserValidator from '@sanity/blueprints-parser';
 import * as find from 'empathic/find';
 import { createJiti } from 'jiti';
 import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, } from '../../constants.js';
-import { isLocalFunctionResource, } from '../../utils/types.js';
 import { validateResources } from '../../utils/validate/index.js';
-import { validateFunctionResource } from '../../utils/validate/resource.js';
 import { backfillOrganizationId, backfillProjectBasedStackId, readConfigFile, } from './config.js';
 const SUPPORTED_FILE_EXTENSIONS = ['.json', '.js', '.mjs', '.ts'];
 let SUPPORTED_FILE_NAMES = SUPPORTED_FILE_EXTENSIONS.map((ext) => `blueprint${ext}`);
@@ -215,6 +213,7 @@ export async function readLocalBlueprint(logger, validate, blueprintPath) {
         scopeId = organizationId;
     }
     const parserResult = blueprintParserValidator(rawBlueprint, {
+        // Prevents the following resources from being referenced.
         invalidReferenceTypes: [
             SANITY_FUNCTION_DOCUMENT,
             SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
@@ -229,12 +228,6 @@ export async function readLocalBlueprint(logger, validate, blueprintPath) {
             // validate function resources
             errors.push(...validateResources(parsedBlueprint.resources));
         }
-        else {
-            // backwards compat: fallback to the previous validation if validation was not explicitly enabled
-            const functionResources = parsedBlueprint.resources.filter(isLocalFunctionResource);
-            const fnErrors = functionResources.map((r) => validateFunctionResource(r));
-            errors.push(...fnErrors.flat());
-        }
     }
     return {
         fileInfo: { blueprintFilePath: foundFilePath, fileName, extension },

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

@@ -53,10 +53,10 @@ export declare function patchConfigFile(blueprintFilePath: string, updateablePro
 export declare function backfillOrganizationId({ blueprintFilePath, projectId, logger, }: {
     blueprintFilePath: string;
     projectId: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<string>;
 export declare function backfillProjectBasedStackId({ blueprintFilePath, projectId, logger, }: {
     blueprintFilePath: string;
     projectId: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<string | undefined>;

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

@@ -6,7 +6,7 @@ export interface LogStreamingConfig {
     auth: AuthParams;
     showBanner?: boolean;
     verbose?: boolean;
-    log: ReturnType<typeof Logger>;
+    log: Logger;
     onActivity?: () => void;
 }
 export interface StreamLogsOptions {
@@ -16,7 +16,7 @@ export interface StreamLogsOptions {
     onLog: (log: BlueprintLog) => void;
     onOpen: () => void;
     onError: (error: string) => void;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }
 export declare function streamLogs({ stackId, after, auth, onLog, onOpen, onError, logger, }: StreamLogsOptions): () => void;
 /** Check if a log is newer than a given timestamp */

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

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

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

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

package/dist/actions/blueprints/resources.js

@@ -2,7 +2,6 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { cwd } from 'node:process';
-import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
 import { styleText } from '../../utils/style-text.js';
 import { writeOrUpdateNodeDependency } from '../node.js';
 import { addResourceToBlueprint } from './blueprint.js';
@@ -57,18 +56,39 @@ export async function createFunctionResource(options, logger) {
             throw new Error(`Failed to install dependencies using \`${installCommand}\``);
         }
     }
-    // type looks like 'document-publish' or 'media-library-asset-delete'
+    // type looks like 'document-publish', 'media-library-asset-delete' or 'scheduled-function'
+    // and we are guaranteed to have the same leading words (typeName below) for all provided type strings (via guards in the call site for this method).
     const typeName = type[0].substring(0, type[0].lastIndexOf('-'));
     const eventsOn = type.map((t) => t.substring(t.lastIndexOf('-') + 1));
     // Create resource definition
-    const resourceJson = {
-        name,
-        src: `functions/${name}`,
-        type: `${SANITY_FUNCTION_PREFIX}${typeName}`,
-        event: {
-            on: eventsOn,
-        },
-    };
+    let resourceJson;
+    switch (typeName) {
+        case 'document':
+            resourceJson = {
+                name,
+                src: `functions/${name}`,
+                type: 'sanity.function.document',
+                event: {
+                    on: eventsOn,
+                },
+            };
+            break;
+        case 'media-library-asset':
+            resourceJson = {
+                name,
+                src: `functions/${name}`,
+                type: 'sanity.function.media-library.asset',
+                event: {
+                    on: eventsOn,
+                    resource: { type: 'media-library', id: 'my-media-library-id' },
+                },
+            };
+            break;
+        // TODO: add scheduled and sync tag invalidate funx
+    }
+    if (!resourceJson) {
+        throw new Error('Could not create function resource based on selections');
+    }
     // Add to blueprint or return for manual addition
     const resource = addResourceToBlueprint({ blueprintFilePath, resource: resourceJson });
     return {

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

@@ -1,6 +1,6 @@
 import type { Blueprint } from '@sanity/blueprints-parser';
 import type { Logger } from '../../utils/logger.js';
-import type { AuthParams, ScopeType, Stack, StackMutation, StackSummary } from '../../utils/types.js';
+import type { ActionResponse, AuthParams, ScopeType, Stack, StackMutation, StackSummary } from '../../utils/types.js';
 export declare const stacksUrl: string;
 type ListStacksResponse = {
     ok: true;
@@ -11,45 +11,39 @@ type ListStacksResponse = {
     error: string;
     stacks: unknown;
 };
-export declare function listStacks(auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<ListStacksResponse>;
-interface GetStackResponse {
-    ok: boolean;
-    error: string | null;
+export declare function listStacks(auth: AuthParams, logger: Logger): Promise<ListStacksResponse>;
+interface GetStackResponse extends ActionResponse {
     stack: Stack;
     response?: Response;
 }
 export declare function getStack({ stackId, auth, logger, }: {
     stackId: string;
     auth: AuthParams;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<GetStackResponse>;
-interface CreateStackResponse {
-    ok: boolean;
-    error: string | null;
+interface CreateStackResponse extends ActionResponse {
     stack: Stack;
 }
 export declare function createStack({ stackMutation, auth, logger, }: {
     stackMutation: StackMutation;
     auth: AuthParams;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<CreateStackResponse>;
 export declare function createEmptyStack({ token, scopeType, scopeId, name, logger, }: {
     token: string;
     scopeType: ScopeType;
     scopeId: string;
     name: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<Stack>;
-interface UpdateStackResponse {
-    ok: boolean;
-    error: string | null;
+interface UpdateStackResponse extends ActionResponse {
     stack: Stack;
 }
 export declare function updateStack({ stackId, stackMutation, auth, logger, }: {
     stackId: string;
     stackMutation: StackMutation;
     auth: AuthParams;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<UpdateStackResponse>;
 interface PlanResourceSnapshot {
     name: string;
@@ -99,17 +93,13 @@ export declare function planStack({ stackId, document, auth, logger, }: {
     stackId: string;
     document: Blueprint;
     auth: AuthParams;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<PlanStackResponse>;
-interface DestroyStackResponse {
-    ok: boolean;
-    error: string | null;
+interface DestroyStackResponse extends ActionResponse {
     stack: Stack;
 }
-export declare function resolveStackIdByNameOrId(value: string, auth: AuthParams, logger: ReturnType<typeof Logger>): Promise<string>;
-interface PromoteStackResponse {
-    ok: boolean;
-    error: string | null;
+export declare function resolveStackIdByNameOrId(value: string, auth: AuthParams, logger: Logger): Promise<string>;
+interface PromoteStackResponse extends ActionResponse {
     stack: Stack & {
         alreadyPromoted: boolean;
     };
@@ -117,11 +107,11 @@ interface PromoteStackResponse {
 export declare function promoteStack({ stackId, auth, logger, }: {
     stackId: string;
     auth: AuthParams;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<PromoteStackResponse>;
 export declare function destroyStack({ stackId, auth, logger, }: {
     stackId: string;
     auth: AuthParams;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<DestroyStackResponse>;
 export {};

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

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

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

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

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

@@ -1,6 +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, logger: ReturnType<typeof Logger>): Promise<{
+export declare function remove(id: string, key: string, auth: AuthParams, logger: Logger): Promise<{
     ok: boolean;
     error: any;
 }>;

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

@@ -1,6 +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, logger: ReturnType<typeof Logger>): Promise<{
+export declare function update(id: string, key: string, value: string, auth: AuthParams, logger: Logger): Promise<{
     ok: boolean;
     error: any;
 }>;

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

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

package/dist/actions/node.d.ts

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

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

@@ -7,7 +7,7 @@ declare const EXAMPLE_TYPES: {
 export declare function verifyExampleExists({ type, name, logger, }: {
     type: keyof typeof EXAMPLE_TYPES;
     name: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<boolean>;
 /**
  * Downloads an example from the examples repo and writes it to disk.
@@ -19,7 +19,7 @@ export declare function writeExample({ ownerRepo, exampleType, exampleName, dir,
     exampleType: keyof typeof EXAMPLE_TYPES;
     exampleName: string;
     dir?: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<false | {
     files: Record<string, string>;
     dir: string;

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

@@ -1,5 +1,5 @@
 import type { Logger } from '../../utils/logger.js';
-import type { ScopeType } from '../../utils/types.js';
+import type { ActionResponse, ScopeType } from '../../utils/types.js';
 export declare const projectsApiPath: string;
 export declare const orgsApiPath: string;
 export interface Project {
@@ -14,18 +14,14 @@ export interface Project {
     createdAt: string;
     updatedAt: string;
 }
-interface ListProjectsResponse {
-    ok: boolean;
-    error: string | null;
+interface ListProjectsResponse extends ActionResponse {
     projects: Project[];
 }
 export declare function listProjects({ token, logger, }: {
     token: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<ListProjectsResponse>;
-interface GroupedProjectsByOrganizationResponse {
-    ok: boolean;
-    error: string | null;
+interface GroupedProjectsByOrganizationResponse extends ActionResponse {
     organizations: GroupedProjects[];
 }
 interface GroupedProjects {
@@ -37,17 +33,15 @@ interface GroupedProjects {
 }
 export declare function groupProjectsByOrganization({ token, logger, }: {
     token: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<GroupedProjectsByOrganizationResponse>;
-interface GetProjectResponse {
-    ok: boolean;
-    error: string | null;
+interface GetProjectResponse extends ActionResponse {
     project: Project;
 }
 export declare function getProject({ token, scopeId, scopeType, logger, }: {
     token: string;
     scopeId: string;
     scopeType: ScopeType;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<GetProjectResponse>;
 export {};

package/dist/baseCommands.d.ts

@@ -12,6 +12,14 @@ export declare const baseFlags: {
     verbose: Interfaces.BooleanFlag<boolean>;
 };
 export declare const stackFlag: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+export declare const projectIdFlagConfig: {
+    description: string;
+    aliases: string[];
+};
+export declare const organizationIdFlagConfig: {
+    description: string;
+    aliases: string[];
+};
 /**
  * @description Unhides a flag by setting its hidden property to false
  * Also makes oclif's types happy when destructuring the flag