@mcp-z/cli 1.0.0

package/dist/esm/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":["createServerRegistry","fs","path","findConfigPath","hasStartBlock","upCommand","opts","raw","configPath","config","JSON","parse","readFileSync","servers","mcpServers","configDir","dirname","dialects","stdioOnly","httpOnly","hasStartBlocks","Object","values","some","entry","console","log","cwd"],"mappings":"AAAA,SAASA,oBAAoB,QAA2C,gBAAgB;AACxF,YAAYC,QAAQ,KAAK;AACzB,YAAYC,UAAU,OAAO;AAC7B,SAASC,cAAc,QAAQ,wBAAwB;AACvD,SAASC,aAAa,QAA2B,cAAc;AAe/D;;;;;;;;;;;CAWC,GAED;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,OAAO,eAAeC,UAAUC,OAAkB,CAAC,CAAC;QAGlCC,MAAAA;IAFhB,MAAMC,aAAaL,eAAeG,KAAKG,MAAM;IAC7C,MAAMF,MAAMG,KAAKC,KAAK,CAACV,GAAGW,YAAY,CAACJ,YAAY;IACnD,MAAMK,WAAUN,QAAAA,kBAAAA,IAAIO,UAAU,cAAdP,6BAAAA,kBAAkBA,IAAIM,OAAO,cAA7BN,kBAAAA,OAAiCA;IACjD,MAAMQ,YAAYb,KAAKc,OAAO,CAACR;IAE/B,oCAAoC;IACpC,sDAAsD;IACtD,IAAIS,WAAsB;QAAC;QAAW;KAAQ;IAC9C,IAAIX,KAAKY,SAAS,EAAE;QAClBD,WAAW;YAAC;SAAU;IACxB,OAAO,IAAIX,KAAKa,QAAQ,EAAE;QACxBF,WAAW;YAAC;SAAQ;QACpB,sEAAsE;QACtE,MAAMG,iBAAiBC,OAAOC,MAAM,CAACT,WAAW,CAAC,GAAGU,IAAI,CAAC,CAACC,QAAUA,SAASpB,cAAcoB;QAC3F,IAAI,CAACJ,gBAAgB;YACnBK,QAAQC,GAAG,CAAC;YACZD,QAAQC,GAAG,CAAC;YACZ,wBAAwB;YACxB,OAAO1B,qBAAqB,CAAC,GAAG;gBAAE2B,KAAKZ;YAAU;QACnD;IACF;IAEA,OAAOf,qBAAqBa,SAAS;QACnCc,KAAKZ;QACLE;IACF;AACF"}

package/dist/esm/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/esm/index.js

@@ -0,0 +1,11 @@
+// Base types and type guards
+export { createConfigChoices, discoverServerJson, extractServerName, filterConfigChoices, generateConditionalCombinations, generateConfigFile, generateConfigObject, generateMatrixCombinations, shouldPromptEnvVar, TRANSPORT_MAP } from './commands/manifest/generate.js';
+export { MetadataReader } from './commands/manifest/metadata-reader.js';
+// Manifest commands
+export { validateCommand } from './commands/manifest/validate.js';
+// Commands
+export { upCommand } from './commands/up.js';
+// Library utilities
+export { getSchema, SCHEMA_URL, validateSchema } from './lib/json-schema.js';
+export { resolveServerConfig } from './lib/resolve-server-config.js';
+export * from './types.js';

package/dist/esm/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":["createConfigChoices","discoverServerJson","extractServerName","filterConfigChoices","generateConditionalCombinations","generateConfigFile","generateConfigObject","generateMatrixCombinations","shouldPromptEnvVar","TRANSPORT_MAP","MetadataReader","validateCommand","upCommand","getSchema","SCHEMA_URL","validateSchema","resolveServerConfig"],"mappings":"AAAA,6BAA6B;AAE7B,SAIEA,mBAAmB,EAEnBC,kBAAkB,EAClBC,iBAAiB,EACjBC,mBAAmB,EACnBC,+BAA+B,EAC/BC,kBAAkB,EAClBC,oBAAoB,EACpBC,0BAA0B,EAC1BC,kBAAkB,EAClBC,aAAa,QACR,kCAAkC;AACzC,SAAmDC,cAAc,QAA6B,yCAAyC;AAEvI,oBAAoB;AACpB,SAASC,eAAe,QAAQ,kCAAkC;AAClE,WAAW;AACX,SAASC,SAAS,QAAQ,mBAAmB;AAC7C,oBAAoB;AACpB,SAASC,SAAS,EAAEC,UAAU,EAAEC,cAAc,QAAQ,uBAAuB;AAC7E,SAA8DC,mBAAmB,QAAQ,iCAAiC;AAC1H,cAAc,aAAa"}

