@sanity/runtime-cli 14.10.1 → 14.12.0

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

@@ -0,0 +1,46 @@
+import type { ScopeType } from '../../utils/types.js';
+/**
+ * Source of a resolved config value.
+ * - flags: from CLI flags like `--project-id`
+ * - env: from the environment - usually CLI var like `SANITY_ORGANIZATION_ID`
+ * - module: from the blueprint module - undocumented escape hatch
+ * - config: from the config file - .sanity/blueprint.config.json most common
+ * - inferred: legacy `ST-<projectId>` stacks from launch
+ */
+export type ConfigSource = 'flags' | 'env' | 'module' | 'config' | 'inferred';
+/** A set of optional IDs from a single source. */
+export interface IdValues {
+    organizationId?: string;
+    projectId?: string;
+    stackId?: string;
+}
+/**
+ * Sources to resolve IDs from, in descending priority.
+ * Each key maps to a source; the first non-empty value wins.
+ */
+export interface IdSources {
+    flags?: IdValues;
+    env?: IdValues;
+    module?: IdValues;
+    config?: IdValues;
+}
+export interface ResolvedIds {
+    organizationId?: string;
+    projectId?: string;
+    stackId?: string;
+    scopeType?: ScopeType;
+    scopeId?: string;
+    sources: {
+        organizationId?: ConfigSource;
+        projectId?: ConfigSource;
+        stackId?: ConfigSource;
+    };
+}
+/**
+ * Resolve organization, project, and stack IDs from a prioritized set of sources.
+ * Precedence: flags > env > module > config.
+ * Derives scopeType/scopeId from the resolved IDs (project > organization).
+ *
+ * This is a pure, synchronous function -- no I/O, no side effects.
+ */
+export declare function resolveIds(sources: IdSources): ResolvedIds;

package/dist/actions/blueprints/resolve.js

@@ -0,0 +1,42 @@
+/**
+ * Resolve organization, project, and stack IDs from a prioritized set of sources.
+ * Precedence: flags > env > module > config.
+ * Derives scopeType/scopeId from the resolved IDs (project > organization).
+ *
+ * This is a pure, synchronous function -- no I/O, no side effects.
+ */
+export function resolveIds(sources) {
+    const ordered = [
+        { source: 'flags', values: sources.flags },
+        { source: 'env', values: sources.env },
+        { source: 'module', values: sources.module },
+        { source: 'config', values: sources.config },
+    ];
+    const result = { sources: {} };
+    for (const { source, values } of ordered) {
+        if (!values)
+            continue;
+        if (!result.organizationId && values.organizationId) {
+            result.organizationId = values.organizationId;
+            result.sources.organizationId = source;
+        }
+        if (!result.projectId && values.projectId) {
+            result.projectId = values.projectId;
+            result.sources.projectId = source;
+        }
+        if (!result.stackId && values.stackId) {
+            result.stackId = values.stackId;
+            result.sources.stackId = source;
+        }
+    }
+    // Scope is as specific as possible; project > organization
+    if (result.projectId) {
+        result.scopeType = 'project';
+        result.scopeId = result.projectId;
+    }
+    else if (result.organizationId) {
+        result.scopeType = 'organization';
+        result.scopeId = result.organizationId;
+    }
+    return result;
+}

package/dist/actions/blueprints/resources.js

