@mcp-z/cli 1.0.0

package/dist/cjs/commands/up.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "upCommand", {
+    enumerable: true,
+    get: function() {
+        return upCommand;
+    }
+});
+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 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
+        };
+    }
+}
+function upCommand() {
+    return _async_to_generator(function() {
+        var opts, _ref, _raw_mcpServers, configPath, raw, servers, configDir, dialects, hasStartBlocks;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            opts = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : {};
+            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);
+            // Determine dialects based on flags
+            // Default is ['servers', 'start'] (spawns everything)
+            dialects = [
+                'servers',
+                'start'
+            ];
+            if (opts.stdioOnly) {
+                dialects = [
+                    'servers'
+                ];
+            } else if (opts.httpOnly) {
+                dialects = [
+                    'start'
+                ];
+                // In http-only mode, check if there are any servers with start blocks
+                hasStartBlocks = Object.values(servers || {}).some(function(entry) {
+                    return entry && (0, _typests.hasStartBlock)(entry);
+                });
+                if (!hasStartBlocks) {
+                    console.log('  No HTTP servers found with start configuration');
+                    console.log('  (stdio servers are spawned automatically by Claude Code)');
+                    // Return empty registry
+                    return [
+                        2,
+                        (0, _client.createServerRegistry)({}, {
+                            cwd: configDir
+                        })
+                    ];
+                }
+            }
+            return [
+                2,
+                (0, _client.createServerRegistry)(servers, {
+                    cwd: configDir,
+                    dialects: dialects
+                })
+            ];
+        });
+    }).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; }

package/dist/cjs/commands/up.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/cli/src/commands/up.ts"],"sourcesContent":["import { createServerRegistry, type Dialect, type ServerRegistry } from '@mcp-z/client';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { findConfigPath } from '../lib/find-config.ts';\nimport { hasStartBlock, type ServerConfig } from '../types.ts';\n\n/**\n * Configuration options for the upCommand function\n * @public\n */\nexport interface UpOptions {\n  /** Optional path to custom .mcp.json configuration file */\n  config?: string;\n  /** Start only stdio servers (Claude Code compatible mode) */\n  stdioOnly?: boolean;\n  /** Start only HTTP servers with start blocks (for Claude Code Desktop) */\n  httpOnly?: boolean;\n}\n\n/**\n * MCP server configuration entry per MCP specification.\n *\n * Supports two transport types:\n * - stdio (default if no type): spawned process with stdin/stdout\n * - http: remote HTTP server\n *\n * Transport can be inferred from URL protocol:\n * - http:// or https:// → http\n *\n * @see https://modelcontextprotocol.io/specification/2025-06-18/basic/transports\n */\n\n/**\n * Start a cluster of MCP servers from a configuration file or object.\n *\n * @param opts - Configuration options\n * @param opts.config - Optional path to custom .mcp.json file\n * @returns ServerRegistry with servers map, config, connect method, and close function\n *\n * @example\n * // Auto-discover .mcp.json in current directory\n * const registry = await upCommand();\n *\n * @example\n * // Load from specific config\n * const registry = await upCommand({ config: '/path/to/.mcp.json' });\n *\n * @example\n * // Use in-memory config\n * const registry = await upCommand({\n *   mcpServers: {\n *     'echo-stdio': { command: 'node', args: ['test/lib/servers/echo-stdio.ts'] }\n *   }\n * });\n */\nexport async function upCommand(opts: UpOptions = {}): Promise<ServerRegistry> {\n  const configPath = findConfigPath(opts.config);\n  const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));\n  const servers = raw.mcpServers ?? raw.servers ?? raw;\n  const configDir = path.dirname(configPath);\n\n  // Determine dialects based on flags\n  // Default is ['servers', 'start'] (spawns everything)\n  let dialects: Dialect[] = ['servers', 'start'];\n  if (opts.stdioOnly) {\n    dialects = ['servers'];\n  } else if (opts.httpOnly) {\n    dialects = ['start'];\n    // In http-only mode, check if there are any servers with start blocks\n    const hasStartBlocks = Object.values(servers || {}).some((entry) => entry && hasStartBlock(entry as ServerConfig));\n    if (!hasStartBlocks) {\n      console.log('  No HTTP servers found with start configuration');\n      console.log('  (stdio servers are spawned automatically by Claude Code)');\n      // Return empty registry\n      return createServerRegistry({}, { cwd: configDir });\n    }\n  }\n\n  return createServerRegistry(servers, {\n    cwd: configDir,\n    dialects,\n  });\n}\n"],"names":["upCommand","opts","raw","configPath","servers","configDir","dialects","hasStartBlocks","findConfigPath","config","JSON","parse","fs","readFileSync","mcpServers","path","dirname","stdioOnly","httpOnly","Object","values","some","entry","hasStartBlock","console","log","createServerRegistry","cwd"],"mappings":";;;;+BAuDsBA;;;eAAAA;;;sBAvDkD;0DACpD;4DACE;4BACS;uBACkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmD1C,SAAeA;;YAAUC,MAGdC,MAAAA,iBAFVC,YACAD,KACAE,SACAC,WAIFC,UAMIC;;;YAdsBN,OAAAA,oEAAkB,CAAC;YAC3CE,aAAaK,IAAAA,4BAAc,EAACP,KAAKQ,MAAM;YACvCP,MAAMQ,KAAKC,KAAK,CAACC,IAAGC,YAAY,CAACV,YAAY;YAC7CC,WAAUF,QAAAA,kBAAAA,IAAIY,UAAU,cAAdZ,6BAAAA,kBAAkBA,IAAIE,OAAO,cAA7BF,kBAAAA,OAAiCA;YAC3CG,YAAYU,MAAKC,OAAO,CAACb;YAE/B,oCAAoC;YACpC,sDAAsD;YAClDG;gBAAuB;gBAAW;;YACtC,IAAIL,KAAKgB,SAAS,EAAE;gBAClBX;oBAAY;;YACd,OAAO,IAAIL,KAAKiB,QAAQ,EAAE;gBACxBZ;oBAAY;;gBACZ,sEAAsE;gBAChEC,iBAAiBY,OAAOC,MAAM,CAAChB,WAAW,CAAC,GAAGiB,IAAI,CAAC,SAACC;2BAAUA,SAASC,IAAAA,sBAAa,EAACD;;gBAC3F,IAAI,CAACf,gBAAgB;oBACnBiB,QAAQC,GAAG,CAAC;oBACZD,QAAQC,GAAG,CAAC;oBACZ,wBAAwB;oBACxB;;wBAAOC,IAAAA,4BAAoB,EAAC,CAAC,GAAG;4BAAEC,KAAKtB;wBAAU;;gBACnD;YACF;YAEA;;gBAAOqB,IAAAA,4BAAoB,EAACtB,SAAS;oBACnCuB,KAAKtB;oBACLC,UAAAA;gBACF;;;IACF"}

