@sanity/runtime-cli 7.6.6 → 8.0.0

package/dist/commands/blueprints/info.js

@@ -5,13 +5,11 @@ export default class InfoCommand extends DeployedBlueprintCommand {
     static description = 'Show information about a Blueprint deployment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
-        // '<%= config.bin %> <%= command.id %> --id ST-a1b2c3',
+        '<%= config.bin %> <%= command.id %> --stack-id <stackId>',
     ];
     static flags = {
         id: Flags.string({
             description: 'Stack ID to show info for (defaults to current stack)',
-            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     async run() {

package/dist/commands/blueprints/init.js

@@ -7,10 +7,8 @@ export default class InitCommand extends Command {
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> [directory]',
         '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts>',
-        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId>',
-        // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
-        // '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-id <stackId>',
-        // '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-name <stackName>',
+        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-id <stackId>',
+        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --stack-name <stackName>',
     ];
     static args = {
         dir: Args.string({
@@ -35,13 +33,11 @@ export default class InitCommand extends Command {
             aliases: ['stack', 'stackId'],
             dependsOn: ['project-id'],
             exclusive: ['stack-name'],
-            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
         'stack-name': Flags.string({
             description: 'Name to use for a NEW Stack',
             aliases: ['name'],
             exclusive: ['stack-id'],
-            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     async run() {

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

@@ -1,10 +1,9 @@
 import { BlueprintCommand } from '../../baseCommands.js';
 export default class StacksCommand extends BlueprintCommand<typeof StacksCommand> {
-    static hidden: boolean;
     static description: string;
     static examples: string[];
     static flags: {
-        projectId: 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<void>;
 }

package/dist/commands/blueprints/stacks.js

@@ -2,17 +2,15 @@ import { Flags } from '@oclif/core';
 import { BlueprintCommand } from '../../baseCommands.js';
 import { blueprintStacksCore } from '../../cores/blueprints/stacks.js';
 export default class StacksCommand extends BlueprintCommand {
-    // LAUNCH LIMIT: 1 Stack per Project - hide stacks command
-    static hidden = true;
     static description = 'List all Blueprint stacks';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --projectId a1b2c3',
+        '<%= config.bin %> <%= command.id %> --project-id <projectId>',
     ];
     static flags = {
-        projectId: Flags.string({
+        'project-id': Flags.string({
             description: 'Project ID to show stacks for',
-            required: false,
+            aliases: ['projectId', 'project'],
         }),
     };
     async run() {

package/dist/cores/blueprints/add.js

@@ -1,9 +1,21 @@
 import { cwd } from 'node:process';
+import { highlight } from 'cardinal';
 import chalk from 'chalk';
-import highlight from 'color-json';
 import inquirer from 'inquirer';
 import { createFunctionResource } from '../../actions/blueprints/resources.js';
 import { validateFunctionName } from '../../utils/validate/resource.js';
+const FUNCTION_BLUEPRINT_RESOURCE_TEMPLATE = `
+  import {defineBlueprint, defineDocumentFunction} from '@sanity/blueprints'
+               // update imports ↑
+
+  export default defineBlueprint({
+    // ...
+    resources: [
+      // ...
+      defineDocumentFunction({name: '{{fnName}}'}), // ← add this line
+    ],
+  })
+`;
 export async function blueprintAddCore(options) {
     const { bin = 'sanity', log, blueprint, args, flags } = options;
     const { type: resourceType } = args;
@@ -89,17 +101,24 @@ export async function blueprintAddCore(options) {
         });
         log(`\nCreated function: ${filePath.replace(cwd(), '')}`);
         if (!resourceAdded) {
-            // print the resource JSON for manual addition
-            log('\nAdd this Function resource to your Blueprint:');
-            log(highlight(JSON.stringify(resource, null, 2), undefined, undefined, 2));
+            // print the resource definition for manual addition
+            log(`\n${chalk.bold('Add the Resource to your Blueprint:')}`);
+            switch (blueprint.fileInfo.extension) {
+                case '.ts':
+                    log(highlight(FUNCTION_BLUEPRINT_RESOURCE_TEMPLATE.replace('{{fnName}}', fnName)));
+                    break;
+                case '.js':
+                    log(highlight(FUNCTION_BLUEPRINT_RESOURCE_TEMPLATE.replace('{{fnName}}', fnName)));
+                    break;
+                default:
+                    log(highlight(JSON.stringify(resource, null, 2)));
+                    break;
+            }
         }
         else {
             // added to blueprint.json
             log(`Function "${chalk.bold(fnName)}" added to Blueprint file.`);
         }
-        if (fnLang === 'ts') {
-            log(chalk.dim('Add "functions/**/.build/**" to your .gitignore.'));
-        }
         return { success: true };
     }
     catch (err) {

package/dist/cores/blueprints/config.js

@@ -1,9 +1,9 @@
+import { highlight } from 'cardinal';
 import chalk from 'chalk';
-import highlight from 'color-json';
 import inquirer from 'inquirer';
 import ora from 'ora';
 import { BLUEPRINT_CONFIG_FILE, BLUEPRINT_DIR, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
-import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { createStack, getStack } from '../../actions/blueprints/stacks.js';
 import { getProject } from '../../actions/sanity/projects.js';
 import { niceId, warn } from '../../utils/display/presenters.js';
 import { promptForProject } from '../../utils/display/prompt.js';
@@ -67,7 +67,7 @@ export async function blueprintConfigCore(options) {
             // LAUNCH LIMIT: 1 Stack per Project - configStackId is always inferred from projectId if not set in config JSON
             let updatedStackId = flagStackId ?? // flag first
                 configStackId ?? // existing config second
-                `ST-${updatedProjectId}`; /*??*/ // LAUNCH LIMIT: 1 Stack per Project - project-based third
+                `ST-${updatedProjectId}`; //?? LAUNCH LIMIT: 1 Stack per Project - project-based third
             // (await promptForStackId({projectId: updatedProjectId, knownStackId: configStackId})) // prompt for stackId
             const isProjectBasedId = updatedStackId === `ST-${updatedProjectId}`;
             log(`\n${chalk.bold('New configuration:')}`);
@@ -135,31 +135,6 @@ export async function blueprintConfigCore(options) {
         return { success: false, error: 'Unknown error' };
     }
 }
-async function promptForStackId({ token, projectId, knownStackId, }) {
-    const auth = { token, projectId };
-    // get stacks for selected project
-    const { ok: stacksOk, stacks, error: stacksError } = await listStacks(auth);
-    if (!stacksOk)
-        throw new Error(stacksError ?? 'Unknown error listing stacks');
-    if (stacks.length > 0) {
-        const stackChoices = stacks.map((s) => ({
-            name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
-            value: s.id,
-        }));
-        stackChoices.push({ name: 'Unset Stack association', value: 'unset' });
-        const { pickedStackId } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'pickedStackId',
-                message: 'Select a stack:',
-                choices: stackChoices,
-                default: knownStackId,
-            },
-        ]);
-        return pickedStackId === 'unset' ? undefined : pickedStackId;
-    }
-    return undefined;
-}
 async function testConfigAndReport({ token, stackId, projectId, }) {
     const spinner = ora('Testing the configuration...').start();
     const { ok, error } = await getStack({

package/dist/cores/blueprints/init.js

@@ -2,18 +2,18 @@ import { join } from 'node:path';
 import { cwd } from 'node:process';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { BLUEPRINT_CONFIG_FILE, BLUEPRINT_DIR, findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
-import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { BLUEPRINT_CONFIG_FILE, BLUEPRINT_DIR, findBlueprintFile, writeBlueprintToDisk, writeConfigFile, writeGitignoreFile, writeOrUpdateNodeDependency, } from '../../actions/blueprints/blueprint.js';
+import { createEmptyStack, getStack } from '../../actions/blueprints/stacks.js';
 import { getProject } from '../../actions/sanity/projects.js';
-import { niceId } from '../../utils/display/presenters.js';
-import { promptForProject } from '../../utils/display/prompt.js';
+import { check, warn } from '../../utils/display/presenters.js';
+import { promptForProject, promptForStackId } from '../../utils/display/prompt.js';
 const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
 export async function blueprintInitCore(options) {
-    const { log, token, args, flags } = options;
+    const { bin = 'sanity', log, token, args, flags } = options;
     try {
         const { 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, dir: flagDir, } = flags;
         const { dir: argDir } = args;
-        const dirProvided = argDir || flagDir;
+        const providedDir = argDir || flagDir;
         const here = cwd();
         const dir = argDir || flagDir || here;
         const existingBlueprint = findBlueprintFile(dir);
@@ -30,6 +30,7 @@ export async function blueprintInitCore(options) {
             const pickedProject = await promptForProject({ token });
             projectId = pickedProject.projectId;
         }
+        log('');
         if (flagStackName) {
             // using --stack-name gets around "LAUNCH LIMIT: 1 Stack per Project"
             const stack = await createEmptyStack({
@@ -51,17 +52,40 @@ export async function blueprintInitCore(options) {
                 stackId = await promptForStackId({ projectId, token });
             }
         }
-        const fileName = `blueprint.${blueprintExtension}`;
+        const fileName = `sanity.blueprint.${blueprintExtension}`;
         const filePath = join(dir, fileName);
-        if (dirProvided)
-            log(`New Blueprint created:   ${dirProvided}/`);
-        writeBlueprintToDisk({ blueprintFilePath: filePath });
-        log(`Created new blueprint:   ${dirProvided ?? '.'}/${fileName}`);
+        writeBlueprintToDisk({
+            blueprintFilePath: filePath,
+            // content: {resources: [] /*projectId, stackId*/}, // TODO: in the future maybe set config in blueprint
+        });
+        if (providedDir)
+            log(check(`${chalk.bold('New folder created:')}  ${providedDir}/`));
+        log(check(`${chalk.bold('Created Blueprint:')}   ${providedDir ?? '.'}/${fileName}`));
         writeConfigFile({ blueprintFilePath: filePath, projectId, stackId });
-        log(`Created new config file: ${dirProvided ?? '.'}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`);
-        if (blueprintExtension === 'ts') {
-            log('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx');
+        log(check(`${chalk.bold('Added configuration:')} ${providedDir ?? '.'}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
+        writeGitignoreFile({ blueprintFilePath: filePath });
+        log(check(`${chalk.bold('Added .gitignore:')}    ${providedDir ?? '.'}/.gitignore`));
+        if (blueprintExtension !== 'json') {
+            try {
+                // check for || create package.json and add @sanity/blueprints to dependencies
+                await writeOrUpdateNodeDependency({
+                    blueprintFilePath: filePath,
+                    dependency: '@sanity/blueprints',
+                });
+                log(check(`${chalk.bold('Added dependency:')}    @sanity/blueprints`));
+            }
+            catch (err) {
+                log(warn('Unable to add @sanity/blueprints to your project.'));
+            }
         }
+        const nextStepParts = [];
+        if (providedDir)
+            nextStepParts.push(`cd ./${providedDir}`);
+        if (blueprintExtension !== 'json')
+            nextStepParts.push('npm install');
+        nextStepParts.push(`${bin} blueprints --help`);
+        const nextStep = `Run \`${nextStepParts.join(' && ')}\``;
+        log(`\n  ${chalk.dim(nextStep)} to get started`);
         return { success: true };
     }
     catch (error) {
@@ -75,72 +99,17 @@ async function promptForBlueprintType() {
         {
             type: 'list',
             name: 'pickedBlueprintsType',
-            message: 'Choose a blueprint type:',
+            message: 'Choose a Blueprint file type:',
             choices: [
+                { name: 'TypeScript', value: 'ts' },
+                { name: 'JavaScript', value: 'js' },
                 { name: 'JSON', value: 'json' },
-                { name: 'TypeScript', value: 'ts', disabled: '(Coming soon)' },
-                { name: 'JavaScript', value: 'js', disabled: '(Coming soon)' },
             ],
-            default: 'json',
+            default: 'ts',
         },
     ]);
     return pickedBlueprintsType;
 }
-async function promptForStackId({ projectId, token, }) {
-    const { ok: stacksOk, error: stacksErr, stacks } = await listStacks({ token, projectId });
-    if (!stacksOk) {
-        throw new Error(stacksErr || 'Failed to list Stacks');
-    }
-    const stackChoices = [
-        { name: chalk.bold('✨ Create a new Stack'), value: 'new' },
-    ];
-    if (stacks.length > 0) {
-        stackChoices.push(new inquirer.Separator(chalk.underline('Use an existing Stack:')));
-        stackChoices.push(...stacks.map((s) => ({
-            name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
-            value: s.id,
-        })));
-    }
-    const { pickedStackId } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'pickedStackId',
-            message: 'Select an existing deployment or create a new one:',
-            choices: stackChoices,
-        },
-    ]);
-    if (pickedStackId === 'new') {
-        const { stackName } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'stackName',
-                message: 'Enter a name for your Stack:',
-                validate: (input) => input.length > 0 || 'Stack name is required',
-            },
-        ]);
-        const stack = await createEmptyStack({
-            token,
-            projectId,
-            name: stackName,
-        });
-        return stack.id;
-    }
-    return pickedStackId;
-}
-async function createEmptyStack({ token, projectId, name, projectBased = true, }) {
-    const stackPayload = {
-        name,
-        projectId,
-        useProjectBasedId: projectBased,
-        document: { resources: [] },
-    };
-    const auth = { token, projectId };
-    const response = await createStack({ stackPayload, auth });
-    if (!response.ok) {
-        throw new Error(response.error || 'Failed to create new Stack');
-    }
-    return response.stack;
-}
 // LAUNCH LIMIT: 1 Stack per Project - create exclusive stack for project
 async function createProjectBasedStack(auth, token, log) {
     const { projectId } = auth;
@@ -155,8 +124,9 @@ async function createProjectBasedStack(auth, token, log) {
     const { stack: existingStack, ok: stackOk } = await getStack({ stackId: inferredStackId, auth });
     // if existing stack, return stack
     if (stackOk && existingStack) {
-        log(chalk.red(`Found existing deployment for "${projectDisplayName}" Blueprint`));
-        log(chalk.red('Deploying an empty Blueprint will override the existing deployment.'));
+        log(warn(`"${projectDisplayName}" has an existing deployment.`));
+        log(warn(`Deploying an empty Blueprint ${chalk.bold.red('will override the existing deployment!')}`));
+        log('');
         return existingStack;
     }
     // if not, create a stack

package/dist/cores/blueprints/plan.js

@@ -1,10 +1,10 @@
 import chalk from 'chalk';
 import { getStack } from '../../actions/blueprints/stacks.js';
-import { formatResourceTree, formatTitle, stackDeployDiff, } from '../../utils/display/blueprints-formatting.js';
+import { formatResourceTree, stackDeployDiff } from '../../utils/display/blueprints-formatting.js';
 export async function blueprintPlanCore(options) {
     const { bin = 'sanity', log, blueprint, token } = options;
     const { projectId, stackId, parsedBlueprint, fileInfo } = blueprint;
-    log(`${formatTitle('Deployment', 'Plan')} ${chalk.dim(`(${fileInfo.fileName})`)}`);
+    log(`${chalk.bold.blueBright('Blueprint Deployment Plan')} ${chalk.dim(`(${fileInfo.fileName})`)}`);
     log(formatResourceTree(parsedBlueprint.resources));
     if (token && projectId && stackId) {
         const stackResponse = await getStack({ stackId, auth: { token, projectId } });
@@ -19,6 +19,6 @@ export async function blueprintPlanCore(options) {
                 log(chalk.dim('No changes detected to live deployment'));
         }
     }
-    log(chalk.dim(`Run ${bin} blueprints deploy to deploy these changes`));
+    log(chalk.dim(`Run "${bin} blueprints deploy" to deploy these changes`));
     return { success: true };
 }

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

@@ -4,7 +4,7 @@ export interface BlueprintStacksOptions extends CoreConfig {
     token: string;
     blueprint: ReadBlueprintResult;
     flags: {
-        projectId?: string;
+        'project-id'?: string;
     };
 }
 export declare function blueprintStacksCore(options: BlueprintStacksOptions): Promise<CoreResult>;

package/dist/cores/blueprints/stacks.js

@@ -5,9 +5,9 @@ import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintStacksCore(options) {
     const { log, token, blueprint, flags } = options;
     const { projectId: blueprintProjectId, stackId: blueprintStackId } = blueprint;
-    const projectId = flags.projectId || blueprintProjectId;
+    const projectId = flags['project-id'] || blueprintProjectId;
     if (!projectId) {
-        log('Run in a Blueprint directory or provide a Project with --projectId');
+        log('Run in a Blueprint directory or provide a Project with --project-id');
         return { success: false, error: 'No Project ID provided' };
     }
     try {

package/dist/utils/display/blueprints-formatting.js

@@ -9,7 +9,7 @@ export function formatTitle(title, name) {
 export function formatResourceTree(resources) {
     if (!resources || resources.length === 0)
         return '  Zero resources';
-    const output = [`${chalk.blue('Blueprint Resources')} [${resources.length}]`];
+    const output = [`${chalk.bold.underline('Resources')} [${resources.length}]`];
     const functionResources = resources.filter((r) => r.type?.startsWith('sanity.function.'));
     const otherResources = resources.filter((r) => !r.type?.startsWith('sanity.function.'));
     const hasOtherResources = otherResources.length > 0;
@@ -17,12 +17,12 @@ export function formatResourceTree(resources) {
         const fnsOutput = [`${chalk.bold('Functions')} [${functionResources.length}]`];
         const fnDetails = [];
         for (const fn of functionResources) {
-            const name = chalk.green(fn.displayName || fn.name);
+            const name = chalk.bold.green(fn.displayName || fn.name);
             const ids = [
                 'id' in fn && fn.id ? `${niceId(fn.id)}` : '',
                 'externalId' in fn && fn.externalId ? `<${niceId(fn.externalId)}>` : '',
             ].join(' ');
-            fnDetails.push(`"${name}" ${ids}`);
+            fnDetails.push(`${name} ${ids}`);
             if ('parameters' in fn && fn.parameters) {
                 fnDetails.push(arrayifyStackFunction(fn));
             }

package/dist/utils/display/presenters.d.ts

@@ -1,3 +1,4 @@
+export declare function check(str: string): string;
 export declare function info(str: string): string;
 export declare function warn(str: string): string;
 export declare function severe(str: string): string;

package/dist/utils/display/presenters.js

@@ -1,12 +1,15 @@
 import chalk from 'chalk';
+export function check(str) {
+    return `${chalk.bold(chalk.green('✔︎'))} ${str}`;
+}
 export function info(str) {
-    return `${chalk.blue('❯')} ${str}`;
+    return `${chalk.bold.blue('ℹ︎')} ${str}`;
 }
 export function warn(str) {
-    return `${chalk.yellow('❯')} ${str}`;
+    return `${chalk.bold.yellow('▶︎')} ${str}`;
 }
 export function severe(str) {
-    return `${chalk.red('❯')} ${str}`;
+    return `${chalk.bold.red('✘')} ${str}`;
 }
 export function niceId(id) {
     if (!id)

package/dist/utils/display/prompt.d.ts

@@ -12,3 +12,7 @@ export declare function promptForProject({ token, knownOrganizationId, knownProj
     projectId: string;
     displayName: string;
 }>;
+export declare function promptForStackId({ projectId, token, }: {
+    projectId: string;
+    token: string;
+}): Promise<string>;

package/dist/utils/display/prompt.js

@@ -1,4 +1,6 @@
+import chalk from 'chalk';
 import inquirer from 'inquirer';
+import { createEmptyStack, listStacks } from '../../actions/blueprints/stacks.js';
 import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
 import { niceId } from './presenters.js';
 /**
@@ -44,10 +46,51 @@ export async function promptForProject({ token, knownOrganizationId, knownProjec
         {
             type: 'list',
             name: 'pickedProject',
-            message: 'Which Project would you like to use?',
+            message: 'Choose a Sanity Project:',
             choices: projectChoices,
             default: knownProjectId,
         },
     ]);
     return pickedProject;
 }
+export async function promptForStackId({ projectId, token, }) {
+    const { ok: stacksOk, error: stacksErr, stacks } = await listStacks({ token, projectId });
+    if (!stacksOk) {
+        throw new Error(stacksErr || 'Failed to list Stacks');
+    }
+    const stackChoices = [
+        { name: chalk.bold('✨ Create a new Stack'), value: 'new' },
+    ];
+    if (stacks.length > 0) {
+        stackChoices.push(new inquirer.Separator(chalk.underline('Use an existing Stack:')));
+        stackChoices.push(...stacks.map((s) => ({
+            name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
+            value: s.id,
+        })));
+    }
+    const { pickedStackId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'pickedStackId',
+            message: 'Select an existing deployment or create a new one:',
+            choices: stackChoices,
+        },
+    ]);
+    if (pickedStackId === 'new') {
+        const { stackName } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'stackName',
+                message: 'Enter a name for your Stack:',
+                validate: (input) => input.length > 0 || 'Stack name is required',
+            },
+        ]);
+        const stack = await createEmptyStack({
+            token,
+            projectId,
+            name: stackName,
+        });
+        return stack.id;
+    }
+    return pickedStackId;
+}

package/dist/utils/invoke-local.js

@@ -47,6 +47,8 @@ export async function applyGroqRule(resource, data) {
             throw Error('⚠️ failed parsing/evaluating GROQ rule! Skipping invoke.');
         }
     }
+    // default groq rule so just return the data
+    return data;
 }
 export default async function invoke(resource, data, context, options) {
     if (!resource.src) {

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

@@ -0,0 +1 @@
+export declare function getLatestNpmVersion(pkg: string): Promise<string>;

package/dist/utils/other/npmjs.js

@@ -0,0 +1,13 @@
+export async function getLatestNpmVersion(pkg) {
+    const url = `https://registry.npmjs.org/${pkg}/latest`;
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`Failed to fetch version for ${pkg}`);
+        const data = await res.json();
+        return data.version;
+    }
+    catch (error) {
+        return 'latest';
+    }
+}

package/dist/utils/types.d.ts

@@ -141,7 +141,7 @@ export interface InvokeExecutionOptions {
 /** @internal */
 export interface InvocationResponse {
     error: undefined | unknown;
-    json: object | undefined;
+    json: Record<string, unknown> | undefined;
     logs: string | undefined;
     timings?: Record<string, number>;
 }