@@ -2,6 +2,7 @@ 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 { MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
 import { styleText } from '../../utils/style-text.js';
 import { writeOrUpdateNodeDependency } from '../node.js';
 import { addResourceToBlueprint } from './blueprint.js';
@@ -21,6 +22,20 @@ export const handler = scheduledEventHandler(async ({ context }) => {
   const time = new Date().toLocaleTimeString()
   console.log(\`Your scheduled Sanity Function was called at \${time}\`)
 })`;
+const DEFAULT_SYNC_TAG_HELPER_FUNCTION_TEMPLATE = /*ts*/ `import { syncTagInvalidateEventHandler } from '@sanity/functions'
+
+export const handler = syncTagInvalidateEventHandler(async ({ context, event, done }) => {
+  const time = new Date().toLocaleTimeString()
+  console.log(\`Your sync tag invalidate Sanity Function was called at \${time}\`)
+  // TODO: add code to do something with the invalidated sync tags provided to you in \`event.data.syncTags\`
+  try {
+    // notify Sanity that you have completed invalidation
+    const response = await done(event.data.syncTags)
+    console.log('Invalidation complete, Sanity responded with an HTTP', response.status)
+  } catch (e) {
+    console.error('Error invoking Sanity invalidation done endpoint!', e)
+  }
+})`;
 /**
  * Creates a new function resource file and adds it to the blueprint
  */
@@ -47,16 +62,18 @@ export async function createFunctionResource(options, logger) {
         throw Error(`Unsupported language: ${lang}`);
     // 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).
-    // TODO: this substring convention is brittle - consider mapping EVENT_* constants to typeName values explicitly instead of relying on string splitting.
-    const typeName = type[0].substring(0, type[0].lastIndexOf('-'));
+    const functionType = MAP_EVENT_TO_FUNCTION_TYPE[type[0]];
     // Create index.<lang> with default template
     const indexPath = join(functionDir, `index.${lang}`);
     let template = DEFAULT_FUNCTION_TEMPLATE;
     if (addHelpers) {
-        switch (typeName) {
-            case 'scheduled':
+        switch (functionType) {
+            case SANITY_FUNCTION_SCHEDULED:
                 template = DEFAULT_SCHEDULED_HELPER_FUNCTION_TEMPLATE;
                 break;
+            case SANITY_FUNCTION_SYNC_TAG_INVALIDATE:
+                template = DEFAULT_SYNC_TAG_HELPER_FUNCTION_TEMPLATE;
+                break;
             default:
                 template = DEFAULT_HELPER_FUNCTION_TEMPLATE;
                 break;
@@ -80,39 +97,45 @@ export async function createFunctionResource(options, logger) {
     const eventsOn = type.map((t) => t.substring(t.lastIndexOf('-') + 1));
     // Create resource definition
     let resourceJson;
-    switch (typeName) {
-        case 'document':
+    switch (functionType) {
+        case SANITY_FUNCTION_DOCUMENT:
             resourceJson = {
                 name,
                 src: `functions/${name}`,
-                type: 'sanity.function.document',
+                type: SANITY_FUNCTION_DOCUMENT,
                 event: {
                     on: eventsOn,
                 },
             };
             break;
-        case 'media-library-asset':
+        case SANITY_FUNCTION_MEDIA_LIBRARY_ASSET:
             resourceJson = {
                 name,
                 src: `functions/${name}`,
-                type: 'sanity.function.media-library.asset',
+                type: SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
                 event: {
                     on: eventsOn,
                     resource: { type: 'media-library', id: 'my-media-library-id' },
                 },
             };
             break;
-        case 'scheduled':
+        case SANITY_FUNCTION_SCHEDULED:
             resourceJson = {
                 name,
                 src: `functions/${name}`,
-                type: 'sanity.function.cron',
+                type: SANITY_FUNCTION_SCHEDULED,
                 event: {
                     expression: '0 0 * * *',
                 },
             };
             break;
-        // TODO: add sync tag invalidate funx
+        case SANITY_FUNCTION_SYNC_TAG_INVALIDATE:
+            resourceJson = {
+                name,
+                src: `functions/${name}`,
+                type: SANITY_FUNCTION_SYNC_TAG_INVALIDATE,
+            };
+            break;
     }
     if (!resourceJson) {
         throw new Error('Could not create function resource based on selections');

package/dist/baseCommands.d.ts

@@ -1,6 +1,6 @@
 import type { Interfaces } from '@oclif/core';
 import { Command } from '@oclif/core';
-import type { ReadBlueprintResult } from './actions/blueprints/blueprint.js';
+import { type ReadBlueprintResult } from './actions/blueprints/blueprint.js';
 import type { CoreResult } from './cores/index.js';
 import type { AuthParams, ScopeType, Stack } from './utils/types.js';
 export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof RuntimeCommand)['baseFlags'] & T['flags']>;
@@ -69,40 +69,70 @@ export declare abstract class RuntimeCommand<T extends typeof Command> extends C
     }): Promise<unknown>;
 }
 /**
- * Guarantees flags, args, sanityToken, and blueprint.
- * Blueprint parser errors are logged and the command exits with an error
+ * Context a command can declare it needs.
+ * The base class resolves each from the best available source during init().
+ * Dependencies are resolved implicitly -- declaring 'deployedStack' implies
+ * token, scope, and stackId without listing them.
+ *
+ * - token:         Authenticated API token
+ * - blueprint:     Parsed local blueprint file (filesystem)
+ * - scope:         scopeType + scopeId (from flags, env, config file, or blueprint)
+ * - stackId:       stackId (from flags, env, config file, blueprint, or inferred)
+ * - deployedStack: Remote Stack object fetched from the API (implies token, scope, stackId)
+ */
+export type Need = 'token' | 'blueprint' | 'scope' | 'stackId' | 'deployedStack';
+/**
+ * Base command that resolves context declaratively from a `static needs` array.
+ * Commands declare what they *directly use*; the base class resolves transitive
+ * dependencies automatically (e.g. 'deployedStack' implies token, scope, stackId).
+ *
+ * When a command needs only remote context (e.g. `['deployedStack']`),
+ * no local blueprint file is required -- flags and config are sufficient.
+ *
+ * @example
+ * ```ts
+ * class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
+ *   static needs = ['deployedStack'] as const
+ *   // token, scope, stackId resolved automatically
+ * }
+ * ```
+ *
  * @extends RuntimeCommand
  */
-export declare abstract class LocalBlueprintCommand<T extends typeof Command> extends RuntimeCommand<T> {
-    protected sanityToken: string;
-    protected blueprint: ReadBlueprintResult;
+export declare abstract class ResolvedCommand<T extends typeof Command> extends RuntimeCommand<T> {
+    static needs: readonly Need[];
     static baseFlags: {
+        stack: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'project-id': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'organization-id': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
         json: Interfaces.BooleanFlag<boolean>;
         path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
         trace: Interfaces.BooleanFlag<boolean>;
         'validate-resources': Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
     };
+    protected token: string;
+    protected blueprint: ReadBlueprintResult;
+    protected scopeType: ScopeType;
+    protected scopeId: string;
+    protected stackId: string;
+    protected auth: AuthParams;
+    protected deployedStack: Stack;
     init(): Promise<void>;
 }
 /**
- * Guarantees flags, args, sanityToken, blueprint, scopeType, scopeId, stackId, auth, and deployedStack.
- * If scope or stack is missing, the command exits with an error
+ * Guarantees token and blueprint.
+ * @extends ResolvedCommand
+ */
+export declare abstract class LocalBlueprintCommand<T extends typeof Command> extends ResolvedCommand<T> {
+    static needs: Need[];
+    /** @deprecated Use `this.token` instead. */
+    protected get sanityToken(): string;
+}
+/**
+ * Guarantees token, scope, stackId, deployedStack, and blueprint.
  * @extends LocalBlueprintCommand
  */
 export declare abstract class DeployedStackCommand<T extends typeof Command> extends LocalBlueprintCommand<T> {
-    protected auth: AuthParams;
-    protected deployedStack: Stack;
-    protected scopeType: ScopeType;
-    protected scopeId: string;
-    protected stackId: string;
-    static baseFlags: {
-        stack: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
-        json: Interfaces.BooleanFlag<boolean>;
-        path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
-        trace: Interfaces.BooleanFlag<boolean>;
-        'validate-resources': Interfaces.BooleanFlag<boolean>;
-        verbose: Interfaces.BooleanFlag<boolean>;
-    };
-    init(): Promise<void>;
+    static needs: Need[];
 }

package/dist/baseCommands.js

@@ -1,7 +1,13 @@
 // * https://oclif.io/docs/base_class
+import { env } from 'node:process';
 import { Command, CommandHelp, Flags as OclifFlags } from '@oclif/core';
-import { initBlueprintConfig, initDeployedBlueprintConfig } from './cores/index.js';
+import { findBlueprintFile, loadBlueprintFile, parseBlueprintContent, } from './actions/blueprints/blueprint.js';
+import { backfillProjectBasedStackId, readConfigFile } from './actions/blueprints/config.js';
+import { resolveIds } from './actions/blueprints/resolve.js';
+import { getStack, resolveStackIdByNameOrId } from './actions/blueprints/stacks.js';
+import { presentBlueprintParserErrors } from './utils/display/errors.js';
 import { Logger } from './utils/logger.js';
+import { validTokenOrErrorMessage } from './utils/validated-token.js';
 /**
  * Fallback error-to-hint patterns for RuntimeCommand.catch().
  * Each entry maps a regex to a function that returns suggestion strings.
@@ -155,69 +161,227 @@ export class RuntimeCommand extends Command {
     }
 }
 /**
- * Guarantees flags, args, sanityToken, and blueprint.
- * Blueprint parser errors are logged and the command exits with an error
+ * Base command that resolves context declaratively from a `static needs` array.
+ * Commands declare what they *directly use*; the base class resolves transitive
+ * dependencies automatically (e.g. 'deployedStack' implies token, scope, stackId).
+ *
+ * When a command needs only remote context (e.g. `['deployedStack']`),
+ * no local blueprint file is required -- flags and config are sufficient.
+ *
+ * @example
+ * ```ts
+ * class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
+ *   static needs = ['deployedStack'] as const
+ *   // token, scope, stackId resolved automatically
+ * }
+ * ```
+ *
  * @extends RuntimeCommand
  */
-export class LocalBlueprintCommand extends RuntimeCommand {
-    sanityToken;
+export class ResolvedCommand extends RuntimeCommand {
+    static needs = [];
+    static baseFlags = {
+        ...baseFlags,
+        stack: stackFlag,
+        'project-id': OclifFlags.string({ ...projectIdFlagConfig, hidden: true }),
+        'organization-id': OclifFlags.string({ ...organizationIdFlagConfig, hidden: true }),
+    };
+    // Populated by init() according to `needs`
+    token;
     blueprint;
-    static baseFlags = baseFlags;
+    scopeType;
+    scopeId;
+    stackId;
+    auth;
+    deployedStack;
     async init() {
-        await super.init();
-        const result = await initBlueprintConfig({
-            bin: this.config.bin,
-            log: Logger(this.log.bind(this), this.flags),
-            validateResources: this.flags['validate-resources'],
-            blueprintPath: this.flags.path,
+        await super.init(); // RuntimeCommand: parse flags + args
+        const needs = new Set(this.constructor.needs);
+        if (needs.size === 0)
+            return;
+        const log = Logger(this.log.bind(this), this.flags);
+        const needsToken = needs.has('token') || needs.has('scope') || needs.has('stackId') || needs.has('deployedStack');
+        const needsScope = needs.has('scope') || needs.has('deployedStack');
+        const needsStack = needs.has('stackId') || needs.has('deployedStack');
+        const needsBlueprint = needs.has('blueprint');
+        const needsDeployedStack = needs.has('deployedStack');
+        // 1. Token
+        if (needsToken) {
+            const check = await validTokenOrErrorMessage(log);
+            if (!check.ok) {
+                this.error(check.error.message, {
+                    suggestions: ['Run `npx @sanity/cli login` to authenticate.'],
+                });
+            }
+            this.token = check.value;
+        }
+        // 2. Gather ID sources
+        const flagIds = {
+            projectId: this.flags['project-id'],
+            organizationId: this.flags['organization-id'],
+        };
+        const envIds = {
+            organizationId: env.SANITY_ORGANIZATION_ID,
+            projectId: env.SANITY_PROJECT_ID,
+            stackId: env.SANITY_BLUEPRINT_STACK_ID,
+        };
+        // Try to read the config file (cheap single-file JSON read).
+        // Anchor to --path flag or the blueprint file location if found, else cwd.
+        const blueprintFileInfo = findBlueprintFile(this.flags.path);
+        const blueprintConfig = readConfigFile(blueprintFileInfo?.blueprintFilePath);
+        const configIds = blueprintConfig
+            ? {
+                organizationId: blueprintConfig.organizationId,
+                projectId: blueprintConfig.projectId,
+                stackId: blueprintConfig.stackId,
+            }
+            : undefined;
+        // 3. Blueprint (if needed)
+        let moduleIds;
+        if (needsBlueprint) {
+            if (!blueprintFileInfo) {
+                this.error('Could not find Blueprint file! Use the `blueprints init` command.', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints init\` to create one.`,
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            const loaded = await loadBlueprintFile(blueprintFileInfo);
+            const parsed = parseBlueprintContent(loaded.rawBlueprint, {
+                validateResources: this.flags['validate-resources'],
+            });
+            if (parsed.errors.length > 0) {
+                log(presentBlueprintParserErrors(parsed.errors));
+                this.error('Blueprint file contains errors.', {
+                    suggestions: [
+                        'Fix the Blueprint errors listed above.',
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            if (loaded.module) {
+                moduleIds = {
+                    organizationId: loaded.module.organizationId,
+                    projectId: loaded.module.projectId,
+                    stackId: loaded.module.stackId,
+                };
+            }
+            // Assemble the full ReadBlueprintResult -- will be completed with resolved IDs below
+            this.blueprint = {
+                fileInfo: blueprintFileInfo,
+                blueprintConfig,
+                rawBlueprint: loaded.rawBlueprint,
+                ...parsed,
+            };
+        }
+        // 4. Resolve IDs
+        const resolved = resolveIds({
+            flags: flagIds,
+            env: envIds,
+            module: moduleIds,
+            config: configIds,
         });
-        if (!result.ok) {
-            const suggestions = [];
-            if (/token|login/i.test(result.error)) {
-                suggestions.push('Run `npx @sanity/cli login` to authenticate.');
+        // Legacy stack ID inference (only when we have a blueprint file path for the write side-effect)
+        if (!resolved.stackId && resolved.projectId && blueprintFileInfo) {
+            try {
+                const inferred = await backfillProjectBasedStackId({
+                    blueprintFilePath: blueprintFileInfo.blueprintFilePath,
+                    projectId: resolved.projectId,
+                    logger: log,
+                });
+                if (inferred) {
+                    resolved.stackId = inferred;
+                    resolved.sources.stackId = 'inferred';
+                }
+            }
+            catch {
+                // assumption was wrong; leave stackId undefined
             }
-            else if (/blueprint/i.test(result.error) && /error/i.test(result.error)) {
-                suggestions.push('Fix the Blueprint errors listed above.');
+        }
+        // Backfill resolved IDs onto the blueprint result if it was loaded
+        if (this.blueprint) {
+            Object.assign(this.blueprint, {
+                organizationId: resolved.organizationId,
+                projectId: resolved.projectId,
+                stackId: resolved.stackId,
+                scopeType: resolved.scopeType,
+                scopeId: resolved.scopeId,
+                sources: resolved.sources,
+            });
+        }
+        // 5. Scope
+        if (needsScope) {
+            if (!resolved.scopeType || !resolved.scopeId) {
+                this.error('Missing scope: provide --project-id or --organization-id, or configure a Blueprint.', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
             }
-            suggestions.push(`Run \`${this.config.bin} blueprints doctor\` to check your configuration.`);
-            this.error(result.error, { suggestions });
+            this.scopeType = resolved.scopeType;
+            this.scopeId = resolved.scopeId;
+        }
+        // 6. Stack
+        if (needsStack) {
+            let { stackId } = resolved;
+            const stackOverride = this.flags.stack;
+            if (stackOverride) {
+                const auth = {
+                    token: this.token,
+                    scopeType: this.scopeType,
+                    scopeId: this.scopeId,
+                };
+                stackId = await resolveStackIdByNameOrId(stackOverride, auth, log);
+            }
+            if (!stackId) {
+                this.error('Missing Stack: provide --stack, or configure a Blueprint with a Stack.', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            this.stackId = stackId;
+        }
+        // 7. Auth
+        if (needsScope) {
+            this.auth = { token: this.token, scopeType: this.scopeType, scopeId: this.scopeId };
+        }
+        // 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 });
+            if (!response.ok) {
+                spinner.fail('Could not load Stack deployment');
+                this.error('Missing Stack deployment', {
+                    suggestions: [
+                        `Run \`${this.config.bin} blueprints doctor\` to check your configuration.`,
+                    ],
+                });
+            }
+            spinner.stop().clear();
+            this.deployedStack = response.stack;
         }
-        this.sanityToken = result.value.token;
-        this.blueprint = result.value.blueprint;
     }
 }
+// ---------------------------------------------------------------------------
+// Legacy base classes -- thin wrappers around ResolvedCommand
+// ---------------------------------------------------------------------------
 /**
- * Guarantees flags, args, sanityToken, blueprint, scopeType, scopeId, stackId, auth, and deployedStack.
- * If scope or stack is missing, the command exits with an error
+ * Guarantees token and blueprint.
+ * @extends ResolvedCommand
+ */
+export class LocalBlueprintCommand extends ResolvedCommand {
+    static needs = ['token', 'blueprint'];
+    /** @deprecated Use `this.token` instead. */
+    get sanityToken() {
+        return this.token;
+    }
+}
+/**
+ * Guarantees token, scope, stackId, deployedStack, and blueprint.
  * @extends LocalBlueprintCommand
  */
 export class DeployedStackCommand extends LocalBlueprintCommand {
-    auth;
-    deployedStack;
-    scopeType;
-    scopeId;
-    stackId;
-    static baseFlags = { ...baseFlags, stack: stackFlag };
-    async init() {
-        await super.init();
-        const result = await initDeployedBlueprintConfig({
-            bin: this.config.bin,
-            blueprint: this.blueprint,
-            log: Logger(this.log.bind(this), this.flags),
-            token: this.sanityToken,
-            validateToken: false,
-            validateResources: this.flags['validate-resources'],
-            stackOverride: this.flags.stack,
-        });
-        if (!result.ok) {
-            this.error(result.error, {
-                suggestions: [`Run \`${this.config.bin} blueprints doctor\` to check your configuration.`],
-            });
-        }
-        this.scopeType = result.value.scopeType;
-        this.scopeId = result.value.scopeId;
-        this.stackId = result.value.stackId;
-        this.auth = result.value.auth;
-        this.deployedStack = result.value.deployedStack;
-    }
+    static needs = ['deployedStack', 'blueprint'];
 }

package/dist/commands/blueprints/info.d.ts

@@ -1,10 +1,12 @@
-import { DeployedStackCommand } from '../../baseCommands.js';
-export default class InfoCommand extends DeployedStackCommand<typeof InfoCommand> {
+import { ResolvedCommand } from '../../baseCommands.js';
+export default class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
+    static needs: readonly ["deployedStack"];
     static summary: string;
     static description: string;
     static examples: string[];
     static flags: {
         stack: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/info.js

@@ -1,8 +1,9 @@
 import { Flags } from '@oclif/core';
-import { DeployedStackCommand } from '../../baseCommands.js';
+import { projectIdFlagConfig, ResolvedCommand } from '../../baseCommands.js';
 import { blueprintInfoCore } from '../../cores/blueprints/info.js';
 import { Logger } from '../../utils/logger.js';
-export default class InfoCommand extends DeployedStackCommand {
+export default class InfoCommand extends ResolvedCommand {
+    static needs = ['deployedStack'];
     static summary = 'Display the status and resources of the remote Stack deployment';
     static description = `Displays the current state and metadata of your remote Stack deployment, including deployed resources, status, and configuration.
 
@@ -12,12 +13,14 @@ Run 'blueprints stacks' to see all available Stacks in your project or organizat
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --stack <name-or-id>',
+        '<%= config.bin %> <%= command.id %> --project-id <id> --stack <name-or-id>',
     ];
     static flags = {
         stack: Flags.string({
-            description: 'Stack name or ID to use instead of the locally configured Stack',
+            description: 'Stack name or ID',
             aliases: ['id'],
         }),
+        'project-id': Flags.string({ ...projectIdFlagConfig }),
     };
     async run() {
         const result = await blueprintInfoCore({

package/dist/commands/functions/add.js

@@ -8,7 +8,7 @@ export default class AddCommand extends LocalBlueprintCommand {
     static summary = 'Add a Function to your Blueprint';
     static description = `Scaffolds a new Function in the functions/ folder and templates a resource for your Blueprint manifest.
 
-Functions are serverless handlers triggered by document events (create, update, delete, publish) or media library events.
+Functions are serverless handlers triggered by document, live content or media-library events (create, update, delete, publish).
 
 After adding, use 'functions dev' to test locally, then 'blueprints deploy' to publish.`;
     static examples = [