zcatalyst-cli 1.26.2 → 1.27.0

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; } });

package/lib/prompt/overwrite-prompt.d.ts

@@ -0,0 +1,11 @@
+import type { IQuestion, PromptFieldHandle } from './index';
+type OverwriteResource = 'Directory' | 'File';
+interface OverwritePromptOpts {
+    fieldOrName?: string | PromptFieldHandle;
+    resourceName: string;
+    resourceType?: OverwriteResource;
+    contextText?: string;
+    defaultAns?: boolean | null;
+}
+export declare const overwritePromptQuestion: ({ fieldOrName, resourceName, resourceType, contextText, defaultAns }: OverwritePromptOpts) => IQuestion;
+export {};

package/lib/prompt/overwrite-prompt.js

@@ -0,0 +1,16 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwritePromptQuestion = void 0;
+const ansi_colors_1 = require("ansi-colors");
+const question_factory_1 = require("./question-factory");
+const overwritePromptQuestion = ({ fieldOrName = 'overwrite', resourceName, resourceType = 'Directory', contextText = '', defaultAns = false }) => {
+    const messageSuffix = contextText ? ` ${contextText}` : '';
+    const qOpts = {
+        type: 'confirm'
+    };
+    if (defaultAns !== null) {
+        qOpts['defaultAns'] = defaultAns;
+    }
+    return (0, question_factory_1.buildQuestion)(fieldOrName, `${resourceType} ${(0, ansi_colors_1.underline)(resourceName)} already exists${messageSuffix}. Overwrite ?`, qOpts);
+};
+exports.overwritePromptQuestion = overwritePromptQuestion;

package/lib/prompt/question-factory.d.ts

@@ -0,0 +1,34 @@
+import inquirer from 'inquirer';
+import Separator from 'inquirer/lib/objects/separator';
+import { PromptFieldHandle } from './register-fields';
+import type { TreeData, TreeNode } from './types/tree';
+import CatalystError from '../error';
+export interface IChoice extends inquirer.ChoiceOptions, inquirer.ListChoiceOptions, inquirer.CheckboxChoiceOptions {
+    id?: string;
+}
+export interface IQuestion extends inquirer.Question, inquirer.ListQuestionOptions {
+    fieldOrName: string | PromptFieldHandle;
+    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;
+    searchable?: boolean;
+    pageSize?: number;
+    highlight?: boolean;
+    notFoundMsg?: string;
+    searchMsg?: string;
+    boxType?: string;
+    source?: (answersSoFar: unknown, input: string | undefined) => Promise<unknown> | unknown;
+    niInputMissingError?: CatalystError | string;
+}
+export type TSeparator = Separator;
+export declare function getQuestionPromptName(question: IQuestion): string;
+export declare function buildQuestion(fieldOrName: string | PromptFieldHandle, messageText: string, { type, defaultAns, choices, validate, filter, when, prefix, suffix, ...otheropts }?: Omit<IQuestion, 'name' | 'fieldOrName'>): IQuestion;

package/lib/prompt/question-factory.js

@@ -0,0 +1,41 @@
+'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.getQuestionPromptName = getQuestionPromptName;
+exports.buildQuestion = buildQuestion;
+const choice_1 = require("./choice");
+const register_fields_1 = require("./register-fields");
+function getQuestionPromptName(question) {
+    return question.fieldOrName instanceof register_fields_1.PromptFieldHandle
+        ? question.fieldOrName.promptName
+        : question.fieldOrName;
+}
+function buildQuestion(fieldOrName, messageText, _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) => (0, choice_1.choice)(strChoice));
+    }
+    return Object.assign({ type,
+        fieldOrName, message: messageText, default: defaultAns, choices,
+        validate,
+        filter,
+        when,
+        prefix,
+        suffix }, otheropts);
+}

package/lib/prompt/register-fields.d.ts

@@ -0,0 +1,24 @@
+export type PromptFieldDef = {
+    name: string;
+    cliOption: {
+        description: string;
+        option: string;
+    };
+};
+export type PromptFieldNames<T extends ReadonlyArray<PromptFieldDef>> = T[number]['name'];
+export type DefinedPromptFields<T extends ReadonlyArray<PromptFieldDef>> = PromptFieldsRegistry<T>;
+export declare class PromptFieldHandle<F extends PromptFieldDef = PromptFieldDef> extends Array<string> {
+    readonly def: F;
+    constructor(def: F);
+    get optKey(): string;
+    get promptName(): string;
+    toCliOpts(): [string, string];
+}
+export declare class PromptFieldsRegistry<T extends ReadonlyArray<PromptFieldDef>> {
+    readonly map: Map<string, PromptFieldHandle<PromptFieldDef>>;
+    constructor(fields: T);
+    get<K extends PromptFieldNames<T>>(name: K): PromptFieldHandle<Extract<T[number], {
+        name: K;
+    }>>;
+}
+export declare function definePromptFields<T extends ReadonlyArray<PromptFieldDef>>(fields: T): PromptFieldsRegistry<T>;