package/dist/esm/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/esm/lib/find-config.js

@@ -0,0 +1,42 @@
+/**
+ * find-config.ts
+ *
+ * Find .mcp.json config file by searching up the directory tree.
+ * Searches from cwd up to home directory (like Claude Code).
+ */ import * as fs from 'fs';
+import moduleRoot from 'module-root-sync';
+import * as os from 'os';
+import * as path from 'path';
+const CONFIG_NAME = '.mcp.json';
+/**
+ * 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 function findConfigPath(explicitPath) {
+    // If explicit path provided, validate it exists
+    if (explicitPath) {
+        const resolvedPath = path.resolve(explicitPath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Config file not found: ${resolvedPath}`);
+        }
+        return resolvedPath;
+    }
+    const cwd = process.cwd();
+    const homeDir = os.homedir();
+    // Use module-root-sync with custom file name to search up
+    try {
+        const configDir = moduleRoot(cwd, {
+            name: CONFIG_NAME
+        });
+        const 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 ${cwd} to ${homeDir})`);
+        }
+        return configPath;
+    } catch (_) {
+        throw new Error(`Config file not found: ${CONFIG_NAME}\n\nSearched from ${cwd} up to ${homeDir}`);
+    }
+}

package/dist/esm/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":["fs","moduleRoot","os","path","CONFIG_NAME","findConfigPath","explicitPath","resolvedPath","resolve","existsSync","Error","cwd","process","homeDir","homedir","configDir","name","configPath","join","startsWith","_"],"mappings":"AAAA;;;;;CAKC,GAED,YAAYA,QAAQ,KAAK;AACzB,OAAOC,gBAAgB,mBAAmB;AAC1C,YAAYC,QAAQ,KAAK;AACzB,YAAYC,UAAU,OAAO;AAE7B,MAAMC,cAAc;AAEpB;;;;;;CAMC,GACD,OAAO,SAASC,eAAeC,YAAqB;IAClD,gDAAgD;IAChD,IAAIA,cAAc;QAChB,MAAMC,eAAeJ,KAAKK,OAAO,CAACF;QAClC,IAAI,CAACN,GAAGS,UAAU,CAACF,eAAe;YAChC,MAAM,IAAIG,MAAM,CAAC,uBAAuB,EAAEH,cAAc;QAC1D;QACA,OAAOA;IACT;IAEA,MAAMI,MAAMC,QAAQD,GAAG;IACvB,MAAME,UAAUX,GAAGY,OAAO;IAE1B,0DAA0D;IAC1D,IAAI;QACF,MAAMC,YAAYd,WAAWU,KAAK;YAAEK,MAAMZ;QAAY;QACtD,MAAMa,aAAad,KAAKe,IAAI,CAACH,WAAWX;QAExC,8CAA8C;QAC9C,IAAI,CAACa,WAAWE,UAAU,CAACN,UAAU;YACnC,MAAM,IAAIH,MAAM,CAAC,uDAAuD,EAAEC,IAAI,IAAI,EAAEE,QAAQ,CAAC,CAAC;QAChG;QAEA,OAAOI;IACT,EAAE,OAAOG,GAAG;QACV,MAAM,IAAIV,MAAM,CAAC,uBAAuB,EAAEN,YAAY,kBAAkB,EAAEO,IAAI,OAAO,EAAEE,SAAS;IAClG;AACF"}

package/dist/esm/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>;

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

@@ -0,0 +1,66 @@
+import { Ajv } from 'ajv';
+import * as fs from 'fs';
+import { createRequire } from 'module';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// ESM-compatible __dirname equivalent
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Import ajv-formats (CommonJS module - use createRequire for ESM compatibility)
+const require = createRequire(import.meta.url);
+const addFormats = require('ajv-formats');
+export const SCHEMA_URL = 'https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json';
+let schemaCache = null;
+/**
+ * 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 async function getSchema() {
+    // Return cached schema
+    if (schemaCache) {
+        return schemaCache;
+    }
+    try {
+        // Try fetching latest schema
+        const response = await fetch(SCHEMA_URL);
+        if (response.ok) {
+            schemaCache = await response.json();
+            return schemaCache;
+        }
+    } catch  {
+    // Network error - fall through to bundled version
+    }
+    // Fallback to bundled schema
+    const 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 schemaCache;
+}
+/**
+ * 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 async function validateSchema(serverJson, serverName) {
+    const schema = await getSchema();
+    const ajv = new Ajv({
+        allErrors: true,
+        verbose: true,
+        strictSchema: false
+    });
+    // Add format validators (uri, email, etc.) to silence warnings
+    addFormats(ajv);
+    const validate = ajv.compile(schema);
+    const valid = validate(serverJson);
+    if (!valid) {
+        var _validate_errors;
+        const errors = ((_validate_errors = validate.errors) === null || _validate_errors === void 0 ? void 0 : _validate_errors.map((e)=>`  - ${e.instancePath || '(root)'} ${e.message}`).join('\n')) || 'Unknown validation error';
+        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.`);
+    }
+}

package/dist/esm/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":["Ajv","fs","createRequire","path","fileURLToPath","__filename","url","__dirname","dirname","require","addFormats","SCHEMA_URL","schemaCache","getSchema","response","fetch","ok","json","bundledPath","join","existsSync","Error","JSON","parse","readFileSync","validateSchema","serverJson","serverName","schema","ajv","allErrors","verbose","strictSchema","validate","compile","valid","errors","map","e","instancePath","message"],"mappings":"AAAA,SAASA,GAAG,QAA0B,MAAM;AAC5C,YAAYC,QAAQ,KAAK;AACzB,SAASC,aAAa,QAAQ,SAAS;AACvC,YAAYC,UAAU,OAAO;AAC7B,SAASC,aAAa,QAAQ,MAAM;AAEpC,sCAAsC;AACtC,MAAMC,aAAaD,cAAc,YAAYE,GAAG;AAChD,MAAMC,YAAYJ,KAAKK,OAAO,CAACH;AAE/B,iFAAiF;AACjF,MAAMI,UAAUP,cAAc,YAAYI,GAAG;AAC7C,MAAMI,aAAaD,QAAQ;AAE3B,OAAO,MAAME,aAAa,+EAA+E;AAEzG,IAAIC,cAA6B;AAEjC;;;;;;;CAOC,GACD,OAAO,eAAeC;IACpB,uBAAuB;IACvB,IAAID,aAAa;QACf,OAAOA;IACT;IAEA,IAAI;QACF,6BAA6B;QAC7B,MAAME,WAAW,MAAMC,MAAMJ;QAC7B,IAAIG,SAASE,EAAE,EAAE;YACfJ,cAAe,MAAME,SAASG,IAAI;YAClC,OAAOL;QACT;IACF,EAAE,OAAM;IACN,kDAAkD;IACpD;IAEA,6BAA6B;IAC7B,MAAMM,cAAcf,KAAKgB,IAAI,CAACZ,WAAW;IACzC,IAAI,CAACN,GAAGmB,UAAU,CAACF,cAAc;QAC/B,MAAM,IAAIG,MAAM,sEAAsE;IACxF;IAEAT,cAAcU,KAAKC,KAAK,CAACtB,GAAGuB,YAAY,CAACN,aAAa;IACtD,OAAON;AACT;AAEA;;;;;;CAMC,GACD,OAAO,eAAea,eAAeC,UAAmB,EAAEC,UAAkB;IAC1E,MAAMC,SAAS,MAAMf;IAErB,MAAMgB,MAAM,IAAI7B,IAAI;QAClB8B,WAAW;QACXC,SAAS;QACTC,cAAc;IAChB;IAEA,+DAA+D;IAC/DtB,WAAWmB;IAEX,MAAMI,WAAWJ,IAAIK,OAAO,CAACN;IAC7B,MAAMO,QAAQF,SAASP;IAEvB,IAAI,CAACS,OAAO;YACKF;QAAf,MAAMG,SAASH,EAAAA,mBAAAA,SAASG,MAAM,cAAfH,uCAAAA,iBAAiBI,GAAG,CAAC,CAACC,IAAmB,CAAC,IAAI,EAAEA,EAAEC,YAAY,IAAI,SAAS,CAAC,EAAED,EAAEE,OAAO,EAAE,EAAErB,IAAI,CAAC,UAAS;QAExH,MAAM,IAAIE,MAAM,CAAC,yBAAyB,EAAEM,WAAW,IAAI,EAAES,OAAO,6MAA6M,CAAC;IACpR;AACF"}

package/dist/esm/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/esm/lib/resolve-server-config.js

@@ -0,0 +1,154 @@
+/**
+ * resolve-server-config.ts
+ *
+ * Shared config resolution for CLI commands.
+ * Supports both config file-based and inline server configurations.
+ */ import { validateServers } from '@mcp-z/client';
+import * as fs from 'fs';
+import * as path from 'path';
+import { findConfigPath } from './find-config.js';
+/**
+ * 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 function resolveServerConfig(opts) {
+    // Validate mutual exclusivity of inline options
+    const 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');
+    }
+    const 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) {
+    const serverName = opts.server || 'inline';
+    const configDir = process.cwd();
+    let 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
+    const fullConfig = {
+        [serverName]: serverConfig
+    };
+    return {
+        serverName,
+        serverConfig,
+        configDir,
+        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');
+    }
+    const cfgPath = findConfigPath(opts.config);
+    const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    const servers = (_ref = (_raw_mcpServers = raw.mcpServers) !== null && _raw_mcpServers !== void 0 ? _raw_mcpServers : raw.servers) !== null && _ref !== void 0 ? _ref : raw;
+    const serverNames = Object.keys(servers || {});
+    if (!serverNames.includes(opts.server)) {
+        throw new Error(`Server '${opts.server}' not found in config\n\nAvailable servers: ${serverNames.join(', ')}`);
+    }
+    const serverConfig = servers[opts.server];
+    if (!serverConfig) {
+        throw new Error(`Server ${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) {
+    const 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) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonStr);
+    } catch (error) {
+        throw new Error(`Failed to parse server config JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('Server config must be a JSON object');
+    }
+    const 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
+    const serversMap = {
+        [serverName]: config
+    };
+    const validation = validateServers(serversMap);
+    if (!validation.valid) {
+        var _validation_errors;
+        const 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  ${errorDetails}`);
+    }
+    // Return as ServerConfig (compatible with McpServerEntry)
+    return config;
+}

package/dist/esm/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":["validateServers","fs","path","findConfigPath","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","JSON","parse","readFileSync","servers","mcpServers","serverNames","Object","keys","includes","join","dirname","runStr","parts","trim","split","command","args","slice","jsonStr","parsed","error","message","String","serversMap","validation","valid","errorDetails","errors"],"mappings":"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"}

package/dist/esm/package.json

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

package/dist/esm/types.d.ts

@@ -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;
+};

package/dist/esm/types.js

@@ -0,0 +1,11 @@
+// Type definitions for MCP config files
+// Type guards
+export function isHttpServer(config) {
+    return config.type === 'http';
+}
+export function isStdioServer(config) {
+    return !isHttpServer(config);
+}
+export function hasStartBlock(config) {
+    return isHttpServer(config) && config.start !== undefined;
+}

package/dist/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/cli/src/types.ts"],"sourcesContent":["// Type definitions for MCP config files\n\nexport interface MCPConfiguration {\n  mcpServers: Record<string, ServerConfig>;\n}\n\n// Stdio server: spawns with stdio transport\nexport interface ServerConfigStdio {\n  type?: 'stdio'; // Optional: absence means stdio\n  command: string;\n  args?: string[]; // OPTIONAL per .mcp.json standard\n  env?: Record<string, string>;\n}\n\n// HTTP server: connects to URL, optionally spawns the server locally\nexport interface ServerConfigHttp {\n  type: 'http';\n  url: string;\n  headers?: Record<string, string>;\n  start?: ServerConfigStdio; // Extension: reuse stdio config for spawning HTTP servers\n}\n\nexport type ServerConfig = ServerConfigStdio | ServerConfigHttp;\n\n// Type guards\nexport function isHttpServer(config: ServerConfig): config is ServerConfigHttp {\n  return config.type === 'http';\n}\n\nexport function isStdioServer(config: ServerConfig): config is ServerConfigStdio {\n  return !isHttpServer(config);\n}\n\nexport function hasStartBlock(config: ServerConfig): config is ServerConfigHttp & { start: ServerConfigStdio } {\n  return isHttpServer(config) && config.start !== undefined;\n}\n"],"names":["isHttpServer","config","type","isStdioServer","hasStartBlock","start","undefined"],"mappings":"AAAA,wCAAwC;AAwBxC,cAAc;AACd,OAAO,SAASA,aAAaC,MAAoB;IAC/C,OAAOA,OAAOC,IAAI,KAAK;AACzB;AAEA,OAAO,SAASC,cAAcF,MAAoB;IAChD,OAAO,CAACD,aAAaC;AACvB;AAEA,OAAO,SAASG,cAAcH,MAAoB;IAChD,OAAOD,aAAaC,WAAWA,OAAOI,KAAK,KAAKC;AAClD"}

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@mcp-z/cli",
+  "version": "1.0.0",
+  "description": "CLI tool for managing MCP server clusters and testing workflows.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "mcp-client",
+    "server",
+    "client",
+    "cli",
+    "lib",
+    "token-storage",
+    "testing",
+    "integration-testing",
+    "development-tools",
+    "server-management",
+    "lifecycle",
+    "graceful-shutdown",
+    "test-utilities",
+    "workflow",
+    "ai",
+    "claude"
+  ],
+  "homepage": "https://github.com/mcp-z/cli#readme",
+  "bugs": {
+    "url": "https://github.com/mcp-z/cli/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcp-z/cli.git"
+  },
+  "license": "MIT",
+  "author": "Kevin Malakoff <kmalakoff.info@gmail.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "bin": {
+    "mcp-z": "./bin/cli.js",
+    "z": "./bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "schemas"
+  ],
+  "scripts": {
+    "build": "tsc -p . --noEmit && tsds build",
+    "format": "tsds format",
+    "prepublish:check": "ncp",
+    "prepublishOnly": "tsds validate",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:engines": "nvu engines tsds test:node --no-timeouts",
+    "test:integration": "tsds test:node --no-timeouts 'test/integration/**/*.test.ts'",
+    "test:unit": "tsds test:node --no-timeouts 'test/unit/**/*.test.ts'",
+    "validate:server-json": "node --input-type=module -e \"import { execSync } from 'child_process'; import fs from 'fs'; import path from 'path'; import { validateSchema } from './src/lib/json-schema.ts'; const root = path.resolve(process.cwd(), '..'); const files = execSync('rg --files -g \\\"server.json\\\"', { cwd: root, encoding: 'utf8' }).trim().split('\\\\n').filter(Boolean); if (files.length === 0) { console.log('No server.json files found'); process.exit(0); } for (const file of files) { const data = JSON.parse(fs.readFileSync(path.join(root, file), 'utf8')); await validateSchema(data, file); console.log('OK ' + file); }\"",
+    "version": "tsds version"
+  },
+  "dependencies": {
+    "@inquirer/checkbox": "^5.0.3",
+    "@inquirer/confirm": "^6.0.3",
+    "@inquirer/input": "^5.0.3",
+    "@inquirer/password": "^5.0.3",
+    "@inquirer/select": "^5.0.3",
+    "@mcp-z/client": "^1.0.0",
+    "ajv": "^8.0.0",
+    "ajv-formats": "^3.0.0",
+    "commander": "^14.0.2",
+    "module-root-sync": "^2.0.0"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.0.2",
+    "express": "^5.0.0",
+    "get-port": "^7.1.0",
+    "node-version-use": "^2.1.6",
+    "ts-dev-stack": "^1.21.3",
+    "tsds-config": "^1.0.0",
+    "typescript": "^5.9.3",
+    "zod": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "tsds": {
+    "source": "src/index.ts"
+  }
+}