package/dist/cjs/index.d.cts

@@ -0,0 +1,7 @@
+export { type Combination, type ConfigChoice, type ConfigurationMode, createConfigChoices, type Dimension, discoverServerJson, extractServerName, filterConfigChoices, generateConditionalCombinations, generateConfigFile, generateConfigObject, generateMatrixCombinations, shouldPromptEnvVar, TRANSPORT_MAP, } from './commands/manifest/generate.js';
+export { type CliArgMetadata, type EnvVarMetadata, MetadataReader, type ServerMetadata } from './commands/manifest/metadata-reader.js';
+export { validateCommand } from './commands/manifest/validate.js';
+export { upCommand } from './commands/up.js';
+export { getSchema, SCHEMA_URL, validateSchema } from './lib/json-schema.js';
+export { type InlineConfigOptions, type ResolvedServerConfig, resolveServerConfig } from './lib/resolve-server-config.js';
+export * from './types.js';

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export { type Combination, type ConfigChoice, type ConfigurationMode, createConfigChoices, type Dimension, discoverServerJson, extractServerName, filterConfigChoices, generateConditionalCombinations, generateConfigFile, generateConfigObject, generateMatrixCombinations, shouldPromptEnvVar, TRANSPORT_MAP, } from './commands/manifest/generate.js';
+export { type CliArgMetadata, type EnvVarMetadata, MetadataReader, type ServerMetadata } from './commands/manifest/metadata-reader.js';
+export { validateCommand } from './commands/manifest/validate.js';
+export { upCommand } from './commands/up.js';
+export { getSchema, SCHEMA_URL, validateSchema } from './lib/json-schema.js';
+export { type InlineConfigOptions, type ResolvedServerConfig, resolveServerConfig } from './lib/resolve-server-config.js';
+export * from './types.js';