package/lib/prompt/register-fields.js

@@ -0,0 +1,37 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptFieldsRegistry = exports.PromptFieldHandle = void 0;
+exports.definePromptFields = definePromptFields;
+const cli_option_key_1 = require("./cli-option-key");
+class PromptFieldHandle extends Array {
+    constructor(def) {
+        super();
+        this.def = def;
+        this.push(this.def.cliOption.option, this.def.cliOption.description);
+    }
+    get optKey() {
+        return (0, cli_option_key_1.commanderOptionKey)(this.def.cliOption.option);
+    }
+    get promptName() {
+        return this.def.name;
+    }
+    toCliOpts() {
+        return [this.def.cliOption.option, this.def.cliOption.description];
+    }
+}
+exports.PromptFieldHandle = PromptFieldHandle;
+class PromptFieldsRegistry {
+    constructor(fields) {
+        this.map = new Map();
+        for (const f of fields) {
+            this.map.set(f.name, new PromptFieldHandle(f));
+        }
+    }
+    get(name) {
+        return this.map.get(name);
+    }
+}
+exports.PromptFieldsRegistry = PromptFieldsRegistry;
+function definePromptFields(fields) {
+    return new PromptFieldsRegistry(fields);
+}

package/lib/pull/features/apig.js

@@ -1,4 +1,37 @@
 'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -12,10 +45,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ansi_colors_1 = require("ansi-colors");
 const apig_utils_1 = require("../../apig-utils");
 const endpoints_1 = require("../../endpoints");
-const prompt_1 = __importDefault(require("../../prompt"));
+const prompt_1 = __importStar(require("../../prompt"));
 const runtime_store_1 = __importDefault(require("../../runtime-store"));
 const config_1 = require("../../util_modules/config");
 const fs_1 = require("../../util_modules/fs");
@@ -23,6 +55,10 @@ const sync_1 = require("../../util_modules/fs/lib/sync");
 const index_1 = require("../../util_modules/logger/index");
 const project_1 = require("../../util_modules/project");
 const error_1 = __importDefault(require("../../error"));
+const env_1 = require("../../util_modules/env");
+const option_1 = require("../../util_modules/option");
+const utils_1 = require("../utils");
+const ansi_colors_1 = require("ansi-colors");
 exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     const apigName = config_1.apigConfig.rules();
     const apigDirPath = (0, project_1.resolveProjectPath)(apigName);
@@ -37,7 +73,7 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
         (0, index_1.info)();
         const consent = yield prompt_1.default.ask(prompt_1.default.question('enable', 'The APIG is disable in catalyst console, Do you want to enable it and pull the APIG rules now ?', {
             type: 'confirm',
-            defaultAns: false
+            defaultAns: (0, env_1.isNonInteractiveMode)()
         }));
         if (!consent.enable) {
             (0, index_1.info)('Skipping APIG pull. Since the APIG is disabled in catalyst console.');
@@ -47,12 +83,27 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     const fileExists = yield fs_1.ASYNC.fileExists(apigDirPath);
     const overwriteAns = fileExists
-        ? yield prompt_1.default.ask(prompt_1.default.question('overwrite', 'File ' + (0, ansi_colors_1.underline)(apigDirPath) + ' already exists. Overwrite ?', {
-            type: 'confirm',
-            defaultAns: false
+        ? yield prompt_1.default.ask((0, prompt_1.overwritePromptQuestion)({
+            resourceName: apigDirPath,
+            resourceType: 'File',
+            defaultAns: (0, env_1.isNonInteractiveMode)() &&
+                (0, option_1.getOptionValue)(utils_1.promptPullFields.get('overwrite').optKey, false)
+                ? true
+                : false
         }))
         : { overwrite: true };
     if (!overwriteAns.overwrite) {
+        if ((0, env_1.isNonInteractiveMode)()) {
+            throw new error_1.default('APIG pull failed as the APIG rules file already exists and the --overwrite option is not used to overwrite the file in local.', {
+                exit: 1,
+                errorId: 'E_NON_INTERACTIVE_APIG_PULL_OVERWRITE',
+                arg: [
+                    ansi_colors_1.italic.red(apigDirPath),
+                    (0, ansi_colors_1.italic)('--overwrite'),
+                    (0, ansi_colors_1.italic)(`catalyst pull apig ${(0, ansi_colors_1.green)('--overwrite')}`)
+                ]
+            });
+        }
         (0, index_1.info)('Skipping APIG pull');
         return;
     }