@mcp-z/cli 1.0.0

package/dist/cjs/commands/inspect.js

@@ -0,0 +1,896 @@
+/**
+ * inspect.ts
+ *
+ * Inspect MCP servers: explore tools, resources, prompts, and health status.
+ * Supports stdio (spawned) and http (remote) servers per MCP spec.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "inspectCommand", {
+    enumerable: true,
+    get: function() {
+        return inspectCommand;
+    }
+});
+var _client = require("@mcp-z/client");
+var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+var _findconfigts = require("../lib/find-config.js");
+var _typests = require("../types.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 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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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_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 _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 _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 MAX_DESCRIPTION = 100;
+function inspectCommand() {
+    return _async_to_generator(function() {
+        var opts, registry, _ref, _raw_mcpServers, configPath, raw, servers, configDir, serverNames, serversToInspect, serverInfos, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, serverName, info, err, _;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    opts = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : {};
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        ,
+                        10,
+                        15
+                    ]);
+                    configPath = (0, _findconfigts.findConfigPath)(opts.config);
+                    raw = JSON.parse(_fs.readFileSync(configPath, 'utf8'));
+                    servers = (_ref = (_raw_mcpServers = raw.mcpServers) !== null && _raw_mcpServers !== void 0 ? _raw_mcpServers : raw.servers) !== null && _ref !== void 0 ? _ref : raw;
+                    configDir = _path.dirname(configPath);
+                    serverNames = Object.keys(servers || {});
+                    serversToInspect = filterServers(serverNames, opts.servers);
+                    // Create registry (spawns stdio servers, registers HTTP servers)
+                    // In attach mode, don't spawn - just register for connection
+                    registry = (0, _client.createServerRegistry)(servers, {
+                        cwd: configDir,
+                        dialects: opts.attach ? [] : [
+                            'servers',
+                            'start'
+                        ]
+                    });
+                    serverInfos = [];
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        7,
+                        8,
+                        9
+                    ]);
+                    _iterator = serversToInspect[Symbol.iterator]();
+                    _state.label = 3;
+                case 3:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        6
+                    ];
+                    serverName = _step.value;
+                    return [
+                        4,
+                        inspectServer(serverName, servers, registry, opts)
+                    ];
+                case 4:
+                    info = _state.sent();
+                    serverInfos.push(info);
+                    _state.label = 5;
+                case 5:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        3
+                    ];
+                case 6:
+                    return [
+                        3,
+                        9
+                    ];
+                case 7:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        9
+                    ];
+                case 8:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 9:
+                    // 5. Output results
+                    if (opts.json) {
+                        outputJSON(serverInfos);
+                    } else {
+                        outputPretty(serverInfos, opts);
+                    }
+                    return [
+                        3,
+                        15
+                    ];
+                case 10:
+                    if (!registry) return [
+                        3,
+                        14
+                    ];
+                    _state.label = 11;
+                case 11:
+                    _state.trys.push([
+                        11,
+                        13,
+                        ,
+                        14
+                    ]);
+                    return [
+                        4,
+                        registry.close()
+                    ];
+                case 12:
+                    _state.sent();
+                    return [
+                        3,
+                        14
+                    ];
+                case 13:
+                    _ = _state.sent();
+                    return [
+                        3,
+                        14
+                    ];
+                case 14:
+                    return [
+                        7
+                    ];
+                case 15:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+/**
+ * Filter servers based on --servers flag.
+ */ function filterServers(allServers, serversFlag) {
+    if (!serversFlag) {
+        return allServers;
+    }
+    var requested = serversFlag.split(',').map(function(s) {
+        return s.trim();
+    });
+    var missing = requested.filter(function(s) {
+        return !allServers.includes(s);
+    });
+    if (missing.length > 0) {
+        throw new Error("Server(s) not found in config: ".concat(missing.join(', '), "\n\nAvailable servers: ").concat(allServers.join(', ')));
+    }
+    return requested;
+}
+/**
+ * Inspect a single server: collect tools, resources, prompts, health.
+ */ function inspectServer(serverName, servers, registry, opts) {
+    return _async_to_generator(function() {
+        var start, serverConfig, client, needsTools, needsResources, needsPrompts, _ref, toolsResult, resourcesResult, promptsResult, startupTime, error, errorMessage, cause, serverConfig1, url;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    start = Date.now();
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        4,
+                        ,
+                        5
+                    ]);
+                    // Connect to server via registry
+                    serverConfig = servers === null || servers === void 0 ? void 0 : servers[serverName];
+                    if (!serverConfig) {
+                        throw new Error("Server ".concat(serverName, " not found in config"));
+                    }
+                    if (!(0, _typests.isHttpServer)(serverConfig) && !serverConfig.command) {
+                        throw new Error("Stdio server ".concat(serverName, ' missing required "command" field'));
+                    }
+                    return [
+                        4,
+                        registry.connect(serverName)
+                    ];
+                case 2:
+                    client = _state.sent();
+                    // Collect content based on flags
+                    needsTools = opts.tools || shouldShowSummary(opts);
+                    needsResources = opts.resources || shouldShowSummary(opts);
+                    needsPrompts = opts.prompts || shouldShowSummary(opts);
+                    return [
+                        4,
+                        Promise.all([
+                            needsTools ? client.listTools().catch(function() {
+                                return null;
+                            }) : Promise.resolve(null),
+                            needsResources ? client.listResources().catch(function() {
+                                return null;
+                            }) : Promise.resolve(null),
+                            needsPrompts ? client.listPrompts().catch(function() {
+                                return null;
+                            }) : Promise.resolve(null)
+                        ])
+                    ];
+                case 3:
+                    _ref = _sliced_to_array.apply(void 0, [
+                        _state.sent(),
+                        3
+                    ]), toolsResult = _ref[0], resourcesResult = _ref[1], promptsResult = _ref[2];
+                    startupTime = Date.now() - start;
+                    return [
+                        2,
+                        {
+                            name: serverName,
+                            status: 'ready',
+                            startupTime: startupTime,
+                            error: undefined,
+                            tools: (toolsResult === null || toolsResult === void 0 ? void 0 : toolsResult.tools) ? toolsResult.tools.map(function(t) {
+                                return {
+                                    name: t.name,
+                                    description: t.description,
+                                    inputSchema: t.inputSchema
+                                };
+                            }) : undefined,
+                            resources: (resourcesResult === null || resourcesResult === void 0 ? void 0 : resourcesResult.resources) ? resourcesResult.resources.map(function(r) {
+                                return {
+                                    uri: r.uri,
+                                    name: r.name,
+                                    description: r.description,
+                                    mimeType: r.mimeType
+                                };
+                            }) : undefined,
+                            prompts: (promptsResult === null || promptsResult === void 0 ? void 0 : promptsResult.prompts) ? promptsResult.prompts.map(function(p) {
+                                return {
+                                    name: p.name,
+                                    description: p.description,
+                                    arguments: p.arguments
+                                };
+                            }) : undefined
+                        }
+                    ];
+                case 4:
+                    error = _state.sent();
+                    // Format error message with context
+                    errorMessage = _instanceof(error, Error) ? error.message : String(error);
+                    // For fetch errors, dig into the cause for more details
+                    if (_instanceof(error, Error) && error.message === 'fetch failed' && 'cause' in error) {
+                        cause = error.cause;
+                        if ((cause === null || cause === void 0 ? void 0 : cause.code) === 'ECONNREFUSED') {
+                            serverConfig1 = servers === null || servers === void 0 ? void 0 : servers[serverName];
+                            url = serverConfig1 && 'url' in serverConfig1 ? serverConfig1.url : undefined;
+                            errorMessage = url ? "Connection refused (server not running at ".concat(url, ")") : 'Connection refused (server not running)';
+                        } else if (cause === null || cause === void 0 ? void 0 : cause.message) {
+                            errorMessage = "".concat(error.message, ": ").concat(cause.message);
+                        }
+                    }
+                    return [
+                        2,
+                        {
+                            name: serverName,
+                            status: 'failed',
+                            startupTime: undefined,
+                            error: errorMessage,
+                            tools: undefined,
+                            resources: undefined,
+                            prompts: undefined
+                        }
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Determine if we should show summary (no specific content flags).
+ */ function shouldShowSummary(opts) {
+    return !opts.tools && !opts.resources && !opts.prompts && !opts.health;
+}
+/**
+ * Truncate description to max length with ellipsis.
+ */ function truncateDescription(desc) {
+    var _maxLength = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : MAX_DESCRIPTION;
+    return desc;
+// if (!desc || desc.length <= maxLength) {
+//   return desc;
+// }
+// return `${desc.slice(0, maxLength - 3)}...`;
+}
+/**
+ * Render verbose details for a tool (parameters with types and descriptions)
+ */ function renderToolVerbose(tool, indent) {
+    // Description is already shown inline, so skip it here
+    var schema = tool.inputSchema;
+    if (!schema || !schema.properties) {
+        return;
+    }
+    var properties = schema.properties;
+    var required = schema.required || [];
+    // Separate required and optional parameters
+    var requiredParams = [];
+    var optionalParams = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(properties)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], _prop = _step_value[1];
+            if (required.includes(name)) {
+                requiredParams.push(name);
+            } else {
+                optionalParams.push(name);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    // Show required parameters
+    if (requiredParams.length > 0) {
+        console.log("".concat(indent, "Required Parameters:"));
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = requiredParams[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var name1 = _step1.value;
+                renderParameter(name1, properties[name1], "".concat(indent, "  "));
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        console.log('');
+    }
+    // Show optional parameters
+    if (optionalParams.length > 0) {
+        console.log("".concat(indent, "Optional Parameters:"));
+        var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+        try {
+            for(var _iterator2 = optionalParams[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                var name2 = _step2.value;
+                renderParameter(name2, properties[name2], "".concat(indent, "  "));
+            }
+        } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                    _iterator2.return();
+                }
+            } finally{
+                if (_didIteratorError2) {
+                    throw _iteratorError2;
+                }
+            }
+        }
+        console.log('');
+    }
+}
+/**
+ * Render verbose details for a resource
+ */ function renderResourceVerbose(resource, indent) {
+    // Description is already shown inline, so only show URI and MIME type
+    if (resource.uri) {
+        console.log("".concat(indent, "URI: ").concat(resource.uri));
+    }
+    if (resource.mimeType) {
+        console.log("".concat(indent, "MIME Type: ").concat(resource.mimeType));
+    }
+    if (resource.uri || resource.mimeType) {
+        console.log('');
+    }
+}
+/**
+ * Render verbose details for a prompt
+ */ function renderPromptVerbose(prompt, indent) {
+    // Description is already shown inline, so only show arguments
+    if (prompt.arguments && Array.isArray(prompt.arguments) && prompt.arguments.length > 0) {
+        console.log("".concat(indent, "Arguments:"));
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = prompt.arguments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var arg = _step.value;
+                var argObj = arg;
+                var name = argObj.name || 'unknown';
+                var description = argObj.description || '';
+                var required = argObj.required ? ' (required)' : ' (optional)';
+                var desc = description ? " - ".concat(description) : '';
+                console.log("".concat(indent, "  ").concat(name).concat(required).concat(desc));
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        console.log('');
+    }
+}
+/**
+ * Render a single parameter with type and description
+ */ function renderParameter(name, prop, indent) {
+    var p = prop;
+    var type = getParameterType(prop);
+    var constraints = getParameterConstraints(prop);
+    var typeInfo = constraints ? "(".concat(type, ") ").concat(constraints) : "(".concat(type, ")");
+    var desc = p.description ? " - ".concat(p.description) : '';
+    console.log("".concat(indent).concat(name, " ").concat(typeInfo).concat(desc));
+    // Show enum options on separate line if present
+    if (p.enum && Array.isArray(p.enum)) {
+        console.log("".concat(indent, "  Options: ").concat(p.enum.join(', ')));
+    }
+}
+/**
+ * Get human-readable type from JSON Schema property
+ */ function getParameterType(prop) {
+    var p = prop;
+    if (p.type) {
+        if (Array.isArray(p.type)) {
+            return p.type.join(' | ');
+        }
+        if (p.type === 'array' && p.items) {
+            var itemType = p.items.type || 'any';
+            return "array of ".concat(itemType);
+        }
+        return p.type;
+    }
+    if (p.anyOf) {
+        return p.anyOf.map(function(s) {
+            return s.type || 'any';
+        }).join(' | ');
+    }
+    if (p.enum) {
+        return 'enum';
+    }
+    return 'any';
+}
+/**
+ * Get parameter constraints (default, min, max, etc.)
+ */ function getParameterConstraints(prop) {
+    var p = prop;
+    var constraints = [];
+    if (p.default !== undefined) {
+        var defaultValue = typeof p.default === 'string' ? '"'.concat(p.default, '"') : String(p.default);
+        constraints.push("default: ".concat(defaultValue));
+    }
+    if (p.minimum !== undefined) {
+        constraints.push("min: ".concat(p.minimum));
+    }
+    if (p.maximum !== undefined) {
+        constraints.push("max: ".concat(p.maximum));
+    }
+    if (p.minLength !== undefined) {
+        constraints.push("minLength: ".concat(p.minLength));
+    }
+    if (p.maxLength !== undefined) {
+        constraints.push("maxLength: ".concat(p.maxLength));
+    }
+    if (p.minItems !== undefined) {
+        constraints.push("minItems: ".concat(p.minItems));
+    }
+    if (p.maxItems !== undefined) {
+        constraints.push("maxItems: ".concat(p.maxItems));
+    }
+    return constraints.length > 0 ? "[".concat(constraints.join(', '), "]") : '';
+}
+/**
+ * Output results as JSON.
+ */ function outputJSON(serverInfos) {
+    var output = {
+        servers: serverInfos.reduce(function(acc, info) {
+            acc[info.name] = {
+                status: info.status,
+                startupTime: info.startupTime ? "".concat((info.startupTime / 1000).toFixed(1), "s") : undefined,
+                error: info.error,
+                tools: info.tools,
+                resources: info.resources,
+                prompts: info.prompts
+            };
+            return acc;
+        }, {})
+    };
+    console.log(JSON.stringify(output, null, 2));
+}
+/**
+ * Output results in human-readable format.
+ */ function outputPretty(serverInfos, opts) {
+    var showSummary = shouldShowSummary(opts);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = serverInfos[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var info = _step.value;
+            // Summary mode
+            if (showSummary) {
+                if (info.status === 'ready') {
+                    var _info_tools, _info_resources, _info_prompts;
+                    var toolCount = ((_info_tools = info.tools) === null || _info_tools === void 0 ? void 0 : _info_tools.length) || 0;
+                    var resourceCount = ((_info_resources = info.resources) === null || _info_resources === void 0 ? void 0 : _info_resources.length) || 0;
+                    var promptCount = ((_info_prompts = info.prompts) === null || _info_prompts === void 0 ? void 0 : _info_prompts.length) || 0;
+                    var time = info.startupTime ? "(".concat((info.startupTime / 1000).toFixed(1), "s)") : '';
+                    console.log("\uD83D\uDCE6 ".concat(info.name, ": ").concat(time));
+                    // Show detailed list of tools
+                    console.log("tools: ".concat(toolCount));
+                    if (info.tools && info.tools.length > 0) {
+                        for(var i = 0; i < info.tools.length; i++){
+                            var tool = info.tools[i];
+                            if (!tool) continue; // Array indexing can return undefined with noUncheckedIndexedAccess
+                            var desc = tool.description ? " - ".concat(opts.verbose ? tool.description : truncateDescription(tool.description)) : '';
+                            console.log("".concat(i + 1, ". ").concat(tool.name).concat(desc));
+                            if (opts.verbose) {
+                                renderToolVerbose(tool, '   ');
+                            }
+                        }
+                    }
+                    // Show detailed list of resources
+                    console.log("resources: ".concat(resourceCount));
+                    if (info.resources && info.resources.length > 0) {
+                        for(var i1 = 0; i1 < info.resources.length; i1++){
+                            var resource = info.resources[i1];
+                            if (!resource) continue; // Array indexing can return undefined with noUncheckedIndexedAccess
+                            var desc1 = resource.description ? " - ".concat(opts.verbose ? resource.description : truncateDescription(resource.description)) : '';
+                            console.log("".concat(i1 + 1, ". ").concat(resource.name).concat(desc1));
+                            if (opts.verbose) {
+                                renderResourceVerbose(resource, '   ');
+                            }
+                        }
+                    }
+                    // Show detailed list of prompts
+                    console.log("prompts: ".concat(promptCount));
+                    if (info.prompts && info.prompts.length > 0) {
+                        for(var i2 = 0; i2 < info.prompts.length; i2++){
+                            var prompt = info.prompts[i2];
+                            if (!prompt) continue; // Array indexing can return undefined with noUncheckedIndexedAccess
+                            var desc2 = prompt.description ? " - ".concat(opts.verbose ? prompt.description : truncateDescription(prompt.description)) : '';
+                            console.log("".concat(i2 + 1, ". ").concat(prompt.name).concat(desc2));
+                            if (opts.verbose) {
+                                renderPromptVerbose(prompt, '   ');
+                            }
+                        }
+                    }
+                } else {
+                    console.log("\uD83D\uDCE6 ".concat(info.name, ": ✗ failed - ").concat(info.error));
+                }
+                continue;
+            }
+            // Health mode
+            if (opts.health) {
+                if (info.status === 'ready') {
+                    var time1 = info.startupTime ? "(".concat((info.startupTime / 1000).toFixed(1), "s)") : '';
+                    console.log("✓ ".concat(info.name, " - ready ").concat(time1));
+                } else {
+                    console.log("✗ ".concat(info.name, " - failed"));
+                    console.log("  Error: ".concat(info.error));
+                }
+                continue;
+            }
+            // Tools mode
+            if (opts.tools) {
+                var _info_tools1;
+                console.log("\n\uD83D\uDCE6 ".concat(info.name, " (").concat(((_info_tools1 = info.tools) === null || _info_tools1 === void 0 ? void 0 : _info_tools1.length) || 0, " tools)"));
+                if (info.tools && info.tools.length > 0) {
+                    for(var i3 = 0; i3 < info.tools.length; i3++){
+                        var tool1 = info.tools[i3];
+                        if (!tool1) continue; // Array indexing can return undefined with noUncheckedIndexedAccess
+                        var desc3 = tool1.description ? " - ".concat(opts.verbose ? tool1.description : truncateDescription(tool1.description)) : '';
+                        console.log("  ".concat(i3 + 1, ". ").concat(tool1.name).concat(desc3));
+                        if (opts.verbose) {
+                            renderToolVerbose(tool1, '     ');
+                        }
+                    }
+                }
+            }
+            // Resources mode
+            if (opts.resources) {
+                var _info_resources1;
+                console.log("\n\uD83D\uDCE6 ".concat(info.name, " (").concat(((_info_resources1 = info.resources) === null || _info_resources1 === void 0 ? void 0 : _info_resources1.length) || 0, " resources)"));
+                if (info.resources && info.resources.length > 0) {
+                    for(var i4 = 0; i4 < info.resources.length; i4++){
+                        var resource1 = info.resources[i4];
+                        if (!resource1) continue; // Array indexing can return undefined with noUncheckedIndexedAccess
+                        var desc4 = resource1.description ? " - ".concat(opts.verbose ? resource1.description : truncateDescription(resource1.description)) : '';
+                        console.log("  ".concat(i4 + 1, ". ").concat(resource1.name).concat(desc4));
+                        if (opts.verbose) {
+                            renderResourceVerbose(resource1, '     ');
+                        }
+                    }
+                }
+            }
+            // Prompts mode
+            if (opts.prompts) {
+                var _info_prompts1;
+                console.log("\n\uD83D\uDCE6 ".concat(info.name, " (").concat(((_info_prompts1 = info.prompts) === null || _info_prompts1 === void 0 ? void 0 : _info_prompts1.length) || 0, " prompts)"));
+                if (info.prompts && info.prompts.length > 0) {
+                    for(var i5 = 0; i5 < info.prompts.length; i5++){
+                        var prompt1 = info.prompts[i5];
+                        if (!prompt1) continue; // Array indexing can return undefined with noUncheckedIndexedAccess
+                        var desc5 = prompt1.description ? " - ".concat(opts.verbose ? prompt1.description : truncateDescription(prompt1.description)) : '';
+                        console.log("  ".concat(i5 + 1, ". ").concat(prompt1.name).concat(desc5));
+                        if (opts.verbose) {
+                            renderPromptVerbose(prompt1, '     ');
+                        }
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    console.log('');
+}
+/* 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; }