@basis-theory-labs/cli 2.0.0 → 3.0.0

package/dist/reactors/runtime.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateReactorApplicationId = exports.validateReactorRuntimeFlags = void 0;
+const runtime_1 = require("../runtime");
+const validateReactorRuntimeFlags = (flags, image) => {
+    const setFlags = [];
+    for (const flag of runtime_1.CONFIGURABLE_RUNTIME_FLAGS) {
+        const value = flags[flag];
+        const isSet = value !== undefined &&
+            value !== false &&
+            !(Array.isArray(value) && value.length === 0);
+        if (isSet) {
+            setFlags.push(flag);
+        }
+    }
+    if (setFlags.length && (0, runtime_1.isLegacyRuntimeImage)(image)) {
+        const flagNames = setFlags.map((f) => `--${f}`).join(', ');
+        throw new Error(`Configurable runtime flags (${flagNames}) require --image ${runtime_1.CONFIGURABLE_RUNTIME_IMAGES.join(' | ')}`);
+    }
+};
+exports.validateReactorRuntimeFlags = validateReactorRuntimeFlags;
+const validateReactorApplicationId = (applicationId, image) => {
+    if (applicationId && !(0, runtime_1.isLegacyRuntimeImage)(image)) {
+        throw new Error(`--application-id is not allowed with configurable runtimes (${runtime_1.CONFIGURABLE_RUNTIME_IMAGES.join(' | ')}). Use --permissions to grant specific access instead.`);
+    }
+};
+exports.validateReactorApplicationId = validateReactorApplicationId;

package/dist/reactors/utils.d.ts

