@mcp-z/cli 1.0.0

package/dist/cjs/commands/manifest/generate.js

@@ -0,0 +1,2541 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get TRANSPORT_MAP () {
+        return TRANSPORT_MAP;
+    },
+    get createConfigChoices () {
+        return createConfigChoices;
+    },
+    get discoverServerJson () {
+        return discoverServerJson;
+    },
+    get extractServerName () {
+        return extractServerName;
+    },
+    get filterConfigChoices () {
+        return filterConfigChoices;
+    },
+    get generateCommand () {
+        return generateCommand;
+    },
+    get generateConditionalCombinations () {
+        return generateConditionalCombinations;
+    },
+    get generateConfigFile () {
+        return generateConfigFile;
+    },
+    get generateConfigObject () {
+        return generateConfigObject;
+    },
+    get generateMatrixCombinations () {
+        return generateMatrixCombinations;
+    },
+    get shouldPromptEnvVar () {
+        return shouldPromptEnvVar;
+    }
+});
+var _checkbox = /*#__PURE__*/ _interop_require_default(require("@inquirer/checkbox"));
+var _confirm = /*#__PURE__*/ _interop_require_default(require("@inquirer/confirm"));
+var _input = /*#__PURE__*/ _interop_require_default(require("@inquirer/input"));
+var _select = /*#__PURE__*/ _interop_require_default(require("@inquirer/select"));
+var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+var _jsonschemats = require("../../lib/json-schema.js");
+var _envpromptingts = require("./env-prompting.js");
+var _metadatareaderts = require("./metadata-reader.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var TRANSPORT_MAP = {
+    stdio: 'stdio',
+    http: 'streamable-http'
+};
+function createConfigChoices(combinations, transports) {
+    var choices = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = combinations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var combination = _step.value;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = transports[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var t = _step1.value;
+                    var transport = TRANSPORT_MAP[t] || t;
+                    choices.push({
+                        combination: combination,
+                        transport: transport,
+                        label: "".concat(combination.name, " (").concat(t, ")")
+                    });
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return choices;
+}
+function filterConfigChoices(allChoices, selectedLabels) {
+    return allChoices.filter(function(choice) {
+        return selectedLabels.includes(choice.label);
+    });
+}
+/**
+ * Generate cartesian product of all dimension choices.
+ * Example: [AUTH_MODE: [a, b], DCR_MODE: [x, y]] → [[a,x], [a,y], [b,x], [b,y]]
+ */ function generateCartesianProduct(dimensions) {
+    if (dimensions.length === 0) return [
+        []
+    ];
+    var first = dimensions[0];
+    if (!first || !first.choices || first.choices.length === 0) return [
+        []
+    ];
+    if (dimensions.length === 1) {
+        return first.choices.map(function(c) {
+            return [
+                c
+            ];
+        });
+    }
+    var rest = dimensions.slice(1);
+    var restProduct = generateCartesianProduct(rest);
+    var result = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = first.choices[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var choice = _step.value;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = restProduct[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var restCombination = _step1.value;
+                    result.push([
+                        choice
+                    ].concat(_to_consumable_array(restCombination)));
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+function generateMatrixCombinations(envVars) {
+    var dimensions = envVars.map(function(e) {
+        return {
+            name: e.name,
+            choices: e.choices
+        };
+    });
+    var product = generateCartesianProduct(dimensions);
+    return product.map(function(values) {
+        var dimensionValues = {};
+        dimensions.forEach(function(dim, i) {
+            dimensionValues[dim.name] = values[i] || '';
+        });
+        var nameParts = dimensions.map(function(dim, i) {
+            return "".concat(dim.name.toLowerCase(), "-").concat(values[i]);
+        });
+        return {
+            name: nameParts.length > 0 ? nameParts.join('_') : 'minimal',
+            envKeys: dimensions.map(function(d) {
+                return d.name;
+            }),
+            argNames: [],
+            defaults: {},
+            argDefaults: {},
+            dimensionValues: dimensionValues
+        };
+    });
+}
+function generateConditionalCombinations(envVars) {
+    // Separate primary dimensions (no dependsOn) from conditional ones
+    var primaryDims = envVars.filter(function(e) {
+        return !e.dependsOn;
+    });
+    var conditionalDims = envVars.filter(function(e) {
+        return e.dependsOn;
+    });
+    if (primaryDims.length === 0) {
+        // No primary dimensions - return empty or minimal
+        return [
+            {
+                name: 'minimal',
+                envKeys: [],
+                argNames: [],
+                defaults: {},
+                argDefaults: {},
+                dimensionValues: {}
+            }
+        ];
+    }
+    // Generate all combinations of primary dimensions first
+    var primaryProduct = generateCartesianProduct(primaryDims);
+    var combinations = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var primaryValues = _step.value;
+            // Build base dimension values from primary
+            var baseDimensionValues = {};
+            primaryDims.forEach(function(dim, i) {
+                baseDimensionValues[dim.name] = primaryValues[i] || '';
+            });
+            // Find which conditional dimensions apply to this primary combination
+            var applicableConditionals = conditionalDims.filter(function(cond) {
+                return shouldPromptEnvVar(cond, baseDimensionValues);
+            });
+            if (applicableConditionals.length === 0) {
+                // No conditional dimensions apply - single combination
+                // Only include dimensions with multiple choices in the name (single-choice dimensions don't add discriminating value)
+                var nameParts = primaryDims.filter(function(dim) {
+                    return dim.choices.length > 1;
+                }).map(function(dim, _i) {
+                    return "".concat(dim.name.toLowerCase(), "-").concat(primaryValues[primaryDims.indexOf(dim)]);
+                });
+                combinations.push({
+                    name: nameParts.length > 0 ? nameParts.join('_') : 'default',
+                    envKeys: primaryDims.map(function(d) {
+                        return d.name;
+                    }),
+                    argNames: [],
+                    defaults: {},
+                    argDefaults: {},
+                    dimensionValues: _object_spread({}, baseDimensionValues)
+                });
+            } else {
+                // Generate sub-combinations for applicable conditional dimensions
+                var conditionalProduct = generateCartesianProduct(applicableConditionals);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _loop = function() {
+                        var condValues = _step1.value;
+                        var fullDimensionValues = _object_spread({}, baseDimensionValues);
+                        applicableConditionals.forEach(function(dim, i) {
+                            fullDimensionValues[dim.name] = condValues[i] || '';
+                        });
+                        // Build name from dimensions with multiple choices only (single-choice dimensions don't add discriminating value)
+                        var allDims = _to_consumable_array(primaryDims).concat(_to_consumable_array(applicableConditionals));
+                        var nameParts = allDims.filter(function(dim) {
+                            return dim.choices.length > 1;
+                        }).map(function(dim) {
+                            return "".concat(dim.name.toLowerCase(), "-").concat(fullDimensionValues[dim.name]);
+                        });
+                        combinations.push({
+                            name: nameParts.length > 0 ? nameParts.join('_') : 'default',
+                            envKeys: _to_consumable_array(primaryDims).concat(_to_consumable_array(applicableConditionals)).map(function(d) {
+                                return d.name;
+                            }),
+                            argNames: [],
+                            defaults: {},
+                            argDefaults: {},
+                            dimensionValues: fullDimensionValues
+                        });
+                    };
+                    for(var _iterator = conditionalProduct[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        };
+        for(var _iterator = primaryProduct[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return combinations;
+}
+function shouldPromptEnvVar(envVar, selectedValues) {
+    if (!envVar.dependsOn) return true;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        // All dependencies must be satisfied
+        for(var _iterator = Object.entries(envVar.dependsOn)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), depName = _step_value[0], allowedValues = _step_value[1];
+            var selectedValue = selectedValues[depName];
+            // If dependency not yet selected, or selected value not in allowed list, skip
+            if (!selectedValue || !allowedValues.includes(selectedValue)) {
+                return false;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return true;
+}
+function generateCommand() {
+    return _async_to_generator(function() {
+        var options, useSource, jsonOutput, matrixMode, quickMode, serverJsonPath, packageDir, packageJsonPath, packageJson, packageName, serverName, binPath, packageNameWithoutOrg, serverJsonContent, metadata, error, metadataReader, stdioPackage, envVarsWithChoices, argsWithChoices, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, envVar, _envVar_choices, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, arg, _arg_choices, outputDir, transports, httpPackage, envVarsForMatrix, defaults, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _loop, _iterator2, _step2, combinations, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, combo, httpHost, httpPort, generatedCount, _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, combination, _iteratorNormalCompletion5, _didIteratorError5, _iteratorError5, _iterator5, _step5, transport, err, err, configMode, finalServerName, outputDir1, _tmp, combination1, config, transports1, httpHost1, httpPort1, portStr, availableDimensions, _iteratorNormalCompletion6, _didIteratorError6, _iteratorError6, _iterator6, _step6, envVar1, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, arg1, selectedDimensionNames, selectedDimensions, dimensionsWithFilteredChoices, _iteratorNormalCompletion8, _didIteratorError8, _iteratorError8, _iterator8, _step8, dim, choicesWithSkip, selectedChoices, err, dimensionNames, nonDimensionEnvVars, nonDimensionArgs, defaults1, argDefaults, _iteratorNormalCompletion9, _didIteratorError9, _iteratorError9, _iterator9, _step9, envVar2, choicesWithSkip1, defaultValue, err, _iteratorNormalCompletion10, _didIteratorError10, _iteratorError10, _iterator10, _step10, arg2, choicesWithSkip2, defaultValue1, err, combinations1, totalConfigs, _iteratorNormalCompletion11, _didIteratorError11, _iteratorError11, _iterator11, _step11, combo1, _iteratorNormalCompletion12, _didIteratorError12, _iteratorError12, _iterator12, _step12, _step_value, key, value, _iteratorNormalCompletion13, _didIteratorError13, _iteratorError13, _iterator13, _step13, _step_value1, key1, value1, generationMode, selectedConfigs, allChoices, selectedLabels, finalServerName1, outputDir2, _tmp1, optionalVarsToPrompt, _selectedDimensions_, envVarsWithContext, primaryDimensionName, _iteratorNormalCompletion14, _didIteratorError14, _iteratorError14, _iterator14, _step14, combination2, allEnvVars, _iteratorNormalCompletion15, _didIteratorError15, _iteratorError15, _iterator15, _step15, envVar3, context, allSelectedModes, groupedVars, _iteratorNormalCompletion16, _didIteratorError16, _iteratorError16, _iterator16, _step16, _step_value2, envVar4, relevantModes, appliesToAll, _groupedVars_get, groupKey, templateVars, _iteratorNormalCompletion17, _didIteratorError17, _iteratorError17, _iterator17, _step17, _step_value3, groupKey1, vars, _iteratorNormalCompletion18, _didIteratorError18, _iteratorError18, _iterator18, _step18, envVar5, _ref, _envVar_default, rawDefault, defaultVal, label, allOptionalVarNames, configureChoice, _iteratorNormalCompletion19, _didIteratorError19, _iteratorError19, _iterator19, _step19, name, checkboxChoices, _iteratorNormalCompletion20, _didIteratorError20, _iteratorError20, _iterator20, _step20, _step_value4, groupKey2, vars1, _iteratorNormalCompletion21, _didIteratorError21, _iteratorError21, _iterator21, _step21, envVar6, _ref1, _envVar_default1, rawDefault1, defaultVal1, label1, selectedVarNames, _iteratorNormalCompletion22, _didIteratorError22, _iteratorError22, _iterator22, _step22, name1, configs, _iteratorNormalCompletion23, _didIteratorError23, _iteratorError23, _iterator23, _step23, _step_value5, combination3, transport1, config1, err, generatedCount1, _iteratorNormalCompletion24, _didIteratorError24, _iteratorError24, _iterator24, _step24, _step_value6, combination4, transport2, success, err;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : {};
+                    console.log('🔧 MCP Config Generator\n');
+                    useSource = options.source || false;
+                    jsonOutput = options.json || false;
+                    matrixMode = options.matrix || false;
+                    quickMode = options.quick || false;
+                    // 1. Discover server.json in current directory or parent
+                    serverJsonPath = discoverServerJson();
+                    if (!serverJsonPath) {
+                        console.error('❌ No server.json found in current directory or parent');
+                        console.error('   Run this command from an MCP server package directory');
+                        process.exit(1);
+                    }
+                    // 2. Read package.json to get package name
+                    packageDir = _path.dirname(serverJsonPath);
+                    packageJsonPath = _path.join(packageDir, 'package.json');
+                    if (!_fs.existsSync(packageJsonPath)) {
+                        console.error('❌ No package.json found alongside server.json');
+                        console.error('   Package.json is required to get package name');
+                        process.exit(1);
+                    }
+                    packageJson = JSON.parse(_fs.readFileSync(packageJsonPath, 'utf-8'));
+                    packageName = packageJson.name;
+                    serverName = extractServerName(packageName);
+                    if (packageJson.bin) {
+                        if (typeof packageJson.bin === 'string') {
+                            // Default bin entry
+                            binPath = packageJson.bin;
+                        } else {
+                            // Named bin entries - try to match package name without org
+                            packageNameWithoutOrg = packageName.replace(/^@[^/]+\//, '');
+                            binPath = packageJson.bin[packageNameWithoutOrg] || packageJson.bin[Object.keys(packageJson.bin)[0] || ''];
+                        }
+                    }
+                    console.log("\uD83D\uDCE6 Package: ".concat(packageName));
+                    // 3. Read and validate server.json metadata
+                    serverJsonContent = _fs.readFileSync(serverJsonPath, 'utf-8');
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    metadata = JSON.parse(serverJsonContent);
+                    return [
+                        4,
+                        (0, _jsonschemats.validateSchema)(metadata, serverName)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    error = _state.sent();
+                    console.error("❌ Failed to read or validate server.json: ".concat(_instanceof(error, Error) ? error.message : String(error)));
+                    process.exit(1);
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    metadataReader = new _metadatareaderts.MetadataReader();
+                    // 4. Get stdio package to analyze env vars
+                    stdioPackage = metadataReader.getPackageForTransport(metadata, 'stdio');
+                    if (!stdioPackage) {
+                        console.error('❌ No stdio transport found in server.json');
+                        process.exit(1);
+                    }
+                    // 5. Find all environment variables and package arguments with choices
+                    // Filter to only mandatory matrix items (isMandatoryForMatrix !== false)
+                    // Non-mandatory items like LOG_LEVEL should not explode the test matrix
+                    envVarsWithChoices = (stdioPackage.environmentVariables || []).filter(function(envVar) {
+                        return envVar.choices && envVar.choices.length > 0 && envVar.isMandatoryForMatrix !== false;
+                    });
+                    argsWithChoices = (stdioPackage.packageArguments || []).filter(function(arg) {
+                        return arg.choices !== undefined && arg.choices.length > 0;
+                    });
+                    if (envVarsWithChoices.length === 0 && argsWithChoices.length === 0) {
+                        console.error('❌ No environment variables or package arguments with choices found in server.json');
+                        console.error('   Cannot generate configurations without choice-based configuration options');
+                        process.exit(1);
+                    }
+                    console.log('\n🔍 Available configuration options:');
+                    if (envVarsWithChoices.length > 0) {
+                        console.log("   Environment variables (".concat(envVarsWithChoices.length, "):"));
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = envVarsWithChoices[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                envVar = _step.value;
+                                ;
+                                console.log("   • ".concat(envVar.name, ": ").concat(((_envVar_choices = envVar.choices) === null || _envVar_choices === void 0 ? void 0 : _envVar_choices.join(', ')) || ''));
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    }
+                    if (argsWithChoices.length > 0) {
+                        console.log("   Package arguments (".concat(argsWithChoices.length, "):"));
+                        _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        try {
+                            for(_iterator1 = argsWithChoices[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                arg = _step1.value;
+                                ;
+                                console.log("   • ".concat(arg.name, ": ").concat(((_arg_choices = arg.choices) === null || _arg_choices === void 0 ? void 0 : _arg_choices.join(', ')) || ''));
+                            }
+                        } catch (err) {
+                            _didIteratorError1 = true;
+                            _iteratorError1 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                    _iterator1.return();
+                                }
+                            } finally{
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
+                            }
+                        }
+                    }
+                    console.log();
+                    if (!matrixMode) return [
+                        3,
+                        19
+                    ];
+                    outputDir = options.output || 'examples';
+                    transports = [
+                        'stdio'
+                    ];
+                    // Add http transport if available
+                    httpPackage = metadataReader.getPackageForTransport(metadata, 'streamable-http');
+                    if (httpPackage) {
+                        transports.push('streamable-http');
+                    }
+                    // Build env vars for matrix generation (with dependsOn for conditional filtering)
+                    envVarsForMatrix = envVarsWithChoices.map(function(envVar) {
+                        return {
+                            name: envVar.name,
+                            choices: envVar.choices || [],
+                            dependsOn: envVar.dependsOn
+                        };
+                    });
+                    // Collect defaults for non-dimension env vars (ones without choices or non-mandatory)
+                    // Support both 'default' (MCP schema standard) and 'value' (legacy) fields
+                    defaults = {};
+                    _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                    try {
+                        _loop = function() {
+                            var envVar = _step2.value;
+                            if (!envVarsWithChoices.some(function(e) {
+                                return e.name === envVar.name;
+                            })) {
+                                var _envVar_default;
+                                var defaultValue = (_envVar_default = envVar.default) !== null && _envVar_default !== void 0 ? _envVar_default : envVar.value;
+                                if (defaultValue) {
+                                    defaults[envVar.name] = defaultValue;
+                                }
+                            }
+                        };
+                        for(_iterator2 = (stdioPackage.environmentVariables || [])[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true)_loop();
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
+                        }
+                    }
+                    // Generate combinations respecting dependsOn relationships (no unnecessary combinations)
+                    combinations = generateConditionalCombinations(envVarsForMatrix);
+                    _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+                    try {
+                        // Add defaults to each combination
+                        for(_iterator3 = combinations[Symbol.iterator](); !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                            combo = _step3.value;
+                            combo.defaults = defaults;
+                        }
+                    } catch (err) {
+                        _didIteratorError3 = true;
+                        _iteratorError3 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                                _iterator3.return();
+                            }
+                        } finally{
+                            if (_didIteratorError3) {
+                                throw _iteratorError3;
+                            }
+                        }
+                    }
+                    console.log("\uD83D\uDCCA Matrix mode: Generating ".concat(combinations.length, " combination(s) \xd7 ").concat(transports.length, " transport(s)"));
+                    console.log("   Output: ".concat(outputDir, "/"));
+                    console.log("   Transports: ".concat(transports.join(', ')));
+                    console.log();
+                    // Create output directory
+                    _fs.mkdirSync(outputDir, {
+                        recursive: true
+                    });
+                    // Default HTTP settings for matrix mode
+                    httpHost = 'localhost';
+                    httpPort = 3000;
+                    generatedCount = 0;
+                    _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+                    _state.label = 5;
+                case 5:
+                    _state.trys.push([
+                        5,
+                        16,
+                        17,
+                        18
+                    ]);
+                    _iterator4 = combinations[Symbol.iterator]();
+                    _state.label = 6;
+                case 6:
+                    if (!!(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done)) return [
+                        3,
+                        15
+                    ];
+                    combination = _step4.value;
+                    _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
+                    _state.label = 7;
+                case 7:
+                    _state.trys.push([
+                        7,
+                        12,
+                        13,
+                        14
+                    ]);
+                    _iterator5 = transports[Symbol.iterator]();
+                    _state.label = 8;
+                case 8:
+                    if (!!(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done)) return [
+                        3,
+                        11
+                    ];
+                    transport = _step5.value;
+                    return [
+                        4,
+                        generateConfigFile(_object_spread_props(_object_spread({
+                            serverName: serverName,
+                            combination: combination,
+                            transport: transport,
+                            outputDir: outputDir,
+                            packageName: packageName,
+                            packageDir: packageDir
+                        }, binPath !== undefined && {
+                            binPath: binPath
+                        }), {
+                            metadata: metadata,
+                            metadataReader: metadataReader,
+                            httpHost: httpHost,
+                            httpPort: httpPort,
+                            useSource: useSource,
+                            quick: true
+                        }))
+                    ];
+                case 9:
+                    _state.sent();
+                    generatedCount++;
+                    _state.label = 10;
+                case 10:
+                    _iteratorNormalCompletion5 = true;
+                    return [
+                        3,
+                        8
+                    ];
+                case 11:
+                    return [
+                        3,
+                        14
+                    ];
+                case 12:
+                    err = _state.sent();
+                    _didIteratorError5 = true;
+                    _iteratorError5 = err;
+                    return [
+                        3,
+                        14
+                    ];
+                case 13:
+                    try {
+                        if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                            _iterator5.return();
+                        }
+                    } finally{
+                        if (_didIteratorError5) {
+                            throw _iteratorError5;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 14:
+                    _iteratorNormalCompletion4 = true;
+                    return [
+                        3,
+                        6
+                    ];
+                case 15:
+                    return [
+                        3,
+                        18
+                    ];
+                case 16:
+                    err = _state.sent();
+                    _didIteratorError4 = true;
+                    _iteratorError4 = err;
+                    return [
+                        3,
+                        18
+                    ];
+                case 17:
+                    try {
+                        if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                            _iterator4.return();
+                        }
+                    } finally{
+                        if (_didIteratorError4) {
+                            throw _iteratorError4;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 18:
+                    console.log("\n✅ Generated ".concat(generatedCount, " config file(s) in ").concat(outputDir));
+                    return [
+                        2
+                    ];
+                case 19:
+                    return [
+                        4,
+                        (0, _select.default)({
+                            message: 'What do you want to configure?',
+                            choices: [
+                                {
+                                    name: 'Environment variables only',
+                                    value: 'env',
+                                    disabled: envVarsWithChoices.length === 0
+                                },
+                                {
+                                    name: 'Package arguments only',
+                                    value: 'args',
+                                    disabled: argsWithChoices.length === 0
+                                },
+                                {
+                                    name: 'Both environment variables and package arguments',
+                                    value: 'both',
+                                    disabled: envVarsWithChoices.length === 0 || argsWithChoices.length === 0
+                                },
+                                {
+                                    name: 'None (minimal server config)',
+                                    value: 'none'
+                                }
+                            ].filter(function(choice) {
+                                return !choice.disabled;
+                            })
+                        })
+                    ];
+                case 20:
+                    configMode = _state.sent();
+                    if (!(configMode === 'none')) return [
+                        3,
+                        29
+                    ];
+                    return [
+                        4,
+                        (0, _input.default)({
+                            message: 'Server name for mcpServers config:',
+                            default: serverName,
+                            validate: function(input) {
+                                return input.length > 0 || 'Server name is required';
+                            }
+                        })
+                    ];
+                case 21:
+                    finalServerName = _state.sent();
+                    if (!jsonOutput) return [
+                        3,
+                        22
+                    ];
+                    _tmp = '.';
+                    return [
+                        3,
+                        24
+                    ];
+                case 22:
+                    return [
+                        4,
+                        (0, _input.default)({
+                            message: 'Output directory:',
+                            default: '.'
+                        })
+                    ];
+                case 23:
+                    _tmp = _state.sent();
+                    _state.label = 24;
+                case 24:
+                    outputDir1 = _tmp;
+                    combination1 = {
+                        name: 'minimal',
+                        envKeys: [],
+                        argNames: [],
+                        defaults: {},
+                        argDefaults: {},
+                        dimensionValues: {}
+                    };
+                    if (!jsonOutput) return [
+                        3,
+                        26
+                    ];
+                    return [
+                        4,
+                        generateConfigObject(_object_spread_props(_object_spread({
+                            serverName: finalServerName,
+                            combination: combination1,
+                            transport: 'stdio',
+                            packageName: packageName,
+                            packageDir: packageDir
+                        }, binPath !== undefined && {
+                            binPath: binPath
+                        }), {
+                            metadata: metadata,
+                            metadataReader: metadataReader,
+                            useSource: useSource,
+                            quick: quickMode
+                        }))
+                    ];
+                case 25:
+                    config = _state.sent();
+                    console.log(JSON.stringify(config, null, 2));
+                    return [
+                        3,
+                        28
+                    ];
+                case 26:
+                    _fs.mkdirSync(outputDir1, {
+                        recursive: true
+                    });
+                    return [
+                        4,
+                        generateConfigFile(_object_spread_props(_object_spread({
+                            serverName: finalServerName,
+                            combination: combination1,
+                            transport: 'stdio',
+                            outputDir: outputDir1,
+                            packageName: packageName,
+                            packageDir: packageDir
+                        }, binPath !== undefined && {
+                            binPath: binPath
+                        }), {
+                            metadata: metadata,
+                            metadataReader: metadataReader,
+                            useSource: useSource,
+                            quick: quickMode
+                        }))
+                    ];
+                case 27:
+                    _state.sent();
+                    console.log("\n✅ Generated 1 config file in ".concat(outputDir1));
+                    _state.label = 28;
+                case 28:
+                    return [
+                        2
+                    ];
+                case 29:
+                    return [
+                        4,
+                        (0, _checkbox.default)({
+                            message: 'Select transports:',
+                            choices: [
+                                {
+                                    name: 'stdio',
+                                    value: 'stdio',
+                                    checked: true
+                                },
+                                {
+                                    name: 'http',
+                                    value: 'http',
+                                    checked: true
+                                }
+                            ],
+                            validate: function(choices) {
+                                return choices.length > 0 || 'Select at least one transport';
+                            }
+                        })
+                    ];
+                case 30:
+                    transports1 = _state.sent();
+                    // 7. HTTP configuration if HTTP transport selected
+                    httpHost1 = 'localhost';
+                    httpPort1 = 3000;
+                    if (!transports1.includes('http')) return [
+                        3,
+                        33
+                    ];
+                    return [
+                        4,
+                        (0, _input.default)({
+                            message: 'HTTP host:',
+                            default: 'localhost'
+                        })
+                    ];
+                case 31:
+                    httpHost1 = _state.sent();
+                    return [
+                        4,
+                        (0, _input.default)({
+                            message: 'HTTP port:',
+                            default: '3000',
+                            validate: function(input) {
+                                var port = Number.parseInt(input, 10);
+                                return !Number.isNaN(port) && port > 0 && port < 65536 || 'Port must be between 1 and 65535';
+                            }
+                        })
+                    ];
+                case 32:
+                    portStr = _state.sent();
+                    httpPort1 = Number.parseInt(portStr, 10);
+                    _state.label = 33;
+                case 33:
+                    // 8. Collect available dimensions based on configuration mode
+                    availableDimensions = [];
+                    if (configMode === 'env' || configMode === 'both') {
+                        _iteratorNormalCompletion6 = true, _didIteratorError6 = false, _iteratorError6 = undefined;
+                        try {
+                            for(_iterator6 = envVarsWithChoices[Symbol.iterator](); !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true){
+                                envVar1 = _step6.value;
+                                availableDimensions.push({
+                                    name: envVar1.name,
+                                    type: 'env',
+                                    choices: envVar1.choices || []
+                                });
+                            }
+                        } catch (err) {
+                            _didIteratorError6 = true;
+                            _iteratorError6 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+                                    _iterator6.return();
+                                }
+                            } finally{
+                                if (_didIteratorError6) {
+                                    throw _iteratorError6;
+                                }
+                            }
+                        }
+                    }
+                    if (configMode === 'args' || configMode === 'both') {
+                        _iteratorNormalCompletion7 = true, _didIteratorError7 = false, _iteratorError7 = undefined;
+                        try {
+                            for(_iterator7 = argsWithChoices[Symbol.iterator](); !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true){
+                                arg1 = _step7.value;
+                                availableDimensions.push({
+                                    name: arg1.name,
+                                    type: 'arg',
+                                    choices: arg1.choices
+                                });
+                            }
+                        } catch (err) {
+                            _didIteratorError7 = true;
+                            _iteratorError7 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+                                    _iterator7.return();
+                                }
+                            } finally{
+                                if (_didIteratorError7) {
+                                    throw _iteratorError7;
+                                }
+                            }
+                        }
+                    }
+                    return [
+                        4,
+                        (0, _checkbox.default)({
+                            message: 'Select dimensions to generate combinations from (order determines filename pattern):',
+                            choices: availableDimensions.map(function(d) {
+                                return {
+                                    name: "".concat(d.type === 'env' ? 'ENV' : 'ARG', " ").concat(d.name, " (").concat(d.choices.join(', '), ")"),
+                                    value: d.name,
+                                    checked: true
+                                };
+                            }),
+                            validate: function(choices) {
+                                return choices.length > 0 || 'Select at least one dimension';
+                            }
+                        })
+                    ];
+                case 34:
+                    selectedDimensionNames = _state.sent();
+                    selectedDimensions = availableDimensions.filter(function(d) {
+                        return selectedDimensionNames.includes(d.name);
+                    });
+                    // 9. For each dimension, select which choices to include (with "skip" option)
+                    dimensionsWithFilteredChoices = [];
+                    _iteratorNormalCompletion8 = true, _didIteratorError8 = false, _iteratorError8 = undefined;
+                    _state.label = 35;
+                case 35:
+                    _state.trys.push([
+                        35,
+                        40,
+                        41,
+                        42
+                    ]);
+                    _iterator8 = selectedDimensions[Symbol.iterator]();
+                    _state.label = 36;
+                case 36:
+                    if (!!(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done)) return [
+                        3,
+                        39
+                    ];
+                    dim = _step8.value;
+                    choicesWithSkip = _to_consumable_array(dim.choices).concat([
+                        'skip'
+                    ]);
+                    return [
+                        4,
+                        (0, _checkbox.default)({
+                            message: "For ".concat(dim.type === 'env' ? 'ENV' : 'ARG', " ").concat(dim.name, ", select choices to include:"),
+                            choices: choicesWithSkip.map(function(choice) {
+                                return {
+                                    name: choice === 'skip' ? 'skip (do not configure)' : choice,
+                                    value: choice,
+                                    checked: choice !== 'skip'
+                                };
+                            }),
+                            validate: function(choices) {
+                                return choices.length > 0 || 'Select at least one choice (or skip)';
+                            }
+                        })
+                    ];
+                case 37:
+                    selectedChoices = _state.sent();
+                    dimensionsWithFilteredChoices.push(_object_spread_props(_object_spread({}, dim), {
+                        choices: selectedChoices
+                    }));
+                    _state.label = 38;
+                case 38:
+                    _iteratorNormalCompletion8 = true;
+                    return [
+                        3,
+                        36
+                    ];
+                case 39:
+                    return [
+                        3,
+                        42
+                    ];
+                case 40:
+                    err = _state.sent();
+                    _didIteratorError8 = true;
+                    _iteratorError8 = err;
+                    return [
+                        3,
+                        42
+                    ];
+                case 41:
+                    try {
+                        if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+                            _iterator8.return();
+                        }
+                    } finally{
+                        if (_didIteratorError8) {
+                            throw _iteratorError8;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 42:
+                    // 10. For non-dimensions with choices, get default values (including "skip")
+                    dimensionNames = selectedDimensions.map(function(d) {
+                        return d.name;
+                    });
+                    nonDimensionEnvVars = envVarsWithChoices.filter(function(e) {
+                        return !dimensionNames.includes(e.name);
+                    });
+                    nonDimensionArgs = argsWithChoices.filter(function(a) {
+                        return !dimensionNames.includes(a.name);
+                    });
+                    defaults1 = {};
+                    argDefaults = {};
+                    if (!(configMode === 'env' || configMode === 'both')) return [
+                        3,
+                        50
+                    ];
+                    _iteratorNormalCompletion9 = true, _didIteratorError9 = false, _iteratorError9 = undefined;
+                    _state.label = 43;
+                case 43:
+                    _state.trys.push([
+                        43,
+                        48,
+                        49,
+                        50
+                    ]);
+                    _iterator9 = nonDimensionEnvVars[Symbol.iterator]();
+                    _state.label = 44;
+                case 44:
+                    if (!!(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done)) return [
+                        3,
+                        47
+                    ];
+                    envVar2 = _step9.value;
+                    choicesWithSkip1 = _to_consumable_array(envVar2.choices || []).concat([
+                        'skip'
+                    ]);
+                    return [
+                        4,
+                        (0, _select.default)({
+                            message: "Select default value for ENV ".concat(envVar2.name, " (used in all configs)"),
+                            choices: choicesWithSkip1.map(function(c) {
+                                return {
+                                    name: c === 'skip' ? 'skip (do not configure)' : c,
+                                    value: c
+                                };
+                            })
+                        })
+                    ];
+                case 45:
+                    defaultValue = _state.sent();
+                    if (defaultValue !== 'skip') {
+                        defaults1[envVar2.name] = defaultValue;
+                    }
+                    _state.label = 46;
+                case 46:
+                    _iteratorNormalCompletion9 = true;
+                    return [
+                        3,
+                        44
+                    ];
+                case 47:
+                    return [
+                        3,
+                        50
+                    ];
+                case 48:
+                    err = _state.sent();
+                    _didIteratorError9 = true;
+                    _iteratorError9 = err;
+                    return [
+                        3,
+                        50
+                    ];
+                case 49:
+                    try {
+                        if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+                            _iterator9.return();
+                        }
+                    } finally{
+                        if (_didIteratorError9) {
+                            throw _iteratorError9;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 50:
+                    if (!(configMode === 'args' || configMode === 'both')) return [
+                        3,
+                        58
+                    ];
+                    _iteratorNormalCompletion10 = true, _didIteratorError10 = false, _iteratorError10 = undefined;
+                    _state.label = 51;
+                case 51:
+                    _state.trys.push([
+                        51,
+                        56,
+                        57,
+                        58
+                    ]);
+                    _iterator10 = nonDimensionArgs[Symbol.iterator]();
+                    _state.label = 52;
+                case 52:
+                    if (!!(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done)) return [
+                        3,
+                        55
+                    ];
+                    arg2 = _step10.value;
+                    choicesWithSkip2 = _to_consumable_array(arg2.choices).concat([
+                        'skip'
+                    ]);
+                    return [
+                        4,
+                        (0, _select.default)({
+                            message: "Select default value for ARG ".concat(arg2.name, " (used in all configs)"),
+                            choices: choicesWithSkip2.map(function(c) {
+                                return {
+                                    name: c === 'skip' ? 'skip (do not configure)' : c,
+                                    value: c
+                                };
+                            })
+                        })
+                    ];
+                case 53:
+                    defaultValue1 = _state.sent();
+                    if (defaultValue1 !== 'skip') {
+                        argDefaults[arg2.name] = defaultValue1;
+                    }
+                    _state.label = 54;
+                case 54:
+                    _iteratorNormalCompletion10 = true;
+                    return [
+                        3,
+                        52
+                    ];
+                case 55:
+                    return [
+                        3,
+                        58
+                    ];
+                case 56:
+                    err = _state.sent();
+                    _didIteratorError10 = true;
+                    _iteratorError10 = err;
+                    return [
+                        3,
+                        58
+                    ];
+                case 57:
+                    try {
+                        if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+                            _iterator10.return();
+                        }
+                    } finally{
+                        if (_didIteratorError10) {
+                            throw _iteratorError10;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 58:
+                    // 11. Generate combinations as cartesian product
+                    combinations1 = generateCartesianProduct(dimensionsWithFilteredChoices).map(function(choiceValues) {
+                        // Build name from dimensions that have multiple choices (single-choice dimensions don't add discriminating value)
+                        // Also filter out "skip" values
+                        var nameParts = [];
+                        for(var i = 0; i < choiceValues.length; i++){
+                            var dim = dimensionsWithFilteredChoices[i];
+                            var value = choiceValues[i];
+                            // Only include in name if: not "skip" AND dimension has multiple selected choices
+                            if (dim && value !== 'skip' && dim.choices.filter(function(c) {
+                                return c !== 'skip';
+                            }).length > 1) {
+                                nameParts.push(value || '');
+                            }
+                        }
+                        var name = nameParts.length > 0 ? nameParts.join('-').toLowerCase() : 'defaults';
+                        // Map choice values back to dimension names (excluding "skip")
+                        var dimensionValues = {};
+                        for(var i1 = 0; i1 < choiceValues.length; i1++){
+                            var dimension = dimensionsWithFilteredChoices[i1];
+                            var value1 = choiceValues[i1];
+                            if (dimension && value1 !== 'skip') {
+                                dimensionValues[dimension.name] = value1 || '';
+                            }
+                        }
+                        // Include env vars and args based on what's configured
+                        var allEnvKeys = (stdioPackage.environmentVariables || []).map(function(e) {
+                            return e.name;
+                        });
+                        var allArgNames = (stdioPackage.packageArguments || []).map(function(a) {
+                            return a.name;
+                        });
+                        return {
+                            name: name,
+                            envKeys: configMode === 'env' || configMode === 'both' ? allEnvKeys : [],
+                            argNames: configMode === 'args' || configMode === 'both' ? allArgNames : [],
+                            defaults: defaults1,
+                            argDefaults: argDefaults,
+                            dimensionValues: dimensionValues
+                        };
+                    });
+                    // 12. Show preview with final counts
+                    totalConfigs = combinations1.length * transports1.length;
+                    console.log('\n📋 Preview:');
+                    console.log("   ".concat(combinations1.length, " combination(s) \xd7 ").concat(transports1.length, " transport(s) = ").concat(totalConfigs, " config file(s)"));
+                    console.log('\n   Combinations:');
+                    _iteratorNormalCompletion11 = true, _didIteratorError11 = false, _iteratorError11 = undefined;
+                    try {
+                        for(_iterator11 = combinations1[Symbol.iterator](); !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true){
+                            combo1 = _step11.value;
+                            console.log("   • ".concat(combo1.name));
+                        }
+                    } catch (err) {
+                        _didIteratorError11 = true;
+                        _iteratorError11 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+                                _iterator11.return();
+                            }
+                        } finally{
+                            if (_didIteratorError11) {
+                                throw _iteratorError11;
+                            }
+                        }
+                    }
+                    console.log("\n   Transports: ".concat(transports1.join(', ')));
+                    if (Object.keys(defaults1).length > 0) {
+                        console.log('\n   Default ENV values (used in all configs):');
+                        _iteratorNormalCompletion12 = true, _didIteratorError12 = false, _iteratorError12 = undefined;
+                        try {
+                            for(_iterator12 = Object.entries(defaults1)[Symbol.iterator](); !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true){
+                                _step_value = _sliced_to_array(_step12.value, 2), key = _step_value[0], value = _step_value[1];
+                                console.log("   • ".concat(key, "=").concat(value));
+                            }
+                        } catch (err) {
+                            _didIteratorError12 = true;
+                            _iteratorError12 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                                    _iterator12.return();
+                                }
+                            } finally{
+                                if (_didIteratorError12) {
+                                    throw _iteratorError12;
+                                }
+                            }
+                        }
+                    }
+                    if (Object.keys(argDefaults).length > 0) {
+                        console.log('\n   Default ARG values (used in all configs):');
+                        _iteratorNormalCompletion13 = true, _didIteratorError13 = false, _iteratorError13 = undefined;
+                        try {
+                            for(_iterator13 = Object.entries(argDefaults)[Symbol.iterator](); !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true){
+                                _step_value1 = _sliced_to_array(_step13.value, 2), key1 = _step_value1[0], value1 = _step_value1[1];
+                                console.log("   • ".concat(key1, "=").concat(value1));
+                            }
+                        } catch (err) {
+                            _didIteratorError13 = true;
+                            _iteratorError13 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+                                    _iterator13.return();
+                                }
+                            } finally{
+                                if (_didIteratorError13) {
+                                    throw _iteratorError13;
+                                }
+                            }
+                        }
+                    }
+                    console.log();
+                    return [
+                        4,
+                        (0, _select.default)({
+                            message: 'How would you like to proceed?',
+                            choices: [
+                                {
+                                    name: 'Generate all configurations',
+                                    value: 'all'
+                                },
+                                {
+                                    name: 'Select specific configurations',
+                                    value: 'select'
+                                },
+                                {
+                                    name: 'Cancel',
+                                    value: 'cancel'
+                                }
+                            ]
+                        })
+                    ];
+                case 59:
+                    generationMode = _state.sent();
+                    if (generationMode === 'cancel') {
+                        console.log('❌ Cancelled');
+                        process.exit(0);
+                    }
+                    // Build all config choices
+                    allChoices = createConfigChoices(combinations1, transports1);
+                    if (!(generationMode === 'select')) return [
+                        3,
+                        61
+                    ];
+                    return [
+                        4,
+                        (0, _checkbox.default)({
+                            message: 'Select configurations to generate:',
+                            choices: allChoices.map(function(choice) {
+                                return {
+                                    name: choice.label,
+                                    value: choice.label,
+                                    checked: true
+                                };
+                            }),
+                            required: true
+                        })
+                    ];
+                case 60:
+                    selectedLabels = _state.sent();
+                    selectedConfigs = filterConfigChoices(allChoices, selectedLabels);
+                    if (selectedConfigs.length === 0) {
+                        console.log('❌ No configurations selected');
+                        process.exit(0);
+                    }
+                    console.log("\n\uD83D\uDCCB Selected ".concat(selectedConfigs.length, " configuration(s)"));
+                    return [
+                        3,
+                        62
+                    ];
+                case 61:
+                    // Generate all
+                    selectedConfigs = allChoices;
+                    _state.label = 62;
+                case 62:
+                    return [
+                        4,
+                        (0, _input.default)({
+                            message: 'Server name for mcpServers config:',
+                            default: serverName,
+                            validate: function(input) {
+                                return input.length > 0 || 'Server name is required';
+                            }
+                        })
+                    ];
+                case 63:
+                    finalServerName1 = _state.sent();
+                    if (!jsonOutput) return [
+                        3,
+                        64
+                    ];
+                    _tmp1 = '.';
+                    return [
+                        3,
+                        66
+                    ];
+                case 64:
+                    return [
+                        4,
+                        (0, _input.default)({
+                            message: 'Output directory:',
+                            default: '.'
+                        })
+                    ];
+                case 65:
+                    _tmp1 = _state.sent();
+                    _state.label = 66;
+                case 66:
+                    outputDir2 = _tmp1;
+                    // 13a. Select which optional env vars to prompt for (per-config prompting happens later)
+                    // This is just a FILTER - actual prompting happens in buildServerConfig with config context
+                    optionalVarsToPrompt = new Set();
+                    if (!(!quickMode && process.stdin.isTTY)) return [
+                        3,
+                        70
+                    ];
+                    envVarsWithContext = new Map();
+                    // Get the primary dimension (usually AUTH_MODE) for context grouping
+                    primaryDimensionName = selectedDimensions.length > 0 ? (_selectedDimensions_ = selectedDimensions[0]) === null || _selectedDimensions_ === void 0 ? void 0 : _selectedDimensions_.name : undefined;
+                    _iteratorNormalCompletion14 = true, _didIteratorError14 = false, _iteratorError14 = undefined;
+                    try {
+                        for(_iterator14 = selectedConfigs[Symbol.iterator](); !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true){
+                            combination2 = _step14.value.combination;
+                            allEnvVars = stdioPackage.environmentVariables || [];
+                            _iteratorNormalCompletion15 = true, _didIteratorError15 = false, _iteratorError15 = undefined;
+                            try {
+                                for(_iterator15 = allEnvVars[Symbol.iterator](); !(_iteratorNormalCompletion15 = (_step15 = _iterator15.next()).done); _iteratorNormalCompletion15 = true){
+                                    envVar3 = _step15.value;
+                                    // Skip if already in defaults or dimension values
+                                    if (combination2.envKeys.includes(envVar3.name) && Object.keys(combination2.dimensionValues).includes(envVar3.name)) {
+                                        continue;
+                                    }
+                                    if (Object.keys(combination2.defaults).includes(envVar3.name)) {
+                                        continue;
+                                    }
+                                    // Check dependsOn
+                                    if (!shouldPromptEnvVar(envVar3, combination2.dimensionValues)) {
+                                        continue;
+                                    }
+                                    // Only collect optional env vars (required ones are always prompted per-config)
+                                    if (!envVar3.isRequired) {
+                                        if (!envVarsWithContext.has(envVar3.name)) {
+                                            envVarsWithContext.set(envVar3.name, {
+                                                envVar: envVar3,
+                                                relevantModes: new Set(),
+                                                appliesToAll: !envVar3.dependsOn
+                                            });
+                                        }
+                                        context = envVarsWithContext.get(envVar3.name);
+                                        // Track which primary dimension value this var is relevant to
+                                        if (context && primaryDimensionName && combination2.dimensionValues[primaryDimensionName]) {
+                                            context.relevantModes.add(combination2.dimensionValues[primaryDimensionName]);
+                                        }
+                                    }
+                                }
+                            } catch (err) {
+                                _didIteratorError15 = true;
+                                _iteratorError15 = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion15 && _iterator15.return != null) {
+                                        _iterator15.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError15) {
+                                        throw _iteratorError15;
+                                    }
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError14 = true;
+                        _iteratorError14 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
+                                _iterator14.return();
+                            }
+                        } finally{
+                            if (_didIteratorError14) {
+                                throw _iteratorError14;
+                            }
+                        }
+                    }
+                    if (!(envVarsWithContext.size > 0)) return [
+                        3,
+                        70
+                    ];
+                    // Group env vars by their relevance for clearer display
+                    allSelectedModes = new Set(selectedConfigs.map(function(c) {
+                        return primaryDimensionName ? c.combination.dimensionValues[primaryDimensionName] : '';
+                    }).filter(Boolean));
+                    groupedVars = new Map();
+                    _iteratorNormalCompletion16 = true, _didIteratorError16 = false, _iteratorError16 = undefined;
+                    try {
+                        for(_iterator16 = envVarsWithContext.values()[Symbol.iterator](); !(_iteratorNormalCompletion16 = (_step16 = _iterator16.next()).done); _iteratorNormalCompletion16 = true){
+                            _step_value2 = _step16.value, envVar4 = _step_value2.envVar, relevantModes = _step_value2.relevantModes, appliesToAll = _step_value2.appliesToAll;
+                            ;
+                            groupKey = void 0;
+                            if (appliesToAll || relevantModes.size === allSelectedModes.size) {
+                                groupKey = 'all';
+                            } else {
+                                // Sort modes for consistent display
+                                groupKey = Array.from(relevantModes).sort().join(', ');
+                            }
+                            if (!groupedVars.has(groupKey)) {
+                                groupedVars.set(groupKey, []);
+                            }
+                            (_groupedVars_get = groupedVars.get(groupKey)) === null || _groupedVars_get === void 0 ? void 0 : _groupedVars_get.push(envVar4);
+                        }
+                    } catch (err) {
+                        _didIteratorError16 = true;
+                        _iteratorError16 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion16 && _iterator16.return != null) {
+                                _iterator16.return();
+                            }
+                        } finally{
+                            if (_didIteratorError16) {
+                                throw _iteratorError16;
+                            }
+                        }
+                    }
+                    console.log("\n\uD83D\uDCCB ".concat(envVarsWithContext.size, " optional env var(s) can be configured:"));
+                    // Build template vars from HTTP settings for placeholder substitution
+                    templateVars = {};
+                    if (transports1.includes('http') || transports1.includes('streamable-http')) {
+                        templateVars.HOST = httpHost1;
+                        templateVars.PORT = String(httpPort1);
+                    }
+                    _iteratorNormalCompletion17 = true, _didIteratorError17 = false, _iteratorError17 = undefined;
+                    try {
+                        // Display grouped by relevance
+                        for(_iterator17 = groupedVars.entries()[Symbol.iterator](); !(_iteratorNormalCompletion17 = (_step17 = _iterator17.next()).done); _iteratorNormalCompletion17 = true){
+                            _step_value3 = _sliced_to_array(_step17.value, 2), groupKey1 = _step_value3[0], vars = _step_value3[1];
+                            if (groupKey1 === 'all') {
+                                console.log('\n   For all configurations:');
+                            } else {
+                                console.log("\n   For ".concat(groupKey1, " mode:"));
+                            }
+                            _iteratorNormalCompletion18 = true, _didIteratorError18 = false, _iteratorError18 = undefined;
+                            try {
+                                for(_iterator18 = vars[Symbol.iterator](); !(_iteratorNormalCompletion18 = (_step18 = _iterator18.next()).done); _iteratorNormalCompletion18 = true){
+                                    envVar5 = _step18.value;
+                                    ;
+                                    rawDefault = (_ref = (_envVar_default = envVar5.default) !== null && _envVar_default !== void 0 ? _envVar_default : envVar5.value) !== null && _ref !== void 0 ? _ref : envVar5.placeholder;
+                                    defaultVal = (0, _envpromptingts.substituteTemplateVars)(rawDefault, templateVars);
+                                    label = defaultVal ? "(default: ".concat(defaultVal, ")") : '(no default)';
+                                    console.log("   • ".concat(envVar5.name, " - ").concat(envVar5.description || 'optional', " ").concat(label));
+                                }
+                            } catch (err) {
+                                _didIteratorError18 = true;
+                                _iteratorError18 = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion18 && _iterator18.return != null) {
+                                        _iterator18.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError18) {
+                                        throw _iteratorError18;
+                                    }
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError17 = true;
+                        _iteratorError17 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion17 && _iterator17.return != null) {
+                                _iterator17.return();
+                            }
+                        } finally{
+                            if (_didIteratorError17) {
+                                throw _iteratorError17;
+                            }
+                        }
+                    }
+                    // Build flat list of all optional var names for checkbox selection
+                    allOptionalVarNames = Array.from(envVarsWithContext.keys());
+                    return [
+                        4,
+                        (0, _select.default)({
+                            message: '\nConfigure optional env vars?',
+                            choices: [
+                                {
+                                    name: 'None (use defaults)',
+                                    value: 'none'
+                                },
+                                {
+                                    name: 'All (prompt for each config)',
+                                    value: 'all'
+                                },
+                                {
+                                    name: 'Select specific ones',
+                                    value: 'select'
+                                }
+                            ],
+                            default: 'none'
+                        })
+                    ];
+                case 67:
+                    configureChoice = _state.sent();
+                    if (!(configureChoice === 'all')) return [
+                        3,
+                        68
+                    ];
+                    _iteratorNormalCompletion19 = true, _didIteratorError19 = false, _iteratorError19 = undefined;
+                    try {
+                        // Add all optional vars to the prompt set
+                        for(_iterator19 = allOptionalVarNames[Symbol.iterator](); !(_iteratorNormalCompletion19 = (_step19 = _iterator19.next()).done); _iteratorNormalCompletion19 = true){
+                            name = _step19.value;
+                            optionalVarsToPrompt.add(name);
+                        }
+                    } catch (err) {
+                        _didIteratorError19 = true;
+                        _iteratorError19 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion19 && _iterator19.return != null) {
+                                _iterator19.return();
+                            }
+                        } finally{
+                            if (_didIteratorError19) {
+                                throw _iteratorError19;
+                            }
+                        }
+                    }
+                    return [
+                        3,
+                        70
+                    ];
+                case 68:
+                    if (!(configureChoice === 'select')) return [
+                        3,
+                        70
+                    ];
+                    // Show multi-select checkbox grouped by relevance
+                    checkboxChoices = [];
+                    _iteratorNormalCompletion20 = true, _didIteratorError20 = false, _iteratorError20 = undefined;
+                    try {
+                        for(_iterator20 = groupedVars.entries()[Symbol.iterator](); !(_iteratorNormalCompletion20 = (_step20 = _iterator20.next()).done); _iteratorNormalCompletion20 = true){
+                            _step_value4 = _sliced_to_array(_step20.value, 2), groupKey2 = _step_value4[0], vars1 = _step_value4[1];
+                            // Add group separator
+                            checkboxChoices.push({
+                                name: groupKey2 === 'all' ? '── For all configurations ──' : "── For ".concat(groupKey2, " mode ──"),
+                                value: "__separator__".concat(groupKey2),
+                                disabled: ' '
+                            });
+                            _iteratorNormalCompletion21 = true, _didIteratorError21 = false, _iteratorError21 = undefined;
+                            try {
+                                for(_iterator21 = vars1[Symbol.iterator](); !(_iteratorNormalCompletion21 = (_step21 = _iterator21.next()).done); _iteratorNormalCompletion21 = true){
+                                    envVar6 = _step21.value;
+                                    ;
+                                    rawDefault1 = (_ref1 = (_envVar_default1 = envVar6.default) !== null && _envVar_default1 !== void 0 ? _envVar_default1 : envVar6.value) !== null && _ref1 !== void 0 ? _ref1 : envVar6.placeholder;
+                                    defaultVal1 = (0, _envpromptingts.substituteTemplateVars)(rawDefault1, templateVars);
+                                    label1 = defaultVal1 ? " (default: ".concat(defaultVal1, ")") : '';
+                                    checkboxChoices.push({
+                                        name: "".concat(envVar6.name, " - ").concat(envVar6.description || 'optional').concat(label1),
+                                        value: envVar6.name
+                                    });
+                                }
+                            } catch (err) {
+                                _didIteratorError21 = true;
+                                _iteratorError21 = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion21 && _iterator21.return != null) {
+                                        _iterator21.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError21) {
+                                        throw _iteratorError21;
+                                    }
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError20 = true;
+                        _iteratorError20 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion20 && _iterator20.return != null) {
+                                _iterator20.return();
+                            }
+                        } finally{
+                            if (_didIteratorError20) {
+                                throw _iteratorError20;
+                            }
+                        }
+                    }
+                    return [
+                        4,
+                        (0, _checkbox.default)({
+                            message: 'Select which env vars to configure:',
+                            choices: checkboxChoices
+                        })
+                    ];
+                case 69:
+                    selectedVarNames = _state.sent();
+                    _iteratorNormalCompletion22 = true, _didIteratorError22 = false, _iteratorError22 = undefined;
+                    try {
+                        // Add selected vars to the prompt set (excluding separators)
+                        for(_iterator22 = selectedVarNames[Symbol.iterator](); !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true){
+                            name1 = _step22.value;
+                            if (!name1.startsWith('__separator__')) {
+                                optionalVarsToPrompt.add(name1);
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError22 = true;
+                        _iteratorError22 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
+                                _iterator22.return();
+                            }
+                        } finally{
+                            if (_didIteratorError22) {
+                                throw _iteratorError22;
+                            }
+                        }
+                    }
+                    _state.label = 70;
+                case 70:
+                    if (!jsonOutput) return [
+                        3,
+                        79
+                    ];
+                    // Output selected configs as JSON array to stdout
+                    configs = [];
+                    _iteratorNormalCompletion23 = true, _didIteratorError23 = false, _iteratorError23 = undefined;
+                    _state.label = 71;
+                case 71:
+                    _state.trys.push([
+                        71,
+                        76,
+                        77,
+                        78
+                    ]);
+                    _iterator23 = selectedConfigs[Symbol.iterator]();
+                    _state.label = 72;
+                case 72:
+                    if (!!(_iteratorNormalCompletion23 = (_step23 = _iterator23.next()).done)) return [
+                        3,
+                        75
+                    ];
+                    _step_value5 = _step23.value, combination3 = _step_value5.combination, transport1 = _step_value5.transport;
+                    return [
+                        4,
+                        generateConfigObject(_object_spread_props(_object_spread({
+                            serverName: finalServerName1,
+                            combination: combination3,
+                            transport: transport1,
+                            packageName: packageName,
+                            packageDir: packageDir
+                        }, binPath !== undefined && {
+                            binPath: binPath
+                        }), {
+                            metadata: metadata,
+                            metadataReader: metadataReader,
+                            httpHost: httpHost1,
+                            httpPort: httpPort1,
+                            useSource: useSource,
+                            quick: quickMode,
+                            optionalVarsToPrompt: optionalVarsToPrompt
+                        }))
+                    ];
+                case 73:
+                    config1 = _state.sent();
+                    configs.push(config1);
+                    _state.label = 74;
+                case 74:
+                    _iteratorNormalCompletion23 = true;
+                    return [
+                        3,
+                        72
+                    ];
+                case 75:
+                    return [
+                        3,
+                        78
+                    ];
+                case 76:
+                    err = _state.sent();
+                    _didIteratorError23 = true;
+                    _iteratorError23 = err;
+                    return [
+                        3,
+                        78
+                    ];
+                case 77:
+                    try {
+                        if (!_iteratorNormalCompletion23 && _iterator23.return != null) {
+                            _iterator23.return();
+                        }
+                    } finally{
+                        if (_didIteratorError23) {
+                            throw _iteratorError23;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 78:
+                    console.log(JSON.stringify(configs, null, 2));
+                    return [
+                        3,
+                        88
+                    ];
+                case 79:
+                    _fs.mkdirSync(outputDir2, {
+                        recursive: true
+                    });
+                    generatedCount1 = 0;
+                    _iteratorNormalCompletion24 = true, _didIteratorError24 = false, _iteratorError24 = undefined;
+                    _state.label = 80;
+                case 80:
+                    _state.trys.push([
+                        80,
+                        85,
+                        86,
+                        87
+                    ]);
+                    _iterator24 = selectedConfigs[Symbol.iterator]();
+                    _state.label = 81;
+                case 81:
+                    if (!!(_iteratorNormalCompletion24 = (_step24 = _iterator24.next()).done)) return [
+                        3,
+                        84
+                    ];
+                    _step_value6 = _step24.value, combination4 = _step_value6.combination, transport2 = _step_value6.transport;
+                    return [
+                        4,
+                        generateConfigFile(_object_spread_props(_object_spread({
+                            serverName: finalServerName1,
+                            combination: combination4,
+                            transport: transport2,
+                            outputDir: outputDir2,
+                            packageName: packageName,
+                            packageDir: packageDir
+                        }, binPath !== undefined && {
+                            binPath: binPath
+                        }), {
+                            metadata: metadata,
+                            metadataReader: metadataReader,
+                            httpHost: httpHost1,
+                            httpPort: httpPort1,
+                            useSource: useSource,
+                            quick: quickMode,
+                            optionalVarsToPrompt: optionalVarsToPrompt
+                        }))
+                    ];
+                case 82:
+                    success = _state.sent();
+                    if (success) {
+                        generatedCount1++;
+                    }
+                    _state.label = 83;
+                case 83:
+                    _iteratorNormalCompletion24 = true;
+                    return [
+                        3,
+                        81
+                    ];
+                case 84:
+                    return [
+                        3,
+                        87
+                    ];
+                case 85:
+                    err = _state.sent();
+                    _didIteratorError24 = true;
+                    _iteratorError24 = err;
+                    return [
+                        3,
+                        87
+                    ];
+                case 86:
+                    try {
+                        if (!_iteratorNormalCompletion24 && _iterator24.return != null) {
+                            _iterator24.return();
+                        }
+                    } finally{
+                        if (_didIteratorError24) {
+                            throw _iteratorError24;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 87:
+                    console.log("\n✅ Generated ".concat(generatedCount1, " config file(s) in ").concat(outputDir2));
+                    _state.label = 88;
+                case 88:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function discoverServerJson() {
+    var basePath = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : process.cwd();
+    // Check current directory
+    var currentPath = _path.join(basePath, 'server.json');
+    if (_fs.existsSync(currentPath)) {
+        return currentPath;
+    }
+    // Check parent directory (for monorepo structure)
+    var parentPath = _path.join(basePath, '..', 'server.json');
+    if (_fs.existsSync(parentPath)) {
+        return parentPath;
+    }
+    return null;
+}
+function extractServerName(packageName) {
+    // Strip org prefix if present: "@org/package" -> "package"
+    var withoutOrg = packageName.replace(/^@[^/]+\//, '');
+    return withoutOrg || 'server';
+}
+/** Build config object (shared logic) */ function buildServerConfig(_0) {
+    return _async_to_generator(function(params) {
+        var envPromptFn, transportType, pkg, envDimensions, argDimensions, allPackageArgNames, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, relevantEnvVars, envVarsMatchingDependsOn, allEnvVars, filteredDefaults, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _loop, _iterator1, _step1, envDefaultKeys, envDimensionKeys, prePopulatedEnvKeys, envVarsToPrompt, requiredVars, selectedOptionalVars, promptContext, templateVars, promptedEnv, env, command, args, absolutePackageDir, relativePath, allArgValues, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _step_value1, argName, argValue, _params_httpPort, port, serverConfig, _params_httpHost, _params_httpPort1, startBlock, httpConfig, stdioConfig;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    envPromptFn = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : _envpromptingts.promptForEnvVars;
+                    // Get package config for transport
+                    transportType = params.transport === 'http' ? 'streamable-http' : 'stdio';
+                    pkg = params.metadataReader.getPackageForTransport(params.metadata, transportType);
+                    if (!pkg) {
+                        throw new Error("No ".concat(params.transport, " transport available"));
+                    }
+                    // Separate env vars and package args from dimensionValues
+                    envDimensions = {};
+                    argDimensions = {};
+                    allPackageArgNames = (pkg.packageArguments || []).map(function(a) {
+                        return a.name;
+                    });
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = Object.entries(params.combination.dimensionValues)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                            if (allPackageArgNames.includes(key)) {
+                                argDimensions[key] = value;
+                            } else {
+                                envDimensions[key] = value;
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    // Filter environmentVariables based on combination's envKeys
+                    relevantEnvVars = (pkg.environmentVariables || []).filter(function(envVar) {
+                        return params.combination.envKeys.includes(envVar.name);
+                    });
+                    // Filter by dependsOn - only prompt for env vars relevant to this combination's dimension values
+                    envVarsMatchingDependsOn = relevantEnvVars.filter(function(envVar) {
+                        return shouldPromptEnvVar(envVar, params.combination.dimensionValues);
+                    });
+                    // Filter defaults to only include env vars whose dependsOn is satisfied for this combination
+                    // This ensures DCR_STORE_URI isn't included when AUTH_MODE=loopback-oauth, etc.
+                    allEnvVars = pkg.environmentVariables || [];
+                    filteredDefaults = {};
+                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        _loop = function() {
+                            var _step_value = _sliced_to_array(_step1.value, 2), envName = _step_value[0], envValue = _step_value[1];
+                            var envVarMeta = allEnvVars.find(function(e) {
+                                return e.name === envName;
+                            });
+                            if (!envVarMeta || shouldPromptEnvVar(envVarMeta, params.combination.dimensionValues)) {
+                                filteredDefaults[envName] = envValue;
+                            }
+                        };
+                        for(_iterator1 = Object.entries(params.combination.defaults)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true)_loop();
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                    // Separate env vars into those with pre-populated values and those to prompt for
+                    envDefaultKeys = Object.keys(filteredDefaults);
+                    envDimensionKeys = Object.keys(envDimensions);
+                    prePopulatedEnvKeys = _to_consumable_array(envDefaultKeys).concat(_to_consumable_array(envDimensionKeys));
+                    if (params.optionalVarsToPrompt === undefined) {
+                        // No filter provided (e.g., tests, non-interactive) - use old behavior: prompt all relevant vars
+                        envVarsToPrompt = envVarsMatchingDependsOn.filter(function(envVar) {
+                            return !prePopulatedEnvKeys.includes(envVar.name);
+                        });
+                    } else if (params.optionalVarsToPrompt.size === 0) {
+                        // Empty filter - only prompt for required vars, skip optional
+                        envVarsToPrompt = envVarsMatchingDependsOn.filter(function(envVar) {
+                            return !prePopulatedEnvKeys.includes(envVar.name) && envVar.isRequired;
+                        });
+                    } else {
+                        // Filter provided - prompt required vars + selected optional vars
+                        requiredVars = envVarsMatchingDependsOn.filter(function(envVar) {
+                            return !prePopulatedEnvKeys.includes(envVar.name) && envVar.isRequired;
+                        });
+                        selectedOptionalVars = allEnvVars.filter(function(envVar) {
+                            var // Only optional vars
+                            _params_optionalVarsToPrompt;
+                            return !envVar.isRequired && ((_params_optionalVarsToPrompt = params.optionalVarsToPrompt) === null || _params_optionalVarsToPrompt === void 0 ? void 0 : _params_optionalVarsToPrompt.has(envVar.name)) && // User selected it
+                            !prePopulatedEnvKeys.includes(envVar.name) && // Not already populated
+                            shouldPromptEnvVar(envVar, params.combination.dimensionValues) // Relevant to this config
+                            ;
+                        });
+                        envVarsToPrompt = _to_consumable_array(requiredVars).concat(_to_consumable_array(selectedOptionalVars));
+                    }
+                    // Prompt for environment variable values using shared logic
+                    // In quick mode, skip prompts and use defaults/placeholders via the yes option
+                    promptContext = "".concat(params.combination.name, "/").concat(params.transport);
+                    // Build template vars for placeholder substitution (e.g., {HOST}, {PORT})
+                    templateVars = {};
+                    if (params.httpHost) templateVars.HOST = params.httpHost;
+                    if (params.httpPort) templateVars.PORT = String(params.httpPort);
+                    return [
+                        4,
+                        envPromptFn(promptContext, envVarsToPrompt, {
+                            yes: params.quick,
+                            templateVars: templateVars
+                        })
+                    ];
+                case 1:
+                    promptedEnv = _state.sent();
+                    // Merge all env values: filtered defaults + dimension values + prompted values
+                    env = _object_spread({}, filteredDefaults, envDimensions, promptedEnv);
+                    if (params.useSource) {
+                        // Source mode: use node with relative path to bin entry
+                        if (!params.packageDir) {
+                            throw new Error('packageDir is required when useSource is true');
+                        }
+                        if (!params.binPath) {
+                            throw new Error('binPath is required when useSource is true (check package.json bin entry)');
+                        }
+                        absolutePackageDir = _path.resolve(params.packageDir);
+                        relativePath = _path.join(absolutePackageDir, params.binPath);
+                        command = 'node';
+                        args = [
+                            relativePath
+                        ];
+                    } else {
+                        // Installed mode: use npx (current behavior)
+                        command = 'npx';
+                        args = [
+                            '-y',
+                            params.packageName
+                        ];
+                    }
+                    // Add package arguments from argDefaults and argDimensions
+                    allArgValues = _object_spread({}, params.combination.argDefaults, argDimensions);
+                    _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                    try {
+                        for(_iterator2 = Object.entries(allArgValues)[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                            _step_value1 = _sliced_to_array(_step2.value, 2), argName = _step_value1[0], argValue = _step_value1[1];
+                            // Named arguments are added as --arg value
+                            args.push(argName, argValue);
+                        }
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
+                        }
+                    }
+                    // Add HTTP-specific configuration
+                    if (params.transport === 'http' || params.transport === 'streamable-http') {
+                        ;
+                        port = (_params_httpPort = params.httpPort) !== null && _params_httpPort !== void 0 ? _params_httpPort : 3000;
+                        args.push('--port', String(port));
+                    }
+                    if (params.transport === 'http' || params.transport === 'streamable-http') {
+                        ;
+                        // HTTP servers use start block with stdio config structure
+                        startBlock = _object_spread({
+                            command: command
+                        }, args.length > 0 && {
+                            args: args
+                        }, Object.keys(env).length > 0 && {
+                            env: env
+                        });
+                        httpConfig = {
+                            type: 'http',
+                            url: "http://".concat((_params_httpHost = params.httpHost) !== null && _params_httpHost !== void 0 ? _params_httpHost : 'localhost', ":").concat((_params_httpPort1 = params.httpPort) !== null && _params_httpPort1 !== void 0 ? _params_httpPort1 : 3000, "/mcp"),
+                            start: startBlock
+                        };
+                        serverConfig = httpConfig;
+                    } else {
+                        // Stdio servers use top-level stdio config structure
+                        stdioConfig = _object_spread({
+                            command: command
+                        }, args.length > 0 && {
+                            args: args
+                        }, Object.keys(env).length > 0 && {
+                            env: env
+                        });
+                        serverConfig = stdioConfig;
+                    }
+                    return [
+                        2,
+                        serverConfig
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function generateConfigObject(_0) {
+    return _async_to_generator(function(params) {
+        var envPromptFn, serverConfig;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    envPromptFn = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : _envpromptingts.promptForEnvVars;
+                    return [
+                        4,
+                        buildServerConfig(params, envPromptFn)
+                    ];
+                case 1:
+                    serverConfig = _state.sent();
+                    return [
+                        2,
+                        {
+                            mcpServers: _define_property({}, params.serverName, serverConfig)
+                        }
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function generateConfigFile(_0) {
+    return _async_to_generator(function(params) {
+        var envPromptFn, transportName, filename, filepath, shouldOverwrite, config, error;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    envPromptFn = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : _envpromptingts.promptForEnvVars;
+                    // Normalize transport name for filename ('streamable-http' → 'http' to match config type)
+                    transportName = params.transport === 'streamable-http' ? 'http' : params.transport;
+                    filename = ".mcp.".concat(params.combination.name, "-").concat(transportName, ".json");
+                    filepath = _path.join(params.outputDir, filename);
+                    if (!(_fs.existsSync(filepath) && process.stdin.isTTY)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        (0, _confirm.default)({
+                            message: "".concat(filename, " already exists. Overwrite?"),
+                            default: false
+                        })
+                    ];
+                case 1:
+                    shouldOverwrite = _state.sent();
+                    if (!shouldOverwrite) {
+                        console.log("   ⏭️  Skipped ".concat(filename));
+                        return [
+                            2,
+                            false
+                        ];
+                    }
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    // Ensure output directory exists
+                    _fs.mkdirSync(params.outputDir, {
+                        recursive: true
+                    });
+                    return [
+                        4,
+                        generateConfigObject(params, envPromptFn)
+                    ];
+                case 3:
+                    config = _state.sent();
+                    _fs.writeFileSync(filepath, "".concat(JSON.stringify(config, null, 2), "\n"));
+                    console.log("   ✅ ".concat(filename));
+                    return [
+                        2,
+                        true
+                    ];
+                case 4:
+                    error = _state.sent();
+                    console.error("   ❌ ".concat(filename, ": ").concat(_instanceof(error, Error) ? error.message : String(error)));
+                    return [
+                        2,
+                        false
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }