@mcp-z/cli 1.0.0

package/dist/cjs/lib/json-schema.js

@@ -0,0 +1,306 @@
+"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 SCHEMA_URL () {
+        return SCHEMA_URL;
+    },
+    get getSchema () {
+        return getSchema;
+    },
+    get validateSchema () {
+        return validateSchema;
+    }
+});
+var _ajv = require("ajv");
+var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _module = require("module");
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+var _url = require("url");
+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 _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 _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
+        };
+    }
+}
+// ESM-compatible __dirname equivalent
+var __filename1 = (0, _url.fileURLToPath)(require("url").pathToFileURL(__filename).toString());
+var __dirname = _path.dirname(__filename1);
+// Import ajv-formats (CommonJS module - use createRequire for ESM compatibility)
+var require1 = (0, _module.createRequire)(require("url").pathToFileURL(__filename).toString());
+var addFormats = require1('ajv-formats');
+var SCHEMA_URL = 'https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json';
+var schemaCache = null;
+function getSchema() {
+    return _async_to_generator(function() {
+        var response, unused, bundledPath;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    // Return cached schema
+                    if (schemaCache) {
+                        return [
+                            2,
+                            schemaCache
+                        ];
+                    }
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        5,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        fetch(SCHEMA_URL)
+                    ];
+                case 2:
+                    response = _state.sent();
+                    if (!response.ok) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 3:
+                    schemaCache = _state.sent();
+                    return [
+                        2,
+                        schemaCache
+                    ];
+                case 4:
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    unused = _state.sent();
+                    return [
+                        3,
+                        6
+                    ];
+                case 6:
+                    // Fallback to bundled schema
+                    bundledPath = _path.join(__dirname, '../../schemas/server.schema.json');
+                    if (!_fs.existsSync(bundledPath)) {
+                        throw new Error('Failed to fetch MCP schema from URL and no bundled schema found. ' + 'Check network connection or report this as a bug.');
+                    }
+                    schemaCache = JSON.parse(_fs.readFileSync(bundledPath, 'utf8'));
+                    return [
+                        2,
+                        schemaCache
+                    ];
+            }
+        });
+    })();
+}
+function validateSchema(serverJson, serverName) {
+    return _async_to_generator(function() {
+        var schema, ajv, validate, valid, _validate_errors, errors;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        getSchema()
+                    ];
+                case 1:
+                    schema = _state.sent();
+                    ajv = new _ajv.Ajv({
+                        allErrors: true,
+                        verbose: true,
+                        strictSchema: false
+                    });
+                    // Add format validators (uri, email, etc.) to silence warnings
+                    addFormats(ajv);
+                    validate = ajv.compile(schema);
+                    valid = validate(serverJson);
+                    if (!valid) {
+                        ;
+                        errors = ((_validate_errors = validate.errors) === null || _validate_errors === void 0 ? void 0 : _validate_errors.map(function(e) {
+                            return "  - ".concat(e.instancePath || '(root)', " ").concat(e.message);
+                        }).join('\n')) || 'Unknown validation error';
+                        throw new Error("Invalid server.json for '".concat(serverName, "':\n").concat(errors, "\n\nThe server.json file does not conform to the MCP specification.\nSee: https://modelcontextprotocol.io/specification/server\n\nTo fix: Update the server.json file to match the schema requirements above."));
+                    }
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+/* 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; }

package/dist/cjs/lib/json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/cli/src/lib/json-schema.ts"],"sourcesContent":["import { Ajv, type ErrorObject } from 'ajv';\nimport * as fs from 'fs';\nimport { createRequire } from 'module';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\n\n// ESM-compatible __dirname equivalent\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\n\n// Import ajv-formats (CommonJS module - use createRequire for ESM compatibility)\nconst require = createRequire(import.meta.url);\nconst addFormats = require('ajv-formats');\n\nexport const SCHEMA_URL = 'https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json';\n\nlet schemaCache: object | null = null;\n\n/**\n * Get MCP server.json schema (fetches once, then caches)\n *\n * Strategy:\n * 1. Return cached schema if available\n * 2. Try fetching latest schema from URL\n * 3. Fall back to bundled schema if network fails\n */\nexport async function getSchema(): Promise<object> {\n  // Return cached schema\n  if (schemaCache) {\n    return schemaCache;\n  }\n\n  try {\n    // Try fetching latest schema\n    const response = await fetch(SCHEMA_URL);\n    if (response.ok) {\n      schemaCache = (await response.json()) as object;\n      return schemaCache;\n    }\n  } catch {\n    // Network error - fall through to bundled version\n  }\n\n  // Fallback to bundled schema\n  const bundledPath = path.join(__dirname, '../../schemas/server.schema.json');\n  if (!fs.existsSync(bundledPath)) {\n    throw new Error('Failed to fetch MCP schema from URL and no bundled schema found. ' + 'Check network connection or report this as a bug.');\n  }\n\n  schemaCache = JSON.parse(fs.readFileSync(bundledPath, 'utf8')) as object;\n  return schemaCache;\n}\n\n/**\n * Validate server.json against MCP schema\n *\n * @param serverJson - Parsed server.json content to validate\n * @param serverName - Server name for error messages\n * @throws Error with detailed validation messages if invalid\n */\nexport async function validateSchema(serverJson: unknown, serverName: string): Promise<void> {\n  const schema = await getSchema();\n\n  const ajv = new Ajv({\n    allErrors: true,\n    verbose: true,\n    strictSchema: false, // Allow non-standard keywords like \"example\", \"choices\"\n  });\n\n  // Add format validators (uri, email, etc.) to silence warnings\n  addFormats(ajv);\n\n  const validate = ajv.compile(schema);\n  const valid = validate(serverJson);\n\n  if (!valid) {\n    const errors = validate.errors?.map((e: ErrorObject) => `  - ${e.instancePath || '(root)'} ${e.message}`).join('\\n') || 'Unknown validation error';\n\n    throw new Error(`Invalid server.json for '${serverName}':\\n${errors}\\n\\nThe server.json file does not conform to the MCP specification.\\nSee: https://modelcontextprotocol.io/specification/server\\n\\nTo fix: Update the server.json file to match the schema requirements above.`);\n  }\n}\n"],"names":["SCHEMA_URL","getSchema","validateSchema","__filename","fileURLToPath","__dirname","path","dirname","require","createRequire","addFormats","schemaCache","response","bundledPath","fetch","ok","json","join","fs","existsSync","Error","JSON","parse","readFileSync","serverJson","serverName","schema","ajv","validate","valid","errors","Ajv","allErrors","verbose","strictSchema","compile","map","e","instancePath","message"],"mappings":";;;;;;;;;;;QAcaA;eAAAA;;QAYSC;eAAAA;;QAkCAC;eAAAA;;;mBA5DgB;0DAClB;sBACU;4DACR;mBACQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9B,sCAAsC;AACtC,IAAMC,cAAaC,IAAAA,kBAAa,EAAC;AACjC,IAAMC,YAAYC,MAAKC,OAAO,CAACJ;AAE/B,iFAAiF;AACjF,IAAMK,WAAUC,IAAAA,qBAAa,EAAC;AAC9B,IAAMC,aAAaF,SAAQ;AAEpB,IAAMR,aAAa;AAE1B,IAAIW,cAA6B;AAU1B,SAAeV;;YAQZW,kBAUFC;;;;oBAjBN,uBAAuB;oBACvB,IAAIF,aAAa;wBACf;;4BAAOA;;oBACT;;;;;;;;;oBAImB;;wBAAMG,MAAMd;;;oBAAvBY,WAAW;yBACbA,SAASG,EAAE,EAAXH;;;;oBACa;;wBAAMA,SAASI,IAAI;;;oBAAlCL,cAAe;oBACf;;wBAAOA;;;;;;;;;;;;;;oBAMX,6BAA6B;oBACvBE,cAAcP,MAAKW,IAAI,CAACZ,WAAW;oBACzC,IAAI,CAACa,IAAGC,UAAU,CAACN,cAAc;wBAC/B,MAAM,IAAIO,MAAM,sEAAsE;oBACxF;oBAEAT,cAAcU,KAAKC,KAAK,CAACJ,IAAGK,YAAY,CAACV,aAAa;oBACtD;;wBAAOF;;;;IACT;;AASO,SAAeT,eAAesB,UAAmB,EAAEC,UAAkB;;YACpEC,QAEAC,KASAC,UACAC,OAGWD,kBAATE;;;;oBAfO;;wBAAM7B;;;oBAAfyB,SAAS;oBAETC,MAAM,IAAII,QAAG,CAAC;wBAClBC,WAAW;wBACXC,SAAS;wBACTC,cAAc;oBAChB;oBAEA,+DAA+D;oBAC/DxB,WAAWiB;oBAELC,WAAWD,IAAIQ,OAAO,CAACT;oBACvBG,QAAQD,SAASJ;oBAEvB,IAAI,CAACK,OAAO;;wBACJC,SAASF,EAAAA,mBAAAA,SAASE,MAAM,cAAfF,uCAAAA,iBAAiBQ,GAAG,CAAC,SAACC;mCAAmB,AAAC,OAAoCA,OAA9BA,EAAEC,YAAY,IAAI,UAAS,KAAa,OAAVD,EAAEE,OAAO;2BAAItB,IAAI,CAAC,UAAS;wBAExH,MAAM,IAAIG,MAAM,AAAC,4BAA4CU,OAAjBL,YAAW,QAAa,OAAPK,QAAO;oBACtE;;;;;;IACF"}

package/dist/cjs/lib/resolve-server-config.d.cts

@@ -0,0 +1,50 @@
+/**
+ * resolve-server-config.ts
+ *
+ * Shared config resolution for CLI commands.
+ * Supports both config file-based and inline server configurations.
+ */
+import type { ServersConfig } from '@mcp-z/client';
+import type { ServerConfig } from '../types.js';
+/**
+ * Options for inline server configuration.
+ */
+export interface InlineConfigOptions {
+    /** Server name (optional when inline config provided) */
+    server?: string;
+    /** Config file path (mutually exclusive with inline options) */
+    config?: string;
+    /** Stdio run command string (e.g., "npx -y @echo/server") */
+    run?: string;
+    /** HTTP server URL */
+    url?: string;
+    /** Full server config as JSON string */
+    serverConfig?: string;
+}
+/**
+ * Resolved server configuration.
+ */
+export interface ResolvedServerConfig {
+    /** Server name for display purposes */
+    serverName: string;
+    /** The server configuration object */
+    serverConfig: ServerConfig;
+    /** Working directory for the server (cwd for inline, config dir for file) */
+    configDir: string;
+    /** Full servers config (for HTTP auth flow that needs full config) */
+    fullConfig: ServersConfig;
+}
+/**
+ * Resolve server configuration from CLI options.
+ *
+ * Supports three modes:
+ * 1. Config file: --config path + server positional
+ * 2. Inline stdio: --run "npx server"
+ * 3. Inline HTTP: --url "https://..."
+ * 4. Full JSON: --server '{"command":"npx",...}'
+ *
+ * @param opts - CLI options for config resolution
+ * @returns Resolved server configuration
+ * @throws Error if configuration is invalid
+ */
+export declare function resolveServerConfig(opts: InlineConfigOptions): ResolvedServerConfig;

package/dist/cjs/lib/resolve-server-config.d.ts

@@ -0,0 +1,50 @@
+/**
+ * resolve-server-config.ts
+ *
+ * Shared config resolution for CLI commands.
+ * Supports both config file-based and inline server configurations.
+ */
+import type { ServersConfig } from '@mcp-z/client';
+import type { ServerConfig } from '../types.js';
+/**
+ * Options for inline server configuration.
+ */
+export interface InlineConfigOptions {
+    /** Server name (optional when inline config provided) */
+    server?: string;
+    /** Config file path (mutually exclusive with inline options) */
+    config?: string;
+    /** Stdio run command string (e.g., "npx -y @echo/server") */
+    run?: string;
+    /** HTTP server URL */
+    url?: string;
+    /** Full server config as JSON string */
+    serverConfig?: string;
+}
+/**
+ * Resolved server configuration.
+ */
+export interface ResolvedServerConfig {
+    /** Server name for display purposes */
+    serverName: string;
+    /** The server configuration object */
+    serverConfig: ServerConfig;
+    /** Working directory for the server (cwd for inline, config dir for file) */
+    configDir: string;
+    /** Full servers config (for HTTP auth flow that needs full config) */
+    fullConfig: ServersConfig;
+}
+/**
+ * Resolve server configuration from CLI options.
+ *
+ * Supports three modes:
+ * 1. Config file: --config path + server positional
+ * 2. Inline stdio: --run "npx server"
+ * 3. Inline HTTP: --url "https://..."
+ * 4. Full JSON: --server '{"command":"npx",...}'
+ *
+ * @param opts - CLI options for config resolution
+ * @returns Resolved server configuration
+ * @throws Error if configuration is invalid
+ */
+export declare function resolveServerConfig(opts: InlineConfigOptions): ResolvedServerConfig;

package/dist/cjs/lib/resolve-server-config.js

@@ -0,0 +1,214 @@
+/**
+ * resolve-server-config.ts
+ *
+ * Shared config resolution for CLI commands.
+ * Supports both config file-based and inline server configurations.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveServerConfig", {
+    enumerable: true,
+    get: function() {
+        return resolveServerConfig;
+    }
+});
+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("./find-config.js");
+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 _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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function resolveServerConfig(opts) {
+    // Validate mutual exclusivity of inline options
+    var inlineOptions = [
+        opts.run,
+        opts.url,
+        opts.serverConfig
+    ].filter(Boolean);
+    if (inlineOptions.length > 1) {
+        throw new Error('Cannot use multiple inline config options. Use only one of: --run, --url, or --server');
+    }
+    var hasInlineConfig = inlineOptions.length > 0;
+    // Validate mutual exclusivity with config file
+    if (hasInlineConfig && opts.config) {
+        throw new Error('Cannot use --config with inline config options (--run, --url, --server)');
+    }
+    // Handle inline configuration
+    if (hasInlineConfig) {
+        return resolveInlineConfig(opts);
+    }
+    // Handle config file-based configuration
+    return resolveFileConfig(opts);
+}
+/**
+ * Resolve inline server configuration.
+ */ function resolveInlineConfig(opts) {
+    var serverName = opts.server || 'inline';
+    var configDir = process.cwd();
+    var serverConfig;
+    if (opts.run) {
+        // Parse run string into command + args (simple helper, no schema validation needed)
+        serverConfig = parseRunString(opts.run);
+    } else if (opts.url) {
+        // Create HTTP server config (simple helper, no schema validation needed)
+        serverConfig = {
+            type: 'http',
+            url: opts.url
+        };
+    } else if (opts.serverConfig) {
+        // Parse full JSON config with schema validation
+        serverConfig = parseServerConfigJson(opts.serverConfig, serverName);
+    } else {
+        throw new Error('No inline config provided');
+    }
+    // Create a minimal servers config for the resolved server
+    var fullConfig = _define_property({}, serverName, serverConfig);
+    return {
+        serverName: serverName,
+        serverConfig: serverConfig,
+        configDir: configDir,
+        fullConfig: fullConfig
+    };
+}
+/**
+ * Resolve config file-based server configuration.
+ */ function resolveFileConfig(opts) {
+    var _ref, _raw_mcpServers;
+    if (!opts.server) {
+        throw new Error('Server name is required when using config file');
+    }
+    var cfgPath = (0, _findconfigts.findConfigPath)(opts.config);
+    var raw = JSON.parse(_fs.readFileSync(cfgPath, 'utf8'));
+    var servers = (_ref = (_raw_mcpServers = raw.mcpServers) !== null && _raw_mcpServers !== void 0 ? _raw_mcpServers : raw.servers) !== null && _ref !== void 0 ? _ref : raw;
+    var serverNames = Object.keys(servers || {});
+    if (!serverNames.includes(opts.server)) {
+        throw new Error("Server '".concat(opts.server, "' not found in config\n\nAvailable servers: ").concat(serverNames.join(', ')));
+    }
+    var serverConfig = servers[opts.server];
+    if (!serverConfig) {
+        throw new Error("Server ".concat(opts.server, " not found in config"));
+    }
+    return {
+        serverName: opts.server,
+        serverConfig: serverConfig,
+        configDir: _path.dirname(cfgPath),
+        fullConfig: servers
+    };
+}
+/**
+ * Parse a run string into a ServerConfigStdio.
+ *
+ * @example
+ * parseRunString("npx -y @echo/server")
+ * // => { command: "npx", args: ["-y", "@echo/server"] }
+ */ function parseRunString(runStr) {
+    var parts = runStr.trim().split(/\s+/);
+    if (parts.length === 0 || !parts[0]) {
+        throw new Error('Run string cannot be empty');
+    }
+    return {
+        command: parts[0],
+        args: parts.slice(1)
+    };
+}
+/**
+ * Parse and validate a full server config JSON string against the MCP schema.
+ *
+ * @example
+ * parseServerConfigJson('{"command":"npx","args":["-y","@echo/server"]}')
+ * parseServerConfigJson('{"url":"https://example.com/mcp","type":"http"}')
+ */ function parseServerConfigJson(jsonStr, serverName) {
+    var parsed;
+    try {
+        parsed = JSON.parse(jsonStr);
+    } catch (error) {
+        throw new Error("Failed to parse server config JSON: ".concat(_instanceof(error, Error) ? error.message : String(error)));
+    }
+    if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) !== 'object' || parsed === null) {
+        throw new Error('Server config must be a JSON object');
+    }
+    var config = parsed;
+    // Validate: must have either 'command' (stdio) or 'url' (http)
+    if (!config.command && !config.url) {
+        throw new Error('Server config must have either "command" (for stdio) or "url" (for http)');
+    }
+    // Normalize: if url is present without explicit type, set type to 'http'
+    if (config.url && !config.type) {
+        config.type = 'http';
+    }
+    // Validate against the MCP servers schema
+    var serversMap = _define_property({}, serverName, config);
+    var validation = (0, _client.validateServers)(serversMap);
+    if (!validation.valid) {
+        var _validation_errors;
+        var errorDetails = ((_validation_errors = validation.errors) === null || _validation_errors === void 0 ? void 0 : _validation_errors.join('\n  ')) || 'Unknown validation error';
+        throw new Error("Invalid server config:\n  ".concat(errorDetails));
+    }
+    // Return as ServerConfig (compatible with McpServerEntry)
+    return config;
+}
+/* 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; }

package/dist/cjs/lib/resolve-server-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/cli/src/lib/resolve-server-config.ts"],"sourcesContent":["/**\n * resolve-server-config.ts\n *\n * Shared config resolution for CLI commands.\n * Supports both config file-based and inline server configurations.\n */\n\nimport type { McpServerEntry, ServersConfig } from '@mcp-z/client';\nimport { validateServers } from '@mcp-z/client';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { ServerConfig } from '../types.ts';\nimport { findConfigPath } from './find-config.ts';\n\n/**\n * Options for inline server configuration.\n */\nexport interface InlineConfigOptions {\n  /** Server name (optional when inline config provided) */\n  server?: string;\n  /** Config file path (mutually exclusive with inline options) */\n  config?: string;\n  /** Stdio run command string (e.g., \"npx -y @echo/server\") */\n  run?: string;\n  /** HTTP server URL */\n  url?: string;\n  /** Full server config as JSON string */\n  serverConfig?: string;\n}\n\n/**\n * Resolved server configuration.\n */\nexport interface ResolvedServerConfig {\n  /** Server name for display purposes */\n  serverName: string;\n  /** The server configuration object */\n  serverConfig: ServerConfig;\n  /** Working directory for the server (cwd for inline, config dir for file) */\n  configDir: string;\n  /** Full servers config (for HTTP auth flow that needs full config) */\n  fullConfig: ServersConfig;\n}\n\n/**\n * Resolve server configuration from CLI options.\n *\n * Supports three modes:\n * 1. Config file: --config path + server positional\n * 2. Inline stdio: --run \"npx server\"\n * 3. Inline HTTP: --url \"https://...\"\n * 4. Full JSON: --server '{\"command\":\"npx\",...}'\n *\n * @param opts - CLI options for config resolution\n * @returns Resolved server configuration\n * @throws Error if configuration is invalid\n */\nexport function resolveServerConfig(opts: InlineConfigOptions): ResolvedServerConfig {\n  // Validate mutual exclusivity of inline options\n  const inlineOptions = [opts.run, opts.url, opts.serverConfig].filter(Boolean);\n  if (inlineOptions.length > 1) {\n    throw new Error('Cannot use multiple inline config options. Use only one of: --run, --url, or --server');\n  }\n\n  const hasInlineConfig = inlineOptions.length > 0;\n\n  // Validate mutual exclusivity with config file\n  if (hasInlineConfig && opts.config) {\n    throw new Error('Cannot use --config with inline config options (--run, --url, --server)');\n  }\n\n  // Handle inline configuration\n  if (hasInlineConfig) {\n    return resolveInlineConfig(opts);\n  }\n\n  // Handle config file-based configuration\n  return resolveFileConfig(opts);\n}\n\n/**\n * Resolve inline server configuration.\n */\nfunction resolveInlineConfig(opts: InlineConfigOptions): ResolvedServerConfig {\n  const serverName = opts.server || 'inline';\n  const configDir = process.cwd();\n  let serverConfig: ServerConfig;\n\n  if (opts.run) {\n    // Parse run string into command + args (simple helper, no schema validation needed)\n    serverConfig = parseRunString(opts.run);\n  } else if (opts.url) {\n    // Create HTTP server config (simple helper, no schema validation needed)\n    serverConfig = {\n      type: 'http',\n      url: opts.url,\n    };\n  } else if (opts.serverConfig) {\n    // Parse full JSON config with schema validation\n    serverConfig = parseServerConfigJson(opts.serverConfig, serverName);\n  } else {\n    throw new Error('No inline config provided');\n  }\n\n  // Create a minimal servers config for the resolved server\n  const fullConfig: ServersConfig = {\n    [serverName]: serverConfig,\n  };\n\n  return {\n    serverName,\n    serverConfig,\n    configDir,\n    fullConfig,\n  };\n}\n\n/**\n * Resolve config file-based server configuration.\n */\nfunction resolveFileConfig(opts: InlineConfigOptions): ResolvedServerConfig {\n  if (!opts.server) {\n    throw new Error('Server name is required when using config file');\n  }\n\n  const cfgPath = findConfigPath(opts.config);\n  const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));\n  const servers: ServersConfig = raw.mcpServers ?? raw.servers ?? raw;\n\n  const serverNames = Object.keys(servers || {});\n  if (!serverNames.includes(opts.server)) {\n    throw new Error(`Server '${opts.server}' not found in config\\n\\nAvailable servers: ${serverNames.join(', ')}`);\n  }\n\n  const serverConfig = servers[opts.server];\n  if (!serverConfig) {\n    throw new Error(`Server ${opts.server} not found in config`);\n  }\n\n  return {\n    serverName: opts.server,\n    serverConfig: serverConfig as ServerConfig,\n    configDir: path.dirname(cfgPath),\n    fullConfig: servers,\n  };\n}\n\n/**\n * Parse a run string into a ServerConfigStdio.\n *\n * @example\n * parseRunString(\"npx -y @echo/server\")\n * // => { command: \"npx\", args: [\"-y\", \"@echo/server\"] }\n */\nfunction parseRunString(runStr: string): ServerConfig {\n  const parts = runStr.trim().split(/\\s+/);\n  if (parts.length === 0 || !parts[0]) {\n    throw new Error('Run string cannot be empty');\n  }\n\n  return {\n    command: parts[0],\n    args: parts.slice(1),\n  };\n}\n\n/**\n * Parse and validate a full server config JSON string against the MCP schema.\n *\n * @example\n * parseServerConfigJson('{\"command\":\"npx\",\"args\":[\"-y\",\"@echo/server\"]}')\n * parseServerConfigJson('{\"url\":\"https://example.com/mcp\",\"type\":\"http\"}')\n */\nfunction parseServerConfigJson(jsonStr: string, serverName: string): ServerConfig {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(jsonStr);\n  } catch (error) {\n    throw new Error(`Failed to parse server config JSON: ${error instanceof Error ? error.message : String(error)}`);\n  }\n\n  if (typeof parsed !== 'object' || parsed === null) {\n    throw new Error('Server config must be a JSON object');\n  }\n\n  const config = parsed as McpServerEntry;\n\n  // Validate: must have either 'command' (stdio) or 'url' (http)\n  if (!config.command && !config.url) {\n    throw new Error('Server config must have either \"command\" (for stdio) or \"url\" (for http)');\n  }\n\n  // Normalize: if url is present without explicit type, set type to 'http'\n  if (config.url && !config.type) {\n    config.type = 'http';\n  }\n\n  // Validate against the MCP servers schema\n  const serversMap = { [serverName]: config };\n  const validation = validateServers(serversMap);\n  if (!validation.valid) {\n    const errorDetails = validation.errors?.join('\\n  ') || 'Unknown validation error';\n    throw new Error(`Invalid server config:\\n  ${errorDetails}`);\n  }\n\n  // Return as ServerConfig (compatible with McpServerEntry)\n  return config as ServerConfig;\n}\n"],"names":["resolveServerConfig","opts","inlineOptions","run","url","serverConfig","filter","Boolean","length","Error","hasInlineConfig","config","resolveInlineConfig","resolveFileConfig","serverName","server","configDir","process","cwd","parseRunString","type","parseServerConfigJson","fullConfig","raw","cfgPath","findConfigPath","JSON","parse","fs","readFileSync","servers","mcpServers","serverNames","Object","keys","includes","join","path","dirname","runStr","parts","trim","split","command","args","slice","jsonStr","parsed","error","message","String","serversMap","validation","validateServers","valid","errorDetails","errors"],"mappings":"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"}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/types.d.cts

@@ -0,0 +1,21 @@
+export interface MCPConfiguration {
+    mcpServers: Record<string, ServerConfig>;
+}
+export interface ServerConfigStdio {
+    type?: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface ServerConfigHttp {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+    start?: ServerConfigStdio;
+}
+export type ServerConfig = ServerConfigStdio | ServerConfigHttp;
+export declare function isHttpServer(config: ServerConfig): config is ServerConfigHttp;
+export declare function isStdioServer(config: ServerConfig): config is ServerConfigStdio;
+export declare function hasStartBlock(config: ServerConfig): config is ServerConfigHttp & {
+    start: ServerConfigStdio;
+};