@boolesai/tspec-cli 1.2.0 → 1.3.1

package/dist/index.js

@@ -1,11 +1,12 @@
 import { Command } from "commander";
-import { existsSync, statSync, readFileSync } from "fs";
+import { existsSync, statSync, readFileSync, mkdirSync, writeFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { isAbsolute, resolve as resolve$1, basename, relative, dirname, join } from "path";
 import ora from "ora";
-import { getTypeFromFilePath, isSuiteFile, getSuiteProtocolType, validateTestCase, clearTemplateCache, executeSuite, parseTestCases, scheduler, registry as registry$1 } from "@boolesai/tspec";
-import { glob } from "glob";
 import chalk from "chalk";
+import { getTypeFromFilePath, isSuiteFile, getSuiteProtocolType, loadConfig, isProxyEnabled, getProxyConfig, validateTestCase, readTestFiles, ProxyClient, clearTemplateCache, getPluginManager, version as version$1, registry as registry$1, executeSuite, parseTestCases, scheduler, PluginManager } from "@boolesai/tspec";
+import { findConfigFile, findLocalConfigFile, findGlobalConfigFile, PLUGINS_DIR, isPluginInstalled, installPlugin, GLOBAL_CONFIG_PATH } from "@boolesai/tspec/plugin";
+import { glob } from "glob";
 import process$2 from "node:process";
 async function discoverTSpecFiles(patterns, cwd) {
   const workingDir = process.cwd();
@@ -232,7 +233,7 @@ function error(message, ...args) {
   console.error(chalk.red(`[error] ${message}`), ...args);
 }
 function log(message, ...args) {
-  console.error(message, ...args);
+  console.log(message, ...args);
 }
 function newline() {
   if (!globalOptions.quiet) {
@@ -249,8 +250,77 @@ const logger = {
   newline,
   setOptions: setLoggerOptions
 };
+async function executeValidateViaProxy(params, proxyConfig) {
+  const output = params.output ?? "text";
+  const { files: fileDescriptors } = await discoverTSpecFiles(params.files);
+  const allFiles = fileDescriptors.map((f) => f.path);
+  if (allFiles.length === 0) {
+    return {
+      success: false,
+      output: "No .tcase files found",
+      data: { results: [] }
+    };
+  }
+  const fileResult = readTestFiles(allFiles);
+  if (fileResult.errors.length > 0 && Object.keys(fileResult.fileContents).length === 0) {
+    return {
+      success: false,
+      output: `Failed to read test files: ${fileResult.errors.map((e) => e.error).join(", ")}`,
+      data: { results: [] }
+    };
+  }
+  const client = new ProxyClient({
+    url: proxyConfig.url,
+    timeout: proxyConfig.timeout,
+    headers: proxyConfig.headers
+  });
+  const result = await client.executeValidate(allFiles, fileResult.fileContents);
+  if (!result.success || !result.data) {
+    const errorMsg = result.error ? `${result.error.code}: ${result.error.message}${result.error.details ? ` (${result.error.details})` : ""}` : "Unknown proxy error";
+    return {
+      success: false,
+      output: output === "json" ? formatJson({ error: errorMsg, results: [] }) : `Proxy error: ${errorMsg}`,
+      data: { results: [] }
+    };
+  }
+  const proxyResponse = result.data;
+  const results = (proxyResponse.results || []).map((r) => ({
+    file: r.file,
+    valid: r.valid,
+    errors: r.errors
+  }));
+  const hasErrors = results.some((r) => !r.valid);
+  let outputStr;
+  if (output === "json") {
+    outputStr = formatJson({ results });
+  } else {
+    const parts = [];
+    parts.push(chalk.cyan(`[Proxy: ${proxyConfig.url}]`));
+    parts.push(formatValidationResults(
+      results.map((r) => ({ file: r.file, result: { valid: r.valid, errors: r.errors } })),
+      { format: output }
+    ));
+    outputStr = parts.join("\n");
+  }
+  return {
+    success: !hasErrors,
+    output: outputStr,
+    data: { results }
+  };
+}
 async function executeValidate(params) {
   const output = params.output ?? "text";
+  if (!params.noProxy) {
+    const configPath = params.config || findConfigFile() || void 0;
+    const config2 = await loadConfig(configPath);
+    const proxyUrl = params.proxyUrl;
+    if (proxyUrl || isProxyEnabled(config2, "validate")) {
+      const proxyConfig = proxyUrl ? { url: proxyUrl, timeout: 3e4, headers: {} } : getProxyConfig(config2);
+      if (proxyConfig) {
+        return executeValidateViaProxy(params, proxyConfig);
+      }
+    }
+  }
   const { files: fileDescriptors } = await discoverTSpecFiles(params.files);
   if (fileDescriptors.length === 0) {
     return {
@@ -278,13 +348,16 @@ async function executeValidate(params) {
     data: { results }
   };
 }
-const validateCommand = new Command("validate").description("Validate .tcase files for schema correctness").argument("<files...>", "Files or glob patterns to validate").option("-o, --output <format>", "Output format: json, text", "text").option("-q, --quiet", "Only output errors").action(async (files, options) => {
+const validateCommand = new Command("validate").description("Validate .tcase files for schema correctness").argument("<files...>", "Files or glob patterns to validate").option("-o, --output <format>", "Output format: json, text", "text").option("-q, --quiet", "Only output errors").option("--config <path>", "Path to tspec.config.json").option("--no-proxy", "Disable proxy for this execution").option("--proxy-url <url>", "Override proxy URL for this execution").action(async (files, options) => {
   setLoggerOptions({ quiet: options.quiet });
   const spinner = options.quiet ? null : ora("Validating...").start();
   try {
     const result = await executeValidate({
       files,
-      output: options.output
+      output: options.output,
+      noProxy: options.noProxy,
+      proxyUrl: options.proxyUrl,
+      config: options.config
     });
     spinner?.stop();
     logger.log(result.output);
@@ -353,6 +426,31 @@ async function runFileTestCasesInternal(descriptor, env, params, concurrency, fa
 }
 async function executeRun(params) {
   clearTemplateCache();
+  const configPath = params.config || findConfigFile();
+  if (!params.noProxy) {
+    const config2 = await loadConfig(configPath || void 0);
+    const proxyUrl = params.proxyUrl;
+    if (proxyUrl || isProxyEnabled(config2, "run")) {
+      const proxyConfig = proxyUrl ? { url: proxyUrl, timeout: 3e4, headers: {} } : getProxyConfig(config2);
+      if (proxyConfig) {
+        return executeRunViaProxy(params, proxyConfig);
+      }
+    }
+  }
+  if (configPath) {
+    const pluginManager = getPluginManager(version$1);
+    await pluginManager.initialize(configPath, {
+      skipAutoInstall: params.noAutoInstall
+    });
+    registry$1.enablePluginManager();
+  }
+  if (configPath) {
+    const pluginManager = getPluginManager(version$1);
+    await pluginManager.initialize(configPath, {
+      skipAutoInstall: params.noAutoInstall
+    });
+    registry$1.enablePluginManager();
+  }
   const concurrency = params.concurrency ?? 5;
   const env = params.env ?? {};
   const paramValues = params.params ?? {};
@@ -465,6 +563,7 @@ ${parseErrors.length} file(s) failed to parse:`);
 }
 async function executeSuiteRun(suiteFiles, additionalTspecFiles, options) {
   const { env, params: paramValues, failFast, output, verbose, quiet } = options;
+  const isJsonOutput = output === "json";
   const allResults = [];
   const parseErrors = [];
   let totalTests = 0;
@@ -478,14 +577,15 @@ async function executeSuiteRun(suiteFiles, additionalTspecFiles, options) {
       const suiteResult = await executeSuite(suiteDescriptor.path, {
         env,
         params: paramValues,
-        onSuiteStart: (name) => {
+        silent: isJsonOutput,
+        onSuiteStart: isJsonOutput ? void 0 : (name) => {
           if (!quiet) logger.log(chalk.blue(`
 Suite: ${name}`));
         },
-        onTestStart: (file) => {
+        onTestStart: isJsonOutput ? void 0 : (file) => {
           if (verbose) logger.log(chalk.gray(`  Running: ${file}`));
         },
-        onTestComplete: (file, result) => {
+        onTestComplete: isJsonOutput ? void 0 : (file, result) => {
           const statusIcon = result.status === "passed" ? chalk.green("✓") : chalk.red("✗");
           if (!quiet) logger.log(`  ${statusIcon} ${result.name} (${result.duration}ms)`);
         }
@@ -573,9 +673,105 @@ ${parseErrors.length} file(s) failed to parse:`);
     data: { results: allResults, summary, parseErrors }
   };
 }
-const runCommand = new Command("run").description("Execute test cases and report results").argument("<files...>", "Files or glob patterns to run").option("-o, --output <format>", "Output format: json, text", "text").option("-c, --concurrency <number>", "Max concurrent tests", "5").option("-e, --env <key=value>", "Environment variables", parseKeyValue$1, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue$1, {}).option("-v, --verbose", "Verbose output").option("-q, --quiet", "Only output summary").option("--fail-fast", "Stop on first failure").action(async (files, options) => {
+async function executeRunViaProxy(params, proxyConfig) {
+  const output = params.output ?? "text";
+  const { tspecFiles, suiteFiles } = await discoverAllTestFiles(params.files);
+  const allFiles = [...tspecFiles.map((f) => f.path), ...suiteFiles.map((f) => f.path)];
+  if (allFiles.length === 0) {
+    return {
+      success: false,
+      output: "No .tcase or .tsuite files found",
+      data: {
+        results: [],
+        summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
+        parseErrors: []
+      }
+    };
+  }
+  const fileResult = readTestFiles(allFiles);
+  if (fileResult.errors.length > 0 && Object.keys(fileResult.fileContents).length === 0) {
+    return {
+      success: false,
+      output: `Failed to read test files: ${fileResult.errors.map((e) => e.error).join(", ")}`,
+      data: {
+        results: [],
+        summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
+        parseErrors: fileResult.errors.map((e) => ({ file: e.file, error: e.error }))
+      }
+    };
+  }
+  const client = new ProxyClient({
+    url: proxyConfig.url,
+    timeout: proxyConfig.timeout,
+    headers: proxyConfig.headers
+  });
+  const result = await client.executeRun(
+    allFiles,
+    fileResult.fileContents,
+    {
+      concurrency: params.concurrency,
+      failFast: params.failFast,
+      env: params.env,
+      params: params.params
+    }
+  );
+  if (!result.success || !result.data) {
+    const errorMsg = result.error ? `${result.error.code}: ${result.error.message}${result.error.details ? ` (${result.error.details})` : ""}` : "Unknown proxy error";
+    return {
+      success: false,
+      output: output === "json" ? formatJson({ error: errorMsg, results: [], summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 }, parseErrors: [] }) : `Proxy error: ${errorMsg}`,
+      data: {
+        results: [],
+        summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
+        parseErrors: []
+      }
+    };
+  }
+  const proxyResponse = result.data;
+  const formattedResults = (proxyResponse.results || []).map((r) => ({
+    testCaseId: r.testCaseId,
+    passed: r.passed,
+    duration: r.duration,
+    assertions: (r.assertions || []).map((a) => ({
+      passed: a.passed,
+      type: a.type,
+      message: a.message || ""
+    }))
+  }));
+  const summary = proxyResponse.summary ? {
+    total: proxyResponse.summary.total,
+    passed: proxyResponse.summary.passed,
+    failed: proxyResponse.summary.failed,
+    passRate: proxyResponse.summary.passRate,
+    duration: proxyResponse.summary.duration
+  } : { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 };
+  const parseErrors = (proxyResponse.parseErrors || []).map((e) => ({
+    file: e.file,
+    error: e.message
+  }));
+  let outputStr;
+  if (output === "json") {
+    outputStr = formatJson({ results: formattedResults, summary, parseErrors });
+  } else {
+    const parts = [];
+    parts.push(chalk.cyan(`[Proxy: ${proxyConfig.url}]`));
+    parts.push(formatTestResults(formattedResults, summary, { format: output, verbose: params.verbose }));
+    if (parseErrors.length > 0) {
+      parts.push(`
+${parseErrors.length} file(s) failed to parse:`);
+      parseErrors.forEach(({ file, error: error2 }) => parts.push(`  ${file}: ${error2}`));
+    }
+    outputStr = parts.join("\n");
+  }
+  return {
+    success: summary.failed === 0 && parseErrors.length === 0,
+    output: outputStr,
+    data: { results: formattedResults, summary, parseErrors }
+  };
+}
+const runCommand = new Command("run").description("Execute test cases and report results").argument("<files...>", "Files or glob patterns to run").option("-o, --output <format>", "Output format: json, text", "text").option("-c, --concurrency <number>", "Max concurrent tests", "5").option("-e, --env <key=value>", "Environment variables", parseKeyValue$1, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue$1, {}).option("-v, --verbose", "Verbose output").option("-q, --quiet", "Only output summary").option("--fail-fast", "Stop on first failure").option("--config <path>", "Path to tspec.config.json for plugin loading").option("--no-auto-install", "Skip automatic plugin installation").option("--no-proxy", "Disable proxy for this execution").option("--proxy-url <url>", "Override proxy URL for this execution").action(async (files, options) => {
   setLoggerOptions({ verbose: options.verbose, quiet: options.quiet });
-  const spinner = options.quiet ? null : ora("Running tests...").start();
+  const spinner = options.quiet || options.output === "json" ? null : ora("Running tests...").start();
   try {
     const result = await executeRun({
       files,
@@ -584,6 +780,10 @@ const runCommand = new Command("run").description("Execute test cases and report
       verbose: options.verbose,
       quiet: options.quiet,
       failFast: options.failFast,
+      config: options.config,
+      noAutoInstall: options.noAutoInstall,
+      noProxy: options.noProxy,
+      proxyUrl: options.proxyUrl,
       env: options.env,
       params: options.params
     });
@@ -604,9 +804,20 @@ const runCommand = new Command("run").description("Execute test cases and report
     }
     process.exit(result.success ? 0 : 1);
   } catch (err) {
-    spinner?.fail("Execution failed");
+    spinner?.stop();
     const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
+    if (options.output === "json") {
+      const errorOutput = formatJson({
+        results: [],
+        summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
+        parseErrors: [],
+        error: message
+      });
+      logger.log(errorOutput);
+    } else {
+      spinner?.fail("Execution failed");
+      logger.error(message);
+    }
     process.exit(2);
   }
 });
@@ -617,12 +828,108 @@ function parseKeyValue(value, previous = {}) {
   }
   return previous;
 }
+async function executeParseViaProxy(params, proxyConfig) {
+  const output = params.output ?? "text";
+  params.verbose ?? false;
+  const { files: fileDescriptors } = await discoverTSpecFiles(params.files);
+  const allFiles = fileDescriptors.map((f) => f.path);
+  if (allFiles.length === 0) {
+    return {
+      success: false,
+      output: "No .tcase files found",
+      data: {
+        testCases: [],
+        parseErrors: [],
+        summary: { totalFiles: 0, totalTestCases: 0, parseErrors: 0 }
+      }
+    };
+  }
+  const fileResult = readTestFiles(allFiles);
+  if (fileResult.errors.length > 0 && Object.keys(fileResult.fileContents).length === 0) {
+    return {
+      success: false,
+      output: `Failed to read test files: ${fileResult.errors.map((e) => e.error).join(", ")}`,
+      data: {
+        testCases: [],
+        parseErrors: fileResult.errors.map((e) => ({ file: e.file, error: e.error })),
+        summary: { totalFiles: 0, totalTestCases: 0, parseErrors: fileResult.errors.length }
+      }
+    };
+  }
+  const client = new ProxyClient({
+    url: proxyConfig.url,
+    timeout: proxyConfig.timeout,
+    headers: proxyConfig.headers
+  });
+  const result = await client.executeParse(
+    allFiles,
+    fileResult.fileContents,
+    { env: params.env, params: params.params }
+  );
+  if (!result.success || !result.data) {
+    const errorMsg = result.error ? `${result.error.code}: ${result.error.message}${result.error.details ? ` (${result.error.details})` : ""}` : "Unknown proxy error";
+    return {
+      success: false,
+      output: output === "json" ? formatJson({ error: errorMsg, testCases: [], errors: [], summary: { totalFiles: 0, totalTestCases: 0, parseErrors: 0 } }) : `Proxy error: ${errorMsg}`,
+      data: {
+        testCases: [],
+        parseErrors: [],
+        summary: { totalFiles: 0, totalTestCases: 0, parseErrors: 0 }
+      }
+    };
+  }
+  const proxyResponse = result.data;
+  const testCases = proxyResponse.testCases || [];
+  const parseErrors = (proxyResponse.parseErrors || []).map((e) => ({
+    file: e.file,
+    error: e.message
+  }));
+  const summary = proxyResponse.summary || {
+    totalFiles: allFiles.length,
+    totalTestCases: testCases.length,
+    parseErrors: parseErrors.length
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = formatJson({ testCases, errors: parseErrors, summary });
+  } else {
+    const parts = [];
+    parts.push(chalk.cyan(`[Proxy: ${proxyConfig.url}]`));
+    parts.push(`Parsed ${testCases.length} test case(s) from ${summary.totalFiles} file(s)`);
+    parts.push("");
+    for (const testCase of testCases) {
+      parts.push(formatParsedTestCase(testCase, { format: output }));
+      parts.push("");
+    }
+    if (parseErrors.length > 0) {
+      parts.push(`${parseErrors.length} file(s) failed to parse:`);
+      parseErrors.forEach(({ file, error: error2 }) => parts.push(`  ${file}: ${error2}`));
+    }
+    outputStr = parts.join("\n");
+  }
+  return {
+    success: parseErrors.length === 0,
+    output: outputStr,
+    data: { testCases, parseErrors, summary }
+  };
+}
 async function executeParse(params) {
   clearTemplateCache();
   const output = params.output ?? "text";
   params.verbose ?? false;
   const env = params.env ?? {};
   const paramValues = params.params ?? {};
+  if (!params.noProxy) {
+    const configPath = params.config || findConfigFile() || void 0;
+    const config2 = await loadConfig(configPath);
+    const proxyUrl = params.proxyUrl;
+    if (proxyUrl || isProxyEnabled(config2, "parse")) {
+      const proxyConfig = proxyUrl ? { url: proxyUrl, timeout: 3e4, headers: {} } : getProxyConfig(config2);
+      if (proxyConfig) {
+        return executeParseViaProxy(params, proxyConfig);
+      }
+    }
+  }
   const { files: fileDescriptors } = await discoverTSpecFiles(params.files);
   if (fileDescriptors.length === 0) {
     return {
@@ -674,7 +981,7 @@ async function executeParse(params) {
     data: { testCases: allTestCases, parseErrors, summary }
   };
 }
-const parseCommand = new Command("parse").description("Parse and display test case information without execution").argument("<files...>", "Files or glob patterns to parse").option("-o, --output <format>", "Output format: json, text", "text").option("-v, --verbose", "Show detailed information").option("-q, --quiet", "Minimal output").option("-e, --env <key=value>", "Environment variables", parseKeyValue, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue, {}).action(async (files, options) => {
+const parseCommand = new Command("parse").description("Parse and display test case information without execution").argument("<files...>", "Files or glob patterns to parse").option("-o, --output <format>", "Output format: json, text", "text").option("-v, --verbose", "Show detailed information").option("-q, --quiet", "Minimal output").option("-e, --env <key=value>", "Environment variables", parseKeyValue, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue, {}).option("--config <path>", "Path to tspec.config.json").option("--no-proxy", "Disable proxy for this execution").option("--proxy-url <url>", "Override proxy URL for this execution").action(async (files, options) => {
   setLoggerOptions({ verbose: options.verbose, quiet: options.quiet });
   const spinner = options.quiet ? null : ora("Parsing...").start();
   try {
@@ -683,7 +990,10 @@ const parseCommand = new Command("parse").description("Parse and display test ca
       output: options.output,
       verbose: options.verbose,
       env: options.env,
-      params: options.params
+      params: options.params,
+      noProxy: options.noProxy,
+      proxyUrl: options.proxyUrl,
+      config: options.config
     });
     spinner?.stop();
     logger.log(result.output);
@@ -15138,6 +15448,262 @@ const mcpCommand = new Command("mcp").description("Start MCP server for tool int
   setLoggerOptions({ quiet: true });
   await startMcpServer();
 });
+async function executePluginList(params) {
+  const output = params.output ?? "text";
+  const pluginManager = new PluginManager(version$1);
+  const localConfigPath = findLocalConfigFile();
+  const globalConfigPath = findGlobalConfigFile();
+  const configPath = params.config || localConfigPath || globalConfigPath;
+  let loadSummary;
+  if (configPath) {
+    loadSummary = await pluginManager.initialize(configPath);
+  }
+  const plugins = pluginManager.list();
+  const protocols = pluginManager.listProtocols();
+  let healthReports;
+  if (params.health) {
+    healthReports = await pluginManager.healthCheck();
+  }
+  const data = {
+    plugins: plugins.map((p) => ({
+      name: p.name,
+      version: p.version,
+      description: p.description,
+      protocols: p.protocols,
+      author: p.author,
+      homepage: p.homepage
+    })),
+    protocols,
+    configPath: configPath || void 0,
+    configSources: {
+      local: localConfigPath || void 0,
+      global: globalConfigPath || void 0
+    },
+    pluginsDir: PLUGINS_DIR,
+    health: healthReports
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = JSON.stringify(data, null, 2);
+  } else {
+    outputStr = formatPluginListText(data, params.verbose ?? false, loadSummary);
+  }
+  return {
+    success: true,
+    output: outputStr,
+    data
+  };
+}
+function formatPluginListText(data, verbose, loadSummary) {
+  const lines = [];
+  lines.push(chalk.bold("\nTSpec Plugins\n"));
+  lines.push(chalk.bold("Config:"));
+  if (data.configSources?.local) {
+    lines.push(chalk.gray(`  Local:  ${data.configSources.local}`));
+  } else {
+    lines.push(chalk.gray("  Local:  (none)"));
+  }
+  if (data.configSources?.global) {
+    lines.push(chalk.gray(`  Global: ${data.configSources.global}`));
+  } else {
+    lines.push(chalk.gray("  Global: (none)"));
+  }
+  lines.push(chalk.gray(`  Plugins dir: ${data.pluginsDir}`));
+  if (loadSummary) {
+    lines.push("");
+    lines.push(chalk.gray(`Discovered: ${loadSummary.total}, Loaded: ${loadSummary.loaded}`));
+    if (loadSummary.installed && loadSummary.installed > 0) {
+      lines.push(chalk.green(`Installed: ${loadSummary.installed} plugin(s)`));
+    }
+    if (loadSummary.failed > 0) {
+      lines.push(chalk.red(`Failed: ${loadSummary.failed}`));
+      for (const error2 of loadSummary.errors) {
+        lines.push(chalk.red(`  ${error2.plugin}: ${error2.error}`));
+      }
+    }
+    if (loadSummary.installErrors && loadSummary.installErrors.length > 0) {
+      lines.push(chalk.red(`Install failures:`));
+      for (const error2 of loadSummary.installErrors) {
+        lines.push(chalk.red(`  ${error2.plugin}: ${error2.error}`));
+      }
+    }
+  }
+  lines.push("");
+  if (data.plugins.length === 0) {
+    lines.push(chalk.yellow("No plugins loaded."));
+    lines.push(chalk.gray("Add plugins to your tspec.config.json:"));
+    lines.push(chalk.gray("  {"));
+    lines.push(chalk.gray('    "plugins": ["@tspec/http", "@tspec/web"]'));
+    lines.push(chalk.gray("  }"));
+  } else {
+    for (const plugin of data.plugins) {
+      lines.push(`${chalk.cyan(plugin.name)} ${chalk.gray(`v${plugin.version}`)}`);
+      if (verbose && plugin.description) {
+        lines.push(`  ${plugin.description}`);
+      }
+      lines.push(`  Protocols: ${plugin.protocols.join(", ")}`);
+      if (verbose) {
+        if (plugin.author) {
+          lines.push(`  Author: ${plugin.author}`);
+        }
+        if (plugin.homepage) {
+          lines.push(`  Homepage: ${plugin.homepage}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (data.health) {
+    lines.push(chalk.bold("Health Check\n"));
+    for (const report of data.health) {
+      const status = report.healthy ? chalk.green("✓ Healthy") : chalk.red("✗ Unhealthy");
+      lines.push(`${chalk.cyan(report.plugin)}: ${status}`);
+      if (report.message) {
+        lines.push(`  ${report.message}`);
+      }
+    }
+    lines.push("");
+  }
+  if (data.protocols.length > 0) {
+    lines.push(chalk.bold("Supported Protocols: ") + data.protocols.join(", "));
+  }
+  return lines.join("\n");
+}
+const pluginListCommand = new Command("plugin:list").alias("plugins").description("List all installed TSpec plugins").option("-o, --output <format>", "Output format: json, text", "text").option("-v, --verbose", "Show detailed plugin information").option("--health", "Run health checks on all plugins").option("-c, --config <path>", "Path to tspec.config.json").action(async (options) => {
+  try {
+    const result = await executePluginList({
+      output: options.output,
+      verbose: options.verbose,
+      health: options.health,
+      config: options.config
+    });
+    logger.log(result.output);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(`Failed to list plugins: ${message}`);
+    process.exit(2);
+  }
+});
+function loadConfigFile(configPath) {
+  if (!existsSync(configPath)) {
+    return { plugins: [], pluginOptions: {} };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { plugins: [], pluginOptions: {} };
+  }
+}
+function saveConfigFile(configPath, config2) {
+  const dir = configPath.substring(0, configPath.lastIndexOf("/"));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n");
+}
+function addPluginToConfig(config2, pluginName) {
+  if (!config2.plugins) {
+    config2.plugins = [];
+  }
+  if (config2.plugins.includes(pluginName)) {
+    return false;
+  }
+  config2.plugins.push(pluginName);
+  return true;
+}
+async function executePluginInstall(params) {
+  const { pluginName, output = "text", global: useGlobal = false, config: customConfig } = params;
+  let configPath;
+  if (customConfig) {
+    configPath = customConfig;
+  } else if (useGlobal) {
+    configPath = GLOBAL_CONFIG_PATH;
+  } else {
+    const localConfig = findLocalConfigFile();
+    configPath = localConfig || GLOBAL_CONFIG_PATH;
+  }
+  const alreadyInstalled = isPluginInstalled(pluginName);
+  let installed = false;
+  let installError;
+  if (!alreadyInstalled) {
+    const result = await installPlugin(pluginName);
+    installed = result.success;
+    if (!result.success) {
+      installError = result.error;
+    }
+  } else {
+    installed = true;
+  }
+  let configUpdated = false;
+  if (installed) {
+    const config2 = loadConfigFile(configPath);
+    configUpdated = addPluginToConfig(config2, pluginName);
+    if (configUpdated) {
+      saveConfigFile(configPath, config2);
+    }
+  }
+  const data = {
+    plugin: pluginName,
+    installed,
+    configUpdated,
+    configPath: installed ? configPath : void 0,
+    error: installError
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = JSON.stringify(data, null, 2);
+  } else {
+    if (!installed) {
+      outputStr = chalk.red(`Failed to install ${pluginName}: ${installError || "Unknown error"}`);
+    } else if (alreadyInstalled && !configUpdated) {
+      outputStr = chalk.yellow(`Plugin ${pluginName} is already installed and configured.`);
+    } else if (alreadyInstalled && configUpdated) {
+      outputStr = [
+        chalk.green(`Plugin ${pluginName} is already installed.`),
+        chalk.green(`Added to config: ${configPath}`)
+      ].join("\n");
+    } else if (configUpdated) {
+      outputStr = [
+        chalk.green(`Successfully installed ${pluginName}`),
+        chalk.green(`Added to config: ${configPath}`)
+      ].join("\n");
+    } else {
+      outputStr = [
+        chalk.green(`Successfully installed ${pluginName}`),
+        chalk.yellow(`Plugin already in config: ${configPath}`)
+      ].join("\n");
+    }
+  }
+  return {
+    success: installed,
+    output: outputStr,
+    data
+  };
+}
+const pluginInstallCommand = new Command("plugin:install").alias("install").description("Install a TSpec plugin and add it to config").argument("<plugin>", "Plugin name (npm package name, e.g., @tspec/http)").option("-o, --output <format>", "Output format: json, text", "text").option("-g, --global", "Add plugin to global config (~/.tspec/tspec.config.json)").option("-c, --config <path>", "Path to config file to update").action(async (plugin, options) => {
+  const spinner = ora(`Installing ${plugin}...`).start();
+  try {
+    const result = await executePluginInstall({
+      pluginName: plugin,
+      output: options.output,
+      global: options.global,
+      config: options.config
+    });
+    spinner.stop();
+    logger.log(result.output);
+    process.exit(result.success ? 0 : 1);
+  } catch (err) {
+    spinner.stop();
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.output === "json") {
+      logger.log(JSON.stringify({ success: false, error: message }, null, 2));
+    } else {
+      logger.error(`Failed to install plugin: ${message}`);
+    }
+    process.exit(2);
+  }
+});
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
 const packageJson = JSON.parse(readFileSync(join(__dirname$1, "../package.json"), "utf-8"));
@@ -15148,5 +15714,7 @@ program.addCommand(runCommand);
 program.addCommand(parseCommand);
 program.addCommand(listCommand);
 program.addCommand(mcpCommand);
+program.addCommand(pluginListCommand);
+program.addCommand(pluginInstallCommand);
 await program.parseAsync();
 //# sourceMappingURL=index.js.map