@@ -1,5 +1,12 @@
 import type { BasisTheory } from '@basis-theory/node-sdk';
 declare const REACTOR_FLAGS: {
+    image: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    'package-json': import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    timeout: import("@oclif/core/lib/interfaces/parser").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    'warm-concurrency': import("@oclif/core/lib/interfaces/parser").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    resources: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    permissions: import("@oclif/core/lib/interfaces/parser").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    async: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
     name: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     configuration: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     'application-id': import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
@@ -18,9 +25,13 @@ interface ReactorFlagProps {
      * Path to .env file
      */
     configuration?: string;
+    /**
+     * Runtime configuration
+     */
+    runtime?: BasisTheory.Runtime;
 }
-type CreateReactor = ReactorFlagProps & Omit<BasisTheory.CreateReactorRequest, 'application' | 'configuration'>;
-type PatchReactor = ReactorFlagProps & Omit<BasisTheory.PatchReactorRequest, 'application' | 'configuration'>;
+type CreateReactor = ReactorFlagProps & Omit<BasisTheory.CreateReactorRequest, 'application' | 'configuration' | 'runtime'>;
+type PatchReactor = ReactorFlagProps & Omit<BasisTheory.PatchReactorRequest, 'application' | 'configuration' | 'runtime'>;
 declare function createModelFromFlags(payload: CreateReactor): BasisTheory.CreateReactorRequest;
 declare function createModelFromFlags(payload: PatchReactor): BasisTheory.PatchReactorRequest;
 export { REACTOR_FLAGS, createModelFromFlags };

package/dist/reactors/utils.js

@@ -4,6 +4,7 @@ exports.createModelFromFlags = exports.REACTOR_FLAGS = void 0;
 const core_1 = require("@oclif/core");
 const dotenv_1 = require("dotenv");
 const files_1 = require("../files");
+const runtime_1 = require("../runtime");
 const REACTOR_FLAGS = {
     name: core_1.Flags.string({
         char: 'n',
@@ -21,10 +22,11 @@ const REACTOR_FLAGS = {
         char: 'r',
         description: 'path to JavaScript file containing the Reactor code',
     }),
+    ...runtime_1.RUNTIME_FLAGS,
 };
 exports.REACTOR_FLAGS = REACTOR_FLAGS;
 // eslint-disable-next-line get-off-my-lawn/prefer-arrow-functions
-function createModelFromFlags({ name, applicationId, code, configuration, }) {
+function createModelFromFlags({ name, applicationId, code, configuration, runtime, }) {
     return {
         name,
         code: code ? (0, files_1.readFileContents)(code) : undefined,
@@ -32,6 +34,7 @@ function createModelFromFlags({ name, applicationId, code, configuration, }) {
         configuration: configuration
             ? (0, dotenv_1.parse)((0, files_1.readFileContents)(configuration))
             : undefined,
+        runtime,
     };
 }
 exports.createModelFromFlags = createModelFromFlags;

package/dist/runtime/flags.d.ts

@@ -0,0 +1,10 @@
+declare const RUNTIME_FLAGS: {
+    image: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    'package-json': import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    timeout: import("@oclif/core/lib/interfaces/parser").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    'warm-concurrency': import("@oclif/core/lib/interfaces/parser").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    resources: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    permissions: import("@oclif/core/lib/interfaces/parser").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    async: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+};
+export { RUNTIME_FLAGS };

package/dist/runtime/flags.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_FLAGS = void 0;
+const core_1 = require("@oclif/core");
+const utils_1 = require("./utils");
+const RUNTIME_FLAGS = {
+    image: core_1.Flags.string({
+        description: `runtime image (${utils_1.VALID_RUNTIME_IMAGES.join('|')})`,
+        options: [...utils_1.VALID_RUNTIME_IMAGES],
+    }),
+    'package-json': core_1.Flags.file({
+        description: 'path to runtime package.json JSON file (top-level dependencies required; supports resolutions or overrides fallback; pinned versions required) (node22 only)',
+    }),
+    timeout: core_1.Flags.integer({
+        description: 'timeout in seconds, 1-30 (node22 only, default: 10)',
+        min: 1,
+        max: 30,
+    }),
+    'warm-concurrency': core_1.Flags.integer({
+        description: 'number of warm instances, 0-1 (node22 only, default: 0)',
+        min: 0,
+        max: 1,
+    }),
+    resources: core_1.Flags.string({
+        description: 'resource tier (node22 only, default: standard)',
+        options: ['standard', 'large', 'xlarge'],
+    }),
+    permissions: core_1.Flags.string({
+        description: 'permission to grant, repeatable (node22 only)',
+        multiple: true,
+    }),
+    async: core_1.Flags.boolean({
+        description: 'do not wait for resource to be ready (node22 only)',
+        default: false,
+    }),
+};
+exports.RUNTIME_FLAGS = RUNTIME_FLAGS;

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { LEGACY_RUNTIME_IMAGE, CONFIGURABLE_RUNTIME_IMAGES, VALID_RUNTIME_IMAGES, CONFIGURABLE_RUNTIME_FLAGS, isLegacyRuntimeImage, validateRuntimeImage, parseRuntimePackageJsonFile, buildRuntime, promptRuntimeOptions, promptRuntimeImage, type ConfigurableRuntimeOptions, type RuntimeFlagProps, type RuntimeFlags, } from './utils';
+export { RUNTIME_FLAGS } from './flags';
+export { waitForResourceState, needsPolling, POLL_INTERVAL, POLL_TIMEOUT, } from './state';

package/dist/runtime/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLL_TIMEOUT = exports.POLL_INTERVAL = exports.needsPolling = exports.waitForResourceState = exports.RUNTIME_FLAGS = exports.promptRuntimeImage = exports.promptRuntimeOptions = exports.buildRuntime = exports.parseRuntimePackageJsonFile = exports.validateRuntimeImage = exports.isLegacyRuntimeImage = exports.CONFIGURABLE_RUNTIME_FLAGS = exports.VALID_RUNTIME_IMAGES = exports.CONFIGURABLE_RUNTIME_IMAGES = exports.LEGACY_RUNTIME_IMAGE = void 0;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "LEGACY_RUNTIME_IMAGE", { enumerable: true, get: function () { return utils_1.LEGACY_RUNTIME_IMAGE; } });
+Object.defineProperty(exports, "CONFIGURABLE_RUNTIME_IMAGES", { enumerable: true, get: function () { return utils_1.CONFIGURABLE_RUNTIME_IMAGES; } });
+Object.defineProperty(exports, "VALID_RUNTIME_IMAGES", { enumerable: true, get: function () { return utils_1.VALID_RUNTIME_IMAGES; } });
+Object.defineProperty(exports, "CONFIGURABLE_RUNTIME_FLAGS", { enumerable: true, get: function () { return utils_1.CONFIGURABLE_RUNTIME_FLAGS; } });
+Object.defineProperty(exports, "isLegacyRuntimeImage", { enumerable: true, get: function () { return utils_1.isLegacyRuntimeImage; } });
+Object.defineProperty(exports, "validateRuntimeImage", { enumerable: true, get: function () { return utils_1.validateRuntimeImage; } });
+Object.defineProperty(exports, "parseRuntimePackageJsonFile", { enumerable: true, get: function () { return utils_1.parseRuntimePackageJsonFile; } });
+Object.defineProperty(exports, "buildRuntime", { enumerable: true, get: function () { return utils_1.buildRuntime; } });
+Object.defineProperty(exports, "promptRuntimeOptions", { enumerable: true, get: function () { return utils_1.promptRuntimeOptions; } });
+Object.defineProperty(exports, "promptRuntimeImage", { enumerable: true, get: function () { return utils_1.promptRuntimeImage; } });
+var flags_1 = require("./flags");
+Object.defineProperty(exports, "RUNTIME_FLAGS", { enumerable: true, get: function () { return flags_1.RUNTIME_FLAGS; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "waitForResourceState", { enumerable: true, get: function () { return state_1.waitForResourceState; } });
+Object.defineProperty(exports, "needsPolling", { enumerable: true, get: function () { return state_1.needsPolling; } });
+Object.defineProperty(exports, "POLL_INTERVAL", { enumerable: true, get: function () { return state_1.POLL_INTERVAL; } });
+Object.defineProperty(exports, "POLL_TIMEOUT", { enumerable: true, get: function () { return state_1.POLL_TIMEOUT; } });

package/dist/runtime/state.d.ts

@@ -0,0 +1,6 @@
+import type { BasisTheoryClient } from '@basis-theory/node-sdk';
+declare const POLL_INTERVAL = 2000;
+declare const POLL_TIMEOUT = 600000;
+declare const needsPolling: (state: string | undefined) => boolean;
+declare const waitForResourceState: (bt: BasisTheoryClient, resourceType: 'reactor' | 'proxy', id: string, initialState?: string) => Promise<void>;
+export { waitForResourceState, needsPolling, POLL_INTERVAL, POLL_TIMEOUT };

package/dist/runtime/state.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLL_TIMEOUT = exports.POLL_INTERVAL = exports.needsPolling = exports.waitForResourceState = void 0;
+const core_1 = require("@oclif/core");
+const POLL_INTERVAL = 2000; // 2 seconds
+exports.POLL_INTERVAL = POLL_INTERVAL;
+const POLL_TIMEOUT = 600000; // 10 minutes
+exports.POLL_TIMEOUT = POLL_TIMEOUT;
+const formatErrorDetails = (value) => {
+    if (typeof value === 'string') {
+        try {
+            return JSON.stringify(JSON.parse(value), undefined, 2);
+        }
+        catch {
+            return value;
+        }
+    }
+    if (typeof value === 'object' && Boolean(value)) {
+        try {
+            return JSON.stringify(value, undefined, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+};
+const formatErrorMessage = (resource, resourceType) => {
+    const { state, requested } = resource;
+    const resourceName = resourceType === 'reactor' ? 'Reactor' : 'Proxy';
+    const parts = [`${resourceName} reached ${state} state`];
+    if (requested === null || requested === void 0 ? void 0 : requested.errorCode) {
+        parts.push(`errorCode: ${requested.errorCode}`);
+    }
+    if (requested === null || requested === void 0 ? void 0 : requested.errorMessage) {
+        parts.push(`errorMessage: ${requested.errorMessage}`);
+    }
+    if (requested === null || requested === void 0 ? void 0 : requested.errorDetails) {
+        parts.push(`errorDetails: ${formatErrorDetails(requested.errorDetails)}`);
+    }
+    return parts.join('\n');
+};
+const needsPolling = (state) => state === 'creating' || state === 'updating';
+exports.needsPolling = needsPolling;
+const formatElapsedTime = (startTime) => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const minutes = Math.floor(elapsed / 60);
+    const seconds = elapsed % 60;
+    if (minutes > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${seconds}s`;
+};
+const createTimer = (startTime, getState) => setInterval(() => {
+    const state = getState();
+    if (state) {
+        core_1.ux.action.status = `${state} (${formatElapsedTime(startTime)})`;
+    }
+}, 1000);
+const waitForResourceState = async (bt, resourceType, id, initialState) => {
+    // If initial state is provided and doesn't need polling, return immediately
+    if (initialState !== undefined && !needsPolling(initialState)) {
+        return;
+    }
+    const deadline = Date.now() + POLL_TIMEOUT;
+    const startTime = Date.now();
+    let currentState;
+    const timer = createTimer(startTime, () => currentState);
+    core_1.ux.action.start('Status');
+    /* eslint-disable no-await-in-loop */
+    try {
+        while (Date.now() < deadline) {
+            let resource;
+            try {
+                resource = await (resourceType === 'reactor'
+                    ? bt.reactors.get(id)
+                    : bt.proxies.get(id));
+            }
+            catch (error) {
+                core_1.ux.action.stop(`error (${formatElapsedTime(startTime)})`);
+                throw new Error(`Failed to check ${resourceType} state: ${error.message}`);
+            }
+            currentState = resource.state;
+            core_1.ux.action.status = `${currentState} (${formatElapsedTime(startTime)})`;
+            if (currentState === 'active') {
+                core_1.ux.action.stop(`ready (${formatElapsedTime(startTime)})`);
+                return;
+            }
+            if (currentState === 'failed' || currentState === 'outdated') {
+                core_1.ux.action.stop(`failed (${formatElapsedTime(startTime)})`);
+                throw new Error(formatErrorMessage(resource, resourceType));
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, POLL_INTERVAL);
+            });
+        }
+        core_1.ux.action.stop(`timeout (${formatElapsedTime(startTime)})`);
+        throw new Error(`Timeout waiting for ${resourceType} to reach final state`);
+    }
+    finally {
+        clearInterval(timer);
+    }
+    /* eslint-enable no-await-in-loop */
+};
+exports.waitForResourceState = waitForResourceState;

package/dist/runtime/utils.d.ts

@@ -0,0 +1,39 @@
+import type { BasisTheory } from '@basis-theory/node-sdk';
+declare const LEGACY_RUNTIME_IMAGE = "node-bt";
+declare const CONFIGURABLE_RUNTIME_IMAGES: readonly ["node22"];
+declare const VALID_RUNTIME_IMAGES: readonly ["node-bt", "node22"];
+declare const isLegacyRuntimeImage: (image: string | undefined) => boolean;
+declare const validateRuntimeImage: (image: string | undefined) => void;
+declare const CONFIGURABLE_RUNTIME_FLAGS: readonly ["timeout", "resources", "warm-concurrency", "permissions", "package-json"];
+interface RuntimeFlagProps {
+    image?: string;
+    packageJson?: string;
+    timeout?: number;
+    warmConcurrency?: number;
+    resources?: string;
+    permissions?: string[];
+}
+interface RuntimeFlags {
+    image?: string;
+    timeout?: number;
+    'warm-concurrency'?: number;
+    resources?: string;
+    'package-json'?: string;
+    permissions?: string[];
+}
+interface ConfigurableRuntimeOptions {
+    timeout?: number;
+    warmConcurrency?: number;
+    resources?: string;
+    packageJson?: string;
+    permissions?: string[];
+}
+interface ParsedRuntimePackageFile {
+    dependencies: Record<string, string>;
+    resolutions?: Record<string, string>;
+}
+declare const parseRuntimePackageJsonFile: (packageJsonPath: string) => ParsedRuntimePackageFile;
+declare const buildRuntime: (props: RuntimeFlagProps) => BasisTheory.Runtime | undefined;
+declare const promptRuntimeOptions: (flags: RuntimeFlags, labelPrefix?: string) => Promise<ConfigurableRuntimeOptions>;
+declare const promptRuntimeImage: (image: string | undefined, message?: string) => Promise<string>;
+export { LEGACY_RUNTIME_IMAGE, CONFIGURABLE_RUNTIME_IMAGES, VALID_RUNTIME_IMAGES, CONFIGURABLE_RUNTIME_FLAGS, isLegacyRuntimeImage, validateRuntimeImage, parseRuntimePackageJsonFile, buildRuntime, promptRuntimeOptions, promptRuntimeImage, type RuntimeFlagProps, type RuntimeFlags, type ConfigurableRuntimeOptions, };

package/dist/runtime/utils.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptRuntimeImage = exports.promptRuntimeOptions = exports.buildRuntime = exports.parseRuntimePackageJsonFile = exports.validateRuntimeImage = exports.isLegacyRuntimeImage = exports.CONFIGURABLE_RUNTIME_FLAGS = exports.VALID_RUNTIME_IMAGES = exports.CONFIGURABLE_RUNTIME_IMAGES = exports.LEGACY_RUNTIME_IMAGE = void 0;
+const files_1 = require("../files");
+const utils_1 = require("../utils");
+const LEGACY_RUNTIME_IMAGE = 'node-bt';
+exports.LEGACY_RUNTIME_IMAGE = LEGACY_RUNTIME_IMAGE;
+const CONFIGURABLE_RUNTIME_IMAGES = ['node22'];
+exports.CONFIGURABLE_RUNTIME_IMAGES = CONFIGURABLE_RUNTIME_IMAGES;
+const VALID_RUNTIME_IMAGES = [
+    LEGACY_RUNTIME_IMAGE,
+    ...CONFIGURABLE_RUNTIME_IMAGES,
+];
+exports.VALID_RUNTIME_IMAGES = VALID_RUNTIME_IMAGES;
+const isLegacyRuntimeImage = (image) => image === undefined || image === LEGACY_RUNTIME_IMAGE;
+exports.isLegacyRuntimeImage = isLegacyRuntimeImage;
+const validateRuntimeImage = (image) => {
+    if (image === undefined) {
+        return;
+    }
+    if (!VALID_RUNTIME_IMAGES.includes(image)) {
+        throw new Error(`Invalid runtime image "${image}". Valid options: ${VALID_RUNTIME_IMAGES.join(', ')}`);
+    }
+};
+exports.validateRuntimeImage = validateRuntimeImage;
+const CONFIGURABLE_RUNTIME_FLAGS = [
+    'timeout',
+    'resources',
+    'warm-concurrency',
+    'permissions',
+    'package-json',
+];
+exports.CONFIGURABLE_RUNTIME_FLAGS = CONFIGURABLE_RUNTIME_FLAGS;
+const isStringRecord = (value) => typeof value === 'object' &&
+    Boolean(value) &&
+    !Array.isArray(value) &&
+    Object.values(value).every((item) => typeof item === 'string');
+const parseRuntimePackageJsonFile = (packageJsonPath) => {
+    let parsedFile;
+    try {
+        parsedFile = JSON.parse((0, files_1.readFileContents)(packageJsonPath));
+    }
+    catch (error) {
+        throw new Error(`Failed to parse package.json file "${packageJsonPath}": ${error.message}`);
+    }
+    if (!parsedFile ||
+        typeof parsedFile !== 'object' ||
+        Array.isArray(parsedFile)) {
+        throw new Error(`Runtime package file "${packageJsonPath}" must include a top-level "dependencies" object.`);
+    }
+    const file = parsedFile;
+    const dependencies = file.dependencies;
+    if (!isStringRecord(dependencies)) {
+        throw new Error(`Runtime package file "${packageJsonPath}" has invalid "dependencies": expected an object of package names to pinned version strings.`);
+    }
+    let resolutions;
+    if (file.resolutions !== undefined) {
+        if (!isStringRecord(file.resolutions)) {
+            throw new Error(`Runtime package file "${packageJsonPath}" has invalid "resolutions": expected an object of package names to pinned version strings.`);
+        }
+        resolutions = file.resolutions;
+    }
+    else if (file.overrides !== undefined) {
+        if (!isStringRecord(file.overrides)) {
+            throw new Error(`Runtime package file "${packageJsonPath}" has unsupported "overrides" values for runtime resolutions; only string values are supported.`);
+        }
+        resolutions = file.overrides;
+    }
+    return {
+        dependencies,
+        resolutions,
+    };
+};
+exports.parseRuntimePackageJsonFile = parseRuntimePackageJsonFile;
+const buildRuntime = (props) => {
+    const { image, packageJson, timeout, warmConcurrency, resources, permissions, } = props;
+    if (!image &&
+        !packageJson &&
+        !timeout &&
+        !warmConcurrency &&
+        !resources &&
+        !(permissions === null || permissions === void 0 ? void 0 : permissions.length)) {
+        return undefined;
+    }
+    let parsedPackageFile;
+    if (packageJson) {
+        parsedPackageFile = parseRuntimePackageJsonFile(packageJson);
+    }
+    const runtime = {};
+    if (image) {
+        runtime.image = image;
+    }
+    if (parsedPackageFile) {
+        runtime.dependencies = parsedPackageFile.dependencies;
+    }
+    if (parsedPackageFile === null || parsedPackageFile === void 0 ? void 0 : parsedPackageFile.resolutions) {
+        runtime.resolutions = parsedPackageFile.resolutions;
+    }
+    if (timeout !== undefined) {
+        runtime.timeout = timeout;
+    }
+    if (warmConcurrency !== undefined) {
+        runtime.warmConcurrency = warmConcurrency;
+    }
+    if (resources) {
+        runtime.resources = resources;
+    }
+    if (permissions === null || permissions === void 0 ? void 0 : permissions.length) {
+        runtime.permissions = permissions;
+    }
+    return runtime;
+};
+exports.buildRuntime = buildRuntime;
+const promptRuntimeOptions = async (flags, labelPrefix) => {
+    const prefix = labelPrefix ? `${labelPrefix}: ` : '';
+    const timeout = await (0, utils_1.promptIntegerIfUndefined)(flags.timeout, {
+        message: `${prefix}Timeout in seconds (1-30, press Enter for default: 10):`,
+        min: 1,
+        max: 30,
+    });
+    const warmConcurrency = await (0, utils_1.promptIntegerIfUndefined)(flags['warm-concurrency'], {
+        message: `${prefix}Warm concurrency (0-1, press Enter for default: 0):`,
+        min: 0,
+        max: 1,
+    });
+    const resources = await (0, utils_1.promptSelectIfUndefined)(flags.resources, {
+        message: `${prefix}Resource tier:`,
+        choices: [
+            {
+                value: 'standard',
+                name: 'standard (default)',
+            },
+            {
+                value: 'large',
+                name: 'large',
+            },
+            {
+                value: 'xlarge',
+                name: 'xlarge',
+            },
+        ],
+    });
+    const packageJson = await (0, utils_1.promptStringIfUndefined)(flags['package-json'], {
+        message: `${prefix}(Optional) Runtime package.json file path (JSON format):`,
+    });
+    const permissions = await (0, utils_1.promptCommaSeparatedIfUndefined)(flags.permissions, {
+        message: `${prefix}(Optional) Permissions (comma-separated, e.g. token:read, token:create):`,
+    });
+    return {
+        timeout,
+        warmConcurrency,
+        resources,
+        packageJson: packageJson || undefined,
+        permissions,
+    };
+};
+exports.promptRuntimeOptions = promptRuntimeOptions;
+const promptRuntimeImage = (image, message = 'Which runtime do you want to use?') => (0, utils_1.promptSelectIfUndefined)(image, {
+    message,
+    choices: [
+        {
+            value: LEGACY_RUNTIME_IMAGE,
+            name: `${LEGACY_RUNTIME_IMAGE} (legacy)`,
+        },
+        ...CONFIGURABLE_RUNTIME_IMAGES.map((runtime) => ({
+            value: runtime,
+            name: `${runtime} (configurable)`,
+        })),
+    ],
+});
+exports.promptRuntimeImage = promptRuntimeImage;

package/dist/utils.d.ts

@@ -15,5 +15,11 @@ declare const promptSelectIfUndefined: (value: string | undefined, options: Para
 declare const promptCheckboxIfUndefined: (value: string[] | undefined, options: Parameters<typeof checkbox>[0]) => Promise<string[]>;
 declare const promptUrlIfUndefined: (value: URL | undefined, options: Parameters<typeof input>[0]) => Promise<URL>;
 declare const promptBooleanIfUndefined: (value: boolean | undefined, options: Parameters<typeof confirm>[0]) => Promise<boolean>;
+declare const promptIntegerIfUndefined: (value: number | undefined, options: {
+    message: string;
+    min?: number;
+    max?: number;
+}) => Promise<number | undefined>;
+declare const promptCommaSeparatedIfUndefined: (value: string[] | undefined, options: Parameters<typeof input>[0]) => Promise<string[] | undefined>;
 declare const cleanUpOnExit: (action: () => unknown) => typeof process;
-export { selectOrNavigate, promptStringIfUndefined, promptSelectIfUndefined, promptCheckboxIfUndefined, promptUrlIfUndefined, promptBooleanIfUndefined, cleanUpOnExit, PaginatedList, };
+export { selectOrNavigate, promptStringIfUndefined, promptSelectIfUndefined, promptCheckboxIfUndefined, promptUrlIfUndefined, promptBooleanIfUndefined, promptIntegerIfUndefined, promptCommaSeparatedIfUndefined, cleanUpOnExit, PaginatedList, };

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanUpOnExit = exports.promptBooleanIfUndefined = exports.promptUrlIfUndefined = exports.promptCheckboxIfUndefined = exports.promptSelectIfUndefined = exports.promptStringIfUndefined = exports.selectOrNavigate = void 0;
+exports.cleanUpOnExit = exports.promptCommaSeparatedIfUndefined = exports.promptIntegerIfUndefined = exports.promptBooleanIfUndefined = exports.promptUrlIfUndefined = exports.promptCheckboxIfUndefined = exports.promptSelectIfUndefined = exports.promptStringIfUndefined = exports.selectOrNavigate = void 0;
 const tslib_1 = require("tslib");
 const checkbox_1 = tslib_1.__importDefault(require("@inquirer/checkbox"));
 const confirm_1 = tslib_1.__importDefault(require("@inquirer/confirm"));
@@ -82,6 +82,46 @@ const promptBooleanIfUndefined = (value, options) => {
     return (0, confirm_1.default)(options);
 };
 exports.promptBooleanIfUndefined = promptBooleanIfUndefined;
+const promptIntegerIfUndefined = async (value, options) => {
+    if (value !== undefined) {
+        return value;
+    }
+    const result = await (0, input_1.default)({
+        message: options.message,
+        validate: (val) => {
+            if (!val.trim()) {
+                return true;
+            } // Allow empty for optional
+            const num = Number(val);
+            if (Number.isNaN(num) || !Number.isInteger(num)) {
+                return 'Please enter a valid integer';
+            }
+            if (options.min !== undefined && num < options.min) {
+                return `Value must be at least ${options.min}`;
+            }
+            if (options.max !== undefined && num > options.max) {
+                return `Value must be at most ${options.max}`;
+            }
+            return true;
+        },
+    });
+    return result.trim() ? Number(result) : undefined;
+};
+exports.promptIntegerIfUndefined = promptIntegerIfUndefined;
+const promptCommaSeparatedIfUndefined = async (value, options) => {
+    if (value && value.length > 0) {
+        return value;
+    }
+    const result = await (0, input_1.default)(options);
+    if (!result.trim()) {
+        return undefined;
+    }
+    return result
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+};
+exports.promptCommaSeparatedIfUndefined = promptCommaSeparatedIfUndefined;
 const cleanUpOnExit = (action) => process.on('SIGINT', async () => {
     await action();
     process.exit(1);