package/dist/cjs/index.js

@@ -0,0 +1,85 @@
+// Base types and type guards
+"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 MetadataReader () {
+        return _metadatareaderts.MetadataReader;
+    },
+    get SCHEMA_URL () {
+        return _jsonschemats.SCHEMA_URL;
+    },
+    get TRANSPORT_MAP () {
+        return _generatets.TRANSPORT_MAP;
+    },
+    get createConfigChoices () {
+        return _generatets.createConfigChoices;
+    },
+    get discoverServerJson () {
+        return _generatets.discoverServerJson;
+    },
+    get extractServerName () {
+        return _generatets.extractServerName;
+    },
+    get filterConfigChoices () {
+        return _generatets.filterConfigChoices;
+    },
+    get generateConditionalCombinations () {
+        return _generatets.generateConditionalCombinations;
+    },
+    get generateConfigFile () {
+        return _generatets.generateConfigFile;
+    },
+    get generateConfigObject () {
+        return _generatets.generateConfigObject;
+    },
+    get generateMatrixCombinations () {
+        return _generatets.generateMatrixCombinations;
+    },
+    get getSchema () {
+        return _jsonschemats.getSchema;
+    },
+    get resolveServerConfig () {
+        return _resolveserverconfigts.resolveServerConfig;
+    },
+    get shouldPromptEnvVar () {
+        return _generatets.shouldPromptEnvVar;
+    },
+    get upCommand () {
+        return _upts.upCommand;
+    },
+    get validateCommand () {
+        return _validatets.validateCommand;
+    },
+    get validateSchema () {
+        return _jsonschemats.validateSchema;
+    }
+});
+var _generatets = require("./commands/manifest/generate.js");
+var _metadatareaderts = require("./commands/manifest/metadata-reader.js");
+var _validatets = require("./commands/manifest/validate.js");
+var _upts = require("./commands/up.js");
+var _jsonschemats = require("./lib/json-schema.js");
+var _resolveserverconfigts = require("./lib/resolve-server-config.js");
+_export_star(require("./types.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+/* 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/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/cli/src/index.ts"],"sourcesContent":["// Base types and type guards\n\nexport {\n  type Combination,\n  type ConfigChoice,\n  type ConfigurationMode,\n  createConfigChoices,\n  type Dimension,\n  discoverServerJson,\n  extractServerName,\n  filterConfigChoices,\n  generateConditionalCombinations,\n  generateConfigFile,\n  generateConfigObject,\n  generateMatrixCombinations,\n  shouldPromptEnvVar,\n  TRANSPORT_MAP,\n} from './commands/manifest/generate.ts';\nexport { type CliArgMetadata, type EnvVarMetadata, MetadataReader, type ServerMetadata } from './commands/manifest/metadata-reader.ts';\n\n// Manifest commands\nexport { validateCommand } from './commands/manifest/validate.ts';\n// Commands\nexport { upCommand } from './commands/up.ts';\n// Library utilities\nexport { getSchema, SCHEMA_URL, validateSchema } from './lib/json-schema.ts';\nexport { type InlineConfigOptions, type ResolvedServerConfig, resolveServerConfig } from './lib/resolve-server-config.ts';\nexport * from './types.ts';\n"],"names":["MetadataReader","SCHEMA_URL","TRANSPORT_MAP","createConfigChoices","discoverServerJson","extractServerName","filterConfigChoices","generateConditionalCombinations","generateConfigFile","generateConfigObject","generateMatrixCombinations","getSchema","resolveServerConfig","shouldPromptEnvVar","upCommand","validateCommand","validateSchema"],"mappings":"AAAA,6BAA6B;;;;;;;;;;;;QAkBsBA;eAAAA,gCAAc;;QAO7CC;eAAAA,wBAAU;;QAT5BC;eAAAA,yBAAa;;QAVbC;eAAAA,+BAAmB;;QAEnBC;eAAAA,8BAAkB;;QAClBC;eAAAA,6BAAiB;;QACjBC;eAAAA,+BAAmB;;QACnBC;eAAAA,2CAA+B;;QAC/BC;eAAAA,8BAAkB;;QAClBC;eAAAA,gCAAoB;;QACpBC;eAAAA,sCAA0B;;QAWnBC;eAAAA,uBAAS;;QAC4CC;eAAAA,0CAAmB;;QAX/EC;eAAAA,8BAAkB;;QAQXC;eAAAA,eAAS;;QAFTC;eAAAA,2BAAe;;QAIQC;eAAAA,4BAAc;;;0BARvC;gCACuF;0BAG9D;oBAEN;4BAE4B;qCACmC;qBAC3E"}

package/dist/cjs/lib/find-config.d.cts

@@ -0,0 +1,14 @@
+/**
+ * find-config.ts
+ *
+ * Find .mcp.json config file by searching up the directory tree.
+ * Searches from cwd up to home directory (like Claude Code).
+ */
+/**
+ * Find .mcp.json by searching up directory tree from cwd to home directory.
+ *
+ * @param explicitPath - If provided, validates and returns this path (for --config flag)
+ * @returns The resolved path to the config file
+ * @throws Error if config file not found
+ */
+export declare function findConfigPath(explicitPath?: string): string;

package/dist/cjs/lib/find-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * find-config.ts
+ *
+ * Find .mcp.json config file by searching up the directory tree.
+ * Searches from cwd up to home directory (like Claude Code).
+ */
+/**
+ * Find .mcp.json by searching up directory tree from cwd to home directory.
+ *
+ * @param explicitPath - If provided, validates and returns this path (for --config flag)
+ * @returns The resolved path to the config file
+ * @throws Error if config file not found
+ */
+export declare function findConfigPath(explicitPath?: string): string;

package/dist/cjs/lib/find-config.js

@@ -0,0 +1,93 @@
+/**
+ * find-config.ts
+ *
+ * Find .mcp.json config file by searching up the directory tree.
+ * Searches from cwd up to home directory (like Claude Code).
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findConfigPath", {
+    enumerable: true,
+    get: function() {
+        return findConfigPath;
+    }
+});
+var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _modulerootsync = /*#__PURE__*/ _interop_require_default(require("module-root-sync"));
+var _os = /*#__PURE__*/ _interop_require_wildcard(require("os"));
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+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;
+}
+var CONFIG_NAME = '.mcp.json';
+function findConfigPath(explicitPath) {
+    // If explicit path provided, validate it exists
+    if (explicitPath) {
+        var resolvedPath = _path.resolve(explicitPath);
+        if (!_fs.existsSync(resolvedPath)) {
+            throw new Error("Config file not found: ".concat(resolvedPath));
+        }
+        return resolvedPath;
+    }
+    var cwd = process.cwd();
+    var homeDir = _os.homedir();
+    // Use module-root-sync with custom file name to search up
+    try {
+        var configDir = (0, _modulerootsync.default)(cwd, {
+            name: CONFIG_NAME
+        });
+        var configPath = _path.join(configDir, CONFIG_NAME);
+        // Ensure we haven't gone above home directory
+        if (!configPath.startsWith(homeDir)) {
+            throw new Error("Config file not found in directory tree (searched from ".concat(cwd, " to ").concat(homeDir, ")"));
+        }
+        return configPath;
+    } catch (_) {
+        throw new Error("Config file not found: ".concat(CONFIG_NAME, "\n\nSearched from ").concat(cwd, " up to ").concat(homeDir));
+    }
+}
+/* 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/find-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/cli/src/lib/find-config.ts"],"sourcesContent":["/**\n * find-config.ts\n *\n * Find .mcp.json config file by searching up the directory tree.\n * Searches from cwd up to home directory (like Claude Code).\n */\n\nimport * as fs from 'fs';\nimport moduleRoot from 'module-root-sync';\nimport * as os from 'os';\nimport * as path from 'path';\n\nconst CONFIG_NAME = '.mcp.json';\n\n/**\n * Find .mcp.json by searching up directory tree from cwd to home directory.\n *\n * @param explicitPath - If provided, validates and returns this path (for --config flag)\n * @returns The resolved path to the config file\n * @throws Error if config file not found\n */\nexport function findConfigPath(explicitPath?: string): string {\n  // If explicit path provided, validate it exists\n  if (explicitPath) {\n    const resolvedPath = path.resolve(explicitPath);\n    if (!fs.existsSync(resolvedPath)) {\n      throw new Error(`Config file not found: ${resolvedPath}`);\n    }\n    return resolvedPath;\n  }\n\n  const cwd = process.cwd();\n  const homeDir = os.homedir();\n\n  // Use module-root-sync with custom file name to search up\n  try {\n    const configDir = moduleRoot(cwd, { name: CONFIG_NAME });\n    const configPath = path.join(configDir, CONFIG_NAME);\n\n    // Ensure we haven't gone above home directory\n    if (!configPath.startsWith(homeDir)) {\n      throw new Error(`Config file not found in directory tree (searched from ${cwd} to ${homeDir})`);\n    }\n\n    return configPath;\n  } catch (_) {\n    throw new Error(`Config file not found: ${CONFIG_NAME}\\n\\nSearched from ${cwd} up to ${homeDir}`);\n  }\n}\n"],"names":["findConfigPath","CONFIG_NAME","explicitPath","resolvedPath","path","resolve","fs","existsSync","Error","cwd","process","homeDir","os","homedir","configDir","moduleRoot","name","configPath","join","startsWith","_"],"mappings":"AAAA;;;;;CAKC;;;;+BAgBeA;;;eAAAA;;;0DAdI;qEACG;0DACH;4DACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtB,IAAMC,cAAc;AASb,SAASD,eAAeE,YAAqB;IAClD,gDAAgD;IAChD,IAAIA,cAAc;QAChB,IAAMC,eAAeC,MAAKC,OAAO,CAACH;QAClC,IAAI,CAACI,IAAGC,UAAU,CAACJ,eAAe;YAChC,MAAM,IAAIK,MAAM,AAAC,0BAAsC,OAAbL;QAC5C;QACA,OAAOA;IACT;IAEA,IAAMM,MAAMC,QAAQD,GAAG;IACvB,IAAME,UAAUC,IAAGC,OAAO;IAE1B,0DAA0D;IAC1D,IAAI;QACF,IAAMC,YAAYC,IAAAA,uBAAU,EAACN,KAAK;YAAEO,MAAMf;QAAY;QACtD,IAAMgB,aAAab,MAAKc,IAAI,CAACJ,WAAWb;QAExC,8CAA8C;QAC9C,IAAI,CAACgB,WAAWE,UAAU,CAACR,UAAU;YACnC,MAAM,IAAIH,MAAM,AAAC,0DAAmEG,OAAVF,KAAI,QAAc,OAARE,SAAQ;QAC9F;QAEA,OAAOM;IACT,EAAE,OAAOG,GAAG;QACV,MAAM,IAAIZ,MAAM,AAAC,0BAAyDC,OAAhCR,aAAY,sBAAiCU,OAAbF,KAAI,WAAiB,OAARE;IACzF;AACF"}

package/dist/cjs/lib/json-schema.d.cts

@@ -0,0 +1,18 @@
+export declare const SCHEMA_URL = "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json";
+/**
+ * Get MCP server.json schema (fetches once, then caches)
+ *
+ * Strategy:
+ * 1. Return cached schema if available
+ * 2. Try fetching latest schema from URL
+ * 3. Fall back to bundled schema if network fails
+ */
+export declare function getSchema(): Promise<object>;
+/**
+ * Validate server.json against MCP schema
+ *
+ * @param serverJson - Parsed server.json content to validate
+ * @param serverName - Server name for error messages
+ * @throws Error with detailed validation messages if invalid
+ */
+export declare function validateSchema(serverJson: unknown, serverName: string): Promise<void>;

package/dist/cjs/lib/json-schema.d.ts

@@ -0,0 +1,18 @@
+export declare const SCHEMA_URL = "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json";
+/**
+ * Get MCP server.json schema (fetches once, then caches)
+ *
+ * Strategy:
+ * 1. Return cached schema if available
+ * 2. Try fetching latest schema from URL
+ * 3. Fall back to bundled schema if network fails
+ */
+export declare function getSchema(): Promise<object>;
+/**
+ * Validate server.json against MCP schema
+ *
+ * @param serverJson - Parsed server.json content to validate
+ * @param serverName - Server name for error messages
+ * @throws Error with detailed validation messages if invalid
+ */
+export declare function validateSchema(serverJson: unknown, serverName: string): Promise<void>;