zcatalyst-cli 1.26.1 → 1.27.0

package/lib/init/util/common.js

@@ -15,12 +15,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeDetails = getRuntimeDetails;
 exports.getRuntimeChoices = getRuntimeChoices;
 exports.getRuntimePromptAnswer = getRuntimePromptAnswer;
+exports.ignorableOptsTest = ignorableOptsTest;
+exports.niIgnorableOptsTest = niIgnorableOptsTest;
+const ansi_colors_1 = require("ansi-colors");
 const catalyst_details_js_1 = __importDefault(require("../../endpoints/lib/catalyst-details.js"));
 const index_js_1 = __importDefault(require("../../error/index.js"));
 const index_js_2 = __importDefault(require("../../prompt/index.js"));
 const index_js_3 = require("../../util_modules/constants/index.js");
 const logger_1 = require("../../util_modules/logger");
 const index_1 = require("../../util_modules/logger/index");
+const option_js_1 = require("../../util_modules/option.js");
+const prompt_fields_js_1 = require("./prompt-fields.js");
+const env_js_1 = require("../../util_modules/env.js");
 function getRuntimeDetails(fnType) {
     const catalystDetailsAPI = new catalyst_details_js_1.default();
     return catalystDetailsAPI.getDetails('runtime', fnType ? index_js_3.REMOTE_REF.functions.type[fnType] : undefined);
@@ -88,16 +94,40 @@ function getRuntimeChoices(_a) {
 function getRuntimePromptAnswer(question, fnType) {
     return __awaiter(this, void 0, void 0, function* () {
         const runtimeChoices = yield getRuntimeChoices({ fnType });
-        const runtimeAns = yield index_js_2.default.ask(index_js_2.default.question('runtime', question, {
+        const runtimeAns = yield index_js_2.default.ask(index_js_2.default.question(prompt_fields_js_1.initCommonPromptFields.get('stack'), question, {
             type: 'list',
             choices: runtimeChoices,
             when: () => {
                 return runtimeChoices.length > 1;
             }
         }));
-        if (runtimeAns === undefined || runtimeAns.runtime === undefined) {
+        if (runtimeAns === undefined || runtimeAns.stack === undefined) {
             throw new index_js_1.default('Selected runtime is invalid.', { exit: 2 });
         }
-        return runtimeAns.runtime;
+        return runtimeAns.stack;
     });
 }
+function ignorableOptsTest(optNames, warnMsg, removeFromOpts = true) {
+    if (typeof optNames === 'string')
+        optNames = [optNames];
+    const ignorableOpts = optNames.filter((optName) => {
+        const optValue = (0, option_js_1.getOptionValue)(optName, undefined);
+        return optValue !== undefined;
+    });
+    if (ignorableOpts.length > 0) {
+        (0, logger_1.warning)(`${warnMsg}\nIgnored options: ${ignorableOpts
+            .map((_opt) => (0, ansi_colors_1.italic)(`--${_opt}`))
+            .join(', ')}.`);
+        if (removeFromOpts) {
+            ignorableOpts.forEach((optName) => {
+                (0, option_js_1.unsetOption)(optName);
+            });
+        }
+    }
+}
+function niIgnorableOptsTest(optNames, warnMsg, removeFromOpts = true) {
+    if (!(0, env_js_1.isNonInteractiveMode)()) {
+        return;
+    }
+    return ignorableOptsTest(optNames, warnMsg, removeFromOpts);
+}

package/lib/init/util/prompt-fields.d.ts

@@ -0,0 +1,7 @@
+export declare const initCommonPromptFields: import("../../prompt/register-fields").PromptFieldsRegistry<readonly [{
+    readonly name: "stack";
+    readonly cliOption: {
+        readonly option: "--stack <stack>";
+        readonly description: "catalyst runtime stack to scaffold (for example node18, java17, python_3_9)";
+    };
+}]>;

package/lib/init/util/prompt-fields.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommonPromptFields = void 0;
+const register_fields_1 = require("../../prompt/register-fields");
+exports.initCommonPromptFields = (0, register_fields_1.definePromptFields)([
+    {
+        name: 'stack',
+        cliOption: {
+            option: '--stack <stack>',
+            description: 'catalyst runtime stack to scaffold (for example node18, java17, python_3_9)'
+        }
+    }
+]);

package/lib/internal/command.d.ts

@@ -11,6 +11,7 @@ declare class Command {
     private beforeRunners;
     private optIgnores;
     private helpText;
+    private niHelpText;
     private allowUnknownOptions;
     client: Client | null;
     private subCommand;
@@ -25,8 +26,10 @@ declare class Command {
     argument(name: string, description: string, defaultValue?: string): Command;
     allowUnknownOpts(): Command;
     option(...args: Array<string>): Command;
+    option(optionTuple: ReadonlyArray<string>): Command;
     needs(fn: 'auth' | 'config' | 'rc', args?: unknown): Command;
     help(text: string): Command;
+    niHelp(text: string): Command;
     addSubCommand(...commands: Array<Command>): Command;
     ci(value: boolean): Command;
     helpConfig(config: HelpConfiguration): Command;

package/lib/internal/command.js

@@ -72,6 +72,7 @@ class Command {
         this.beforeRunners = [];
         this.optIgnores = [];
         this.helpText = null;
+        this.niHelpText = null;
         this.client = null;
         this.allowUnknownOptions = false;
     }
@@ -91,8 +92,16 @@ class Command {
         this.allowUnknownOptions = true;
         return this;
     }
-    option(...args) {
-        this.cmdOptions.push(args);
+    option(firstOrTuple, ...rest) {
+        if (firstOrTuple === undefined) {
+            this.cmdOptions.push(rest.length > 0 ? rest : []);
+            return this;
+        }
+        if (typeof firstOrTuple === 'string') {
+            this.cmdOptions.push([firstOrTuple, ...rest]);
+            return this;
+        }
+        this.cmdOptions.push([...firstOrTuple, ...rest]);
         return this;
     }
     needs(fn, args) {
@@ -106,6 +115,13 @@ class Command {
         this.helpText = text;
         return this;
     }
+    niHelp(text) {
+        this.niHelpText = `\nNon-Interactive Mode help: \n${text
+            .split('\n')
+            .map((line) => '    ' + line)
+            .join('\n')}`;
+        return this;
+    }
     addSubCommand(...commands) {
         commands.forEach((command) => {
             this.subCommand.push(command);
@@ -159,6 +175,13 @@ class Command {
                 (0, index_1.info)(this.helpText);
             });
         }
+        if (this.niHelpText !== null) {
+            cmd.on('--help', () => {
+                if (!(0, env_1.isNonInteractiveMode)())
+                    return;
+                (0, index_1.info)(this.niHelpText);
+            });
+        }
         if (this._helpConfig) {
             cmd.configureHelp(this._helpConfig);
         }
@@ -266,5 +289,5 @@ class Command {
         });
     }
 }
-Command.globalOpts = ['project', 'token', 'dc', 'org', 'verbose'];
+Command.globalOpts = ['project', 'token', 'dc', 'org', 'verbose', 'nonInteractive'];
 exports.default = Command;

package/lib/migration/global/1.27.0.d.ts

@@ -0,0 +1,2 @@
+export declare const isRequire: () => boolean;
+export declare const migrate: () => void;

package/lib/migration/global/1.27.0.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = exports.isRequire = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_store_js_1 = __importDefault(require("../../util_modules/config-store.js"));
+const index_1 = require("../../util_modules/logger/index");
+const LEGACY_CLI_CONFIG_NAME = 'zcatalyst-cli';
+const getLegacyConfigPath = () => {
+    const configDir = config_store_js_1.default.path;
+    return configDir ? (0, path_1.join)(configDir, `${LEGACY_CLI_CONFIG_NAME}.json`) : undefined;
+};
+const isRequire = () => {
+    const legacyPath = getLegacyConfigPath();
+    if (!legacyPath || !(0, fs_1.existsSync)(legacyPath)) {
+        return false;
+    }
+    return Object.keys(config_store_js_1.default.store).every((key) => key === 'migration');
+};
+exports.isRequire = isRequire;
+const migrate = () => {
+    const legacyPath = getLegacyConfigPath();
+    if (!legacyPath) {
+        return;
+    }
+    try {
+        const legacyContent = JSON.parse((0, fs_1.readFileSync)(legacyPath, 'utf8'));
+        config_store_js_1.default.store = Object.assign(Object.assign({}, legacyContent), { migration: config_store_js_1.default.store.migration });
+        (0, index_1.debug)('legacy config migrated to zcatalyst-cli-v1.json');
+    }
+    catch (e) {
+        (0, index_1.debug)('legacy config migration failed');
+        throw e;
+    }
+};
+exports.migrate = migrate;

package/lib/prompt/choice.d.ts

@@ -0,0 +1,2 @@
+import type { IChoice } from './index';
+export declare const choice: (name: string, { id, value, short, disabled, checked, ...otherOpts }?: IChoice) => IChoice;

package/lib/prompt/choice.js

@@ -0,0 +1,24 @@
+'use strict';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.choice = void 0;
+const choice = (name, _a = {}) => {
+    var { id = name, value = name, short = name, disabled = false, checked = false } = _a, otherOpts = __rest(_a, ["id", "value", "short", "disabled", "checked"]);
+    return Object.assign({ id,
+        name,
+        value,
+        short,
+        disabled,
+        checked }, otherOpts);
+};
+exports.choice = choice;

package/lib/prompt/cli-option-key.d.ts

@@ -0,0 +1 @@
+export declare function commanderOptionKey(option: string): string;

package/lib/prompt/cli-option-key.js

@@ -0,0 +1,10 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commanderOptionKey = commanderOptionKey;
+function commanderOptionKey(option) {
+    const parts = option.split(',');
+    const tail = parts[parts.length - 1].trim();
+    const long = tail.match(/^--([\w-]+)/);
+    const kebab = long ? long[1] : tail.replace(/^-+/, '');
+    return kebab.replace(/-([a-z])/gi, (_, c) => c.toUpperCase());
+}

package/lib/prompt/index.d.ts

@@ -1,26 +1,6 @@
 import inquirer from 'inquirer';
-import Separator from 'inquirer/lib/objects/separator';
 import PromptUI from 'inquirer/lib/ui/prompt';
-import { TreeData, TreeNode } from './types/tree';
-export interface IChoice extends inquirer.ChoiceOptions, inquirer.ListChoiceOptions, inquirer.CheckboxChoiceOptions {
-    id?: string;
-}
-export interface IQuestion extends inquirer.Question, inquirer.ListQuestionOptions {
-    name: string;
-    type?: inquirer.QuestionTypeName | 'file-path' | 'tree' | 'search-box' | 'with-desc';
-    defaultAns?: unknown;
-    choices?: Array<IChoice | TSeparator> | Array<string | TSeparator>;
-    treeChoices?: Array<TreeNode | TreeData>;
-    rootPath?: string;
-    exclude?: Array<string>;
-    excludeDir?: boolean;
-    ignoreFiles?: boolean;
-    depth?: number;
-    empTxt?: string;
-    validatingText?: string;
-    description?: string;
-}
-export type TSeparator = Separator;
+import { buildQuestion, IChoice, IQuestion, TSeparator } from './question-factory';
 declare const _default: {
     register: (type: "file-path" | "tree" | "search-box" | "with-desc") => Promise<void>;
     deregister: (type: "file-path" | "tree" | "search-box") => void;
@@ -29,6 +9,10 @@ declare const _default: {
     ask: (...questions: Array<IQuestion>) => (Promise<inquirer.Answers> & {
         ui: PromptUI;
     }) | Promise<inquirer.Answers>;
-    question: (name: string, question: string, { type, defaultAns, choices, validate, filter, when, prefix, suffix, ...otheropts }?: Omit<IQuestion, "name">) => IQuestion;
+    question: typeof buildQuestion;
 };
 export default _default;
+export { overwritePromptQuestion } from './overwrite-prompt';
+export { definePromptFields, PromptFieldHandle, PromptFieldsRegistry } from './register-fields';
+export type { DefinedPromptFields, PromptFieldDef, PromptFieldNames } from './register-fields';
+export type { IQuestion, IChoice, TSeparator } from './question-factory';

package/lib/prompt/index.js

@@ -56,18 +56,184 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptFieldsRegistry = exports.PromptFieldHandle = exports.definePromptFields = exports.overwritePromptQuestion = void 0;
 const inquirer_1 = __importDefault(require("inquirer"));
+const separator_1 = __importDefault(require("inquirer/lib/objects/separator"));
 const error_1 = __importDefault(require("../error"));
+const env_1 = require("../util_modules/env");
+const utils_1 = require("../util_modules/logger/utils");
+const option_1 = require("../util_modules/option");
+const choice_1 = require("./choice");
+const question_factory_1 = require("./question-factory");
 const runtime_store_1 = __importDefault(require("../runtime-store"));
-const choice = (name, _a = {}) => {
-    var { id = name, value = name, short = name, disabled = false, checked = false } = _a, otherOpts = __rest(_a, ["id", "value", "short", "disabled", "checked"]);
-    return Object.assign({ id,
-        name,
-        value,
-        short,
-        disabled,
-        checked }, otherOpts);
-};
+const register_fields_1 = require("./register-fields");
+const ansi_colors_1 = require("ansi-colors");
+function isChoiceSeparator(c) {
+    return c instanceof separator_1.default;
+}
+function omitCliOptionKeyForInquirer(q) {
+    const { fieldOrName } = q, rest = __rest(q, ["fieldOrName"]);
+    void fieldOrName;
+    rest.name = (0, question_factory_1.getQuestionPromptName)(q);
+    return rest;
+}
+function questionWillBeAsked(question, answers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let shouldAsk = true;
+        const whenFn = question.when;
+        if (whenFn !== undefined) {
+            if (typeof whenFn === 'function') {
+                const result = whenFn(answers);
+                shouldAsk = !!(result instanceof Promise ? yield result : result);
+            }
+            else {
+                shouldAsk = !!whenFn;
+            }
+        }
+        return shouldAsk;
+    });
+}
+function ensureCustomPromptTypeRegistered(question) {
+    if (question.type && ['file-path', 'tree', 'search-box'].includes(question.type)) {
+        if (!registeredTypes.has(question.type)) {
+            throw new error_1.default(`Prompt type "${question.type}" is not registered.`, {
+                exit: 2
+            });
+        }
+    }
+}
+function applyRawToAnswer(question, answers, raw) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let value = mapRuntimeRawToAnswer(question, raw);
+        const filterFn = question.filter;
+        if (typeof filterFn === 'function') {
+            const filtered = yield Promise.resolve(filterFn(value, answers));
+            value = filtered;
+        }
+        const validateFn = question.validate;
+        if (typeof validateFn === 'function') {
+            const v = yield Promise.resolve(validateFn(value, answers));
+            if (v !== true) {
+                const qName = (0, question_factory_1.getQuestionPromptName)(question);
+                throw new error_1.default(typeof v === 'string' ? v : `Validation failed for prompt "${qName}".`, { exit: 2 });
+            }
+        }
+        const qName = (0, question_factory_1.getQuestionPromptName)(question);
+        answers[qName] = value;
+    });
+}
+function resolveRawInputForQuestion(question, answers, runtimePrompt) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const qName = (0, question_factory_1.getQuestionPromptName)(question);
+        let raw = runtimePrompt ? runtimePrompt[qName] : undefined;
+        if (raw === undefined && question.default !== undefined) {
+            const d = question.default;
+            if (typeof d === 'function') {
+                const r = d(answers);
+                raw = r instanceof Promise ? yield r : r;
+            }
+            else {
+                raw = d;
+            }
+        }
+        if (raw === undefined && question.defaultAns !== undefined) {
+            raw = question.defaultAns;
+        }
+        return raw;
+    });
+}
+function resolveRuntimePromptAnswers(questions, runtimePrompt) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const answers = {};
+        for (const question of questions) {
+            const shouldAsk = yield questionWillBeAsked(question, answers);
+            if (shouldAsk) {
+                const raw = yield resolveRawInputForQuestion(question, answers, runtimePrompt);
+                if (raw === undefined) {
+                    if ((0, env_1.isNonInteractiveMode)()) {
+                        const qName = (0, question_factory_1.getQuestionPromptName)(question);
+                        throw new error_1.default(`Missing runtime input for prompt "${qName}" (after defaults).`, { exit: 2 });
+                    }
+                    ensureCustomPromptTypeRegistered(question);
+                    const qForPrompt = Object.assign(Object.assign({}, omitCliOptionKeyForInquirer(question)), { when: () => true });
+                    const interactiveSlice = yield inquirer_1.default.prompt([qForPrompt], answers);
+                    Object.assign(answers, interactiveSlice);
+                }
+                else {
+                    yield applyRawToAnswer(question, answers, raw);
+                }
+            }
+            else {
+                const raw = yield resolveRawInputForQuestion(question, answers, runtimePrompt);
+                if (raw !== undefined) {
+                    yield applyRawToAnswer(question, answers, raw);
+                }
+            }
+        }
+        return answers;
+    });
+}
+function mapRuntimeRawToAnswer(question, raw) {
+    const qType = question.type;
+    const qName = (0, question_factory_1.getQuestionPromptName)(question);
+    switch (qType) {
+        case 'checkbox': {
+            let ids;
+            if (typeof raw === 'string') {
+                ids = raw
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+            }
+            else if (Array.isArray(raw)) {
+                ids = raw;
+            }
+            else {
+                throw new error_1.default(`Runtime input for "${qName}" must be a comma-separated list or an array of choice ids for checkbox prompts.`, { exit: 2 });
+            }
+            const choices = (question.choices || []);
+            return choices
+                .filter((c) => !isChoiceSeparator(c))
+                .map((c) => c)
+                .filter((c) => !!c.id && ids.includes(c.id))
+                .map((c) => c.value);
+        }
+        case 'list': {
+            const choices = question.choices;
+            if (!(choices === null || choices === void 0 ? void 0 : choices.length)) {
+                return raw;
+            }
+            if (typeof choices[0] === 'string') {
+                return raw;
+            }
+            const id = String(raw);
+            const flat = choices.filter((c) => !isChoiceSeparator(c) && typeof c !== 'string');
+            let found = flat.find((c) => c.id === id);
+            if (found === undefined) {
+                found = flat.find((c) => String(c.value) === id || String(c.name) === id);
+            }
+            if (found === undefined) {
+                const idx = Number(id);
+                if (!isNaN(idx) && idx >= 0 && idx <= flat.length) {
+                    found = flat[idx];
+                }
+            }
+            if (found === undefined) {
+                const promptChoices = flat
+                    .map((c) => '* ' + (typeof c.value === 'string' ? c.value : c.id))
+                    .join('\n');
+                throw new error_1.default(`No list choice matches "${id}" for prompt "${qName}".`, {
+                    exit: 1,
+                    errorId: 'E_RUNTIME_PROMPT_NO_MATCH',
+                    arg: [(0, ansi_colors_1.bold)(id), (0, ansi_colors_1.bold)(qName), promptChoices]
+                });
+            }
+            return found.value;
+        }
+        default:
+            return raw;
+    }
+}
 const registeredTypes = new Map();
 exports.default = {
     register: (type) => __awaiter(void 0, void 0, void 0, function* () {
@@ -101,72 +267,103 @@ exports.default = {
     separator: (line) => {
         return new inquirer_1.default.Separator(line);
     },
-    choice,
+    choice: choice_1.choice,
     ask: (...questions) => {
-        const runtimePrompt = runtime_store_1.default.get('prompt', false);
-        if (!runtimePrompt) {
+        const runInteractiveAsk = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (!(0, env_1.isNonInteractiveMode)()) {
+                return inquirer_1.default.prompt(questions.map(omitCliOptionKeyForInquirer));
+            }
+            const answers = {};
+            const askableQuestions = [];
             for (const question of questions) {
-                if (question.when &&
-                    question.type &&
-                    ['file-path', 'tree', 'search-box'].includes(question.type)) {
-                    if (!registeredTypes.has(question.type)) {
-                        throw new error_1.default(`Prompt type "${question.type}" is not registered.`, {
-                            exit: 2
-                        });
+                if (yield questionWillBeAsked(question, answers)) {
+                    askableQuestions.push(question);
+                    const qName = (0, question_factory_1.getQuestionPromptName)(question);
+                    if (!(qName in answers)) {
+                        const raw = yield resolveRawInputForQuestion(question, answers);
+                        if (raw !== undefined) {
+                            yield applyRawToAnswer(question, answers, raw);
+                        }
                     }
                 }
             }
-            return inquirer_1.default.prompt(questions);
-        }
-        return new Promise((res, rej) => {
-            try {
-                const answers = {};
-                questions.forEach((question) => {
-                    var _a;
-                    const runtimeAns = runtimePrompt[question.name];
-                    if (runtimeAns !== undefined) {
-                        switch (question.type) {
-                            case 'checkbox': {
-                                answers[question.name] = question.choices
-                                    .filter((choice) => choice.id &&
-                                    runtimeAns.includes(choice.id))
-                                    .map((filteredChoice) => filteredChoice.value);
-                                break;
-                            }
-                            case 'list': {
-                                answers[question.name] = (_a = question.choices.find((choice) => choice.id === runtimeAns.toString())) === null || _a === void 0 ? void 0 : _a.value;
-                                break;
-                            }
-                            default: {
-                                answers[question.name] = runtimeAns;
-                            }
-                        }
+            const missingAskableQuestions = askableQuestions.filter((q) => {
+                const qName = (0, question_factory_1.getQuestionPromptName)(q);
+                return !(qName in answers);
+            });
+            if (missingAskableQuestions.length > 0) {
+                const names = missingAskableQuestions
+                    .map((q) => (0, question_factory_1.getQuestionPromptName)(q))
+                    .join(', ');
+                const niSource = (0, env_1.getNonInteractiveModeSource)();
+                let hint;
+                if ((0, env_1.isCLIBin)()) {
+                    if (niSource === 'env') {
+                        hint = `Use command options to supply values, or unset ${(0, ansi_colors_1.italic)('ZCATALYST_NON_INTERACTIVE')}.`;
                     }
+                    else if (niSource === 'option') {
+                        hint = `Use command options to supply values, or run without ${(0, ansi_colors_1.italic)('--non-interactive, -ni')}.`;
+                    }
+                    else {
+                        hint =
+                            'Use command options to supply values, or disable non-interactive mode.';
+                    }
+                }
+                else {
+                    hint = `Use Catalyst.exec({ inputs: { ... } }) or matching options, or disable non-interactive mode (e.g. omit nonInteractive / ZCATALYST_NON_INTERACTIVE).`;
+                }
+                const _firstMissingQ = missingAskableQuestions[0];
+                if (_firstMissingQ.niInputMissingError) {
+                    if (typeof _firstMissingQ.niInputMissingError === 'string') {
+                        throw new error_1.default(_firstMissingQ.niInputMissingError, {
+                            exit: 1,
+                            errorId: 'E_NON_INTERACTIVE_MISSING_INPUTS_ANY',
+                            arg: [(0, ansi_colors_1.bold)(_firstMissingQ.niInputMissingError)]
+                        });
+                    }
+                    _firstMissingQ.niInputMissingError.skipHelp = false;
+                    throw _firstMissingQ.niInputMissingError;
+                }
+                throw new error_1.default(`Non-interactive mode requires prepared inputs for: ${(0, ansi_colors_1.bold)(names)}`, {
+                    exit: 1,
+                    errorId: 'E_NON_INTERACTIVE_MISSING_INPUTS',
+                    arg: [
+                        (0, ansi_colors_1.bold)(names),
+                        hint,
+                        (0, utils_1.shellCommand)(`catalyst help ${(0, option_1.getCurrentCommand)()}`)
+                    ]
                 });
-                res(answers);
-            }
-            catch (err) {
-                rej(err);
             }
+            return answers;
         });
-    },
-    question: (name, question, _a = {}) => {
-        var { type = 'input', defaultAns, choices = [], validate = () => {
-            return true;
-        }, filter = (ans) => {
-            return ans;
-        }, when = () => {
-            return true;
-        }, prefix = '', suffix = '' } = _a, otheropts = __rest(_a, ["type", "defaultAns", "choices", "validate", "filter", "when", "prefix", "suffix"]);
-        if (choices.length > 0 && typeof choices[0] === 'string') {
-            choices = choices.map((strChoice) => choice(strChoice));
+        const stored = runtime_store_1.default.get('context.prompt', false);
+        const effective = typeof stored === 'object' && stored !== null ? Object.assign({}, stored) : {};
+        let filledFromCli = false;
+        for (const q of questions) {
+            const qName = (0, question_factory_1.getQuestionPromptName)(q);
+            if (effective[qName] === undefined) {
+                const optKey = q.fieldOrName instanceof register_fields_1.PromptFieldHandle
+                    ? q.fieldOrName.optKey
+                    : q.fieldOrName;
+                const fromOpts = (0, option_1.getOptionValue)(optKey, undefined);
+                if (fromOpts !== undefined) {
+                    effective[qName] = fromOpts;
+                    filledFromCli = true;
+                }
+            }
         }
-        return Object.assign({ type,
-            name, message: question, default: defaultAns, choices,
-            validate,
-            filter,
-            when,
-            prefix,
-            suffix }, otheropts);
-    }
+        const fromExec = typeof stored === 'object' && stored !== null;
+        const useRuntimePath = fromExec || filledFromCli;
+        if (!useRuntimePath) {
+            return runInteractiveAsk();
+        }
+        return resolveRuntimePromptAnswers(questions, effective);
+    },
+    question: question_factory_1.buildQuestion
 };
+var overwrite_prompt_1 = require("./overwrite-prompt");
+Object.defineProperty(exports, "overwritePromptQuestion", { enumerable: true, get: function () { return overwrite_prompt_1.overwritePromptQuestion; } });
+var register_fields_2 = require("./register-fields");
+Object.defineProperty(exports, "definePromptFields", { enumerable: true, get: function () { return register_fields_2.definePromptFields; } });
+Object.defineProperty(exports, "PromptFieldHandle", { enumerable: true, get: function () { return register_fields_2.PromptFieldHandle; } });
+Object.defineProperty(exports, "PromptFieldsRegistry", { enumerable: true, get: function () { return register_fields_2.PromptFieldsRegistry; } });