mcp-server-diff 2.1.0

package/src/git.ts

@@ -0,0 +1,262 @@
+/**
+ * Git utilities for MCP server diff
+ */
+
+import * as exec from "@actions/exec";
+import * as core from "@actions/core";
+
+export interface GitInfo {
+  currentBranch: string;
+  compareRef: string;
+}
+
+/**
+ * Get current branch name
+ */
+export async function getCurrentBranch(): Promise<string> {
+  let output = "";
+  try {
+    await exec.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      silent: true,
+      listeners: {
+        stdout: (data) => {
+          output += data.toString();
+        },
+      },
+    });
+    return output.trim() || "HEAD";
+  } catch {
+    return "HEAD";
+  }
+}
+
+/**
+ * Determine what ref to compare against
+ * Priority: 1) Explicit compare_ref, 2) Auto-detect previous tag, 3) Merge-base with main
+ */
+export async function determineCompareRef(
+  explicitRef?: string,
+  githubRef?: string
+): Promise<string> {
+  // If explicit ref provided, use it
+  if (explicitRef) {
+    core.info(`Using explicit compare ref: ${explicitRef}`);
+    return explicitRef;
+  }
+
+  // Check if this is a tag push
+  if (githubRef?.startsWith("refs/tags/")) {
+    const currentTag = githubRef.replace("refs/tags/", "");
+    core.info(`Detected tag push: ${currentTag}`);
+
+    // Try to find previous tag
+    const previousTag = await findPreviousTag(currentTag);
+    if (previousTag && previousTag !== currentTag) {
+      core.info(`Auto-detected previous tag: ${previousTag}`);
+      return previousTag;
+    }
+
+    // Fall back to first commit
+    const firstCommit = await getFirstCommit();
+    core.warning("No previous tag found, comparing against initial commit");
+    return firstCommit;
+  }
+
+  // Default: find merge-base with main
+  const baseRef = await findMainBranch();
+  const mergeBase = await getMergeBase(baseRef);
+  core.info(`Using merge-base with ${baseRef}: ${mergeBase}`);
+  return mergeBase;
+}
+
+/**
+ * Find the previous tag (sorted by version)
+ */
+async function findPreviousTag(currentTag: string): Promise<string | null> {
+  let output = "";
+  try {
+    await exec.exec("git", ["tag", "--sort=-v:refname"], {
+      silent: true,
+      listeners: {
+        stdout: (data) => {
+          output += data.toString();
+        },
+      },
+    });
+
+    const tags = output.trim().split("\n");
+    const currentIndex = tags.indexOf(currentTag);
+    if (currentIndex >= 0 && currentIndex < tags.length - 1) {
+      return tags[currentIndex + 1];
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the first commit in the repository
+ */
+async function getFirstCommit(): Promise<string> {
+  let output = "";
+  await exec.exec("git", ["rev-list", "--max-parents=0", "HEAD"], {
+    silent: true,
+    listeners: {
+      stdout: (data) => {
+        output += data.toString();
+      },
+    },
+  });
+  return output.trim().split("\n")[0];
+}
+
+/**
+ * Find the main branch (origin/main, main, or first commit)
+ */
+async function findMainBranch(): Promise<string> {
+  // Try origin/main
+  try {
+    await exec.exec("git", ["rev-parse", "--verify", "origin/main"], { silent: true });
+    return "origin/main";
+  } catch {
+    // Try main
+    try {
+      await exec.exec("git", ["rev-parse", "--verify", "main"], { silent: true });
+      return "main";
+    } catch {
+      // Fall back to first commit
+      return await getFirstCommit();
+    }
+  }
+}
+
+/**
+ * Get merge-base between HEAD and a ref
+ */
+async function getMergeBase(ref: string): Promise<string> {
+  let output = "";
+  try {
+    await exec.exec("git", ["merge-base", "HEAD", ref], {
+      silent: true,
+      listeners: {
+        stdout: (data) => {
+          output += data.toString();
+        },
+      },
+    });
+    return output.trim();
+  } catch {
+    return ref;
+  }
+}
+
+/**
+ * Create a worktree for the compare ref
+ */
+export async function createWorktree(ref: string, path: string): Promise<boolean> {
+  try {
+    await exec.exec("git", ["worktree", "add", "--quiet", path, ref], { silent: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove a worktree
+ */
+export async function removeWorktree(path: string): Promise<void> {
+  try {
+    await exec.exec("git", ["worktree", "remove", "--force", path], { silent: true });
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Checkout a ref (fallback if worktree fails)
+ */
+export async function checkout(ref: string): Promise<void> {
+  await exec.exec("git", ["checkout", "--quiet", ref], { silent: true });
+}
+
+/**
+ * Checkout previous branch/ref
+ */
+export async function checkoutPrevious(): Promise<void> {
+  try {
+    await exec.exec("git", ["checkout", "--quiet", "-"], { silent: true });
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Get a display-friendly name for a ref.
+ * Returns branch/tag name if available, otherwise the short SHA.
+ */
+export async function getRefDisplayName(ref: string): Promise<string> {
+  // If it's already a readable name (not a SHA), return it
+  if (!ref.match(/^[a-f0-9]{40}$/i) && !ref.match(/^[a-f0-9]{7,}$/i)) {
+    // It's likely already a branch/tag name
+    return ref;
+  }
+
+  // Try to find a branch name pointing to this ref
+  let output = "";
+  try {
+    await exec.exec("git", ["branch", "--points-at", ref, "--format=%(refname:short)"], {
+      silent: true,
+      listeners: {
+        stdout: (data) => {
+          output += data.toString();
+        },
+      },
+    });
+    const branches = output.trim().split("\n").filter(Boolean);
+    if (branches.length > 0) {
+      // Prefer main/master if available
+      if (branches.includes("main")) return "main";
+      if (branches.includes("master")) return "master";
+      return branches[0];
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  // Try to find a tag pointing to this ref
+  output = "";
+  try {
+    await exec.exec("git", ["tag", "--points-at", ref], {
+      silent: true,
+      listeners: {
+        stdout: (data) => {
+          output += data.toString();
+        },
+      },
+    });
+    const tags = output.trim().split("\n").filter(Boolean);
+    if (tags.length > 0) {
+      return tags[0];
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  // Fall back to short SHA
+  output = "";
+  try {
+    await exec.exec("git", ["rev-parse", "--short", ref], {
+      silent: true,
+      listeners: {
+        stdout: (data) => {
+          output += data.toString();
+        },
+      },
+    });
+    return output.trim() || ref;
+  } catch {
+    return ref.substring(0, 7);
+  }
+}

package/src/index.ts

@@ -0,0 +1,284 @@
+/**
+ * MCP Server Diff - Main Entry Point
+ *
+ * Diffs MCP server public interfaces by comparing
+ * API responses between the current branch and a reference.
+ */
+
+import * as core from "@actions/core";
+import * as exec from "@actions/exec";
+import { getCurrentBranch, determineCompareRef, getRefDisplayName } from "./git.js";
+import { parseConfigurations, parseCustomMessages, parseHeaders, runAllTests } from "./runner.js";
+import { generateReport, generateMarkdownReport, saveReport } from "./reporter.js";
+import type { ActionInputs } from "./types.js";
+
+/**
+ * Get all inputs from the action (composite action style - INPUT_* env vars)
+ */
+function getInputs(): ActionInputs {
+  // Helper to get input from INPUT_* environment variables
+  const getInput = (name: string): string => {
+    const envName = `INPUT_${name.toUpperCase().replace(/-/g, "_")}`;
+    return process.env[envName] || "";
+  };
+
+  const getBooleanInput = (name: string): boolean => {
+    const value = getInput(name);
+    return value.toLowerCase() === "true";
+  };
+
+  const transport = (getInput("transport") || "stdio") as "stdio" | "streamable-http";
+  const startCommand = getInput("start_command");
+  const serverUrl = getInput("server_url");
+
+  // Parse configurations
+  const configurationsInput = getInput("configurations");
+  const configurations = parseConfigurations(
+    configurationsInput,
+    transport,
+    startCommand,
+    serverUrl
+  );
+
+  // Parse custom messages
+  const customMessagesInput = getInput("custom_messages");
+  const customMessages = parseCustomMessages(customMessagesInput);
+
+  // Parse global headers
+  const headersInput = getInput("headers");
+  const headers = parseHeaders(headersInput);
+
+  return {
+    // Language setup
+    setupNode: getBooleanInput("setup_node"),
+    nodeVersion: getInput("node_version") || "20",
+    setupPython: getBooleanInput("setup_python"),
+    pythonVersion: getInput("python_version") || "3.11",
+    setupGo: getBooleanInput("setup_go"),
+    goVersion: getInput("go_version") || "1.24",
+    setupRust: getBooleanInput("setup_rust"),
+    rustToolchain: getInput("rust_toolchain") || "stable",
+    setupDotnet: getBooleanInput("setup_dotnet"),
+    dotnetVersion: getInput("dotnet_version") || "9.0.x",
+
+    // Build configuration
+    installCommand: getInput("install_command"),
+    buildCommand: getInput("build_command"),
+    startCommand,
+
+    // Transport configuration
+    transport,
+    serverUrl,
+    headers,
+    configurations,
+    customMessages,
+
+    // Shared HTTP server configuration
+    httpStartCommand: getInput("http_start_command"),
+    httpStartupWaitMs: parseInt(getInput("http_startup_wait_ms") || "2000", 10),
+
+    // Test configuration
+    compareRef: getInput("compare_ref"),
+    failOnError: getBooleanInput("fail_on_error") !== false, // default true
+    failOnDiff: getBooleanInput("fail_on_diff") === true, // default false
+    envVars: getInput("env_vars"),
+    serverTimeout: parseInt(getInput("server_timeout") || "30000", 10),
+  };
+}
+
+/**
+ * Set up language runtimes based on inputs
+ */
+async function setupLanguages(inputs: ActionInputs): Promise<void> {
+  // We rely on composite action setup or assume runtimes are available
+  // In a pure Node action, we'd need to install these ourselves or
+  // require the user to set them up in a prior step
+
+  core.info("📦 Verifying language runtimes...");
+
+  if (inputs.setupNode) {
+    try {
+      let output = "";
+      await exec.exec("node", ["--version"], {
+        silent: true,
+        listeners: {
+          stdout: (data) => {
+            output += data.toString();
+          },
+        },
+      });
+      core.info(`  Node.js: ${output.trim()}`);
+    } catch {
+      core.warning("Node.js not available - please set up in a prior step");
+    }
+  }
+
+  if (inputs.setupPython) {
+    try {
+      let output = "";
+      await exec.exec("python", ["--version"], {
+        silent: true,
+        listeners: {
+          stdout: (data) => {
+            output += data.toString();
+          },
+        },
+      });
+      core.info(`  Python: ${output.trim()}`);
+    } catch {
+      core.warning("Python not available - please set up in a prior step");
+    }
+  }
+
+  if (inputs.setupGo) {
+    try {
+      let output = "";
+      await exec.exec("go", ["version"], {
+        silent: true,
+        listeners: {
+          stdout: (data) => {
+            output += data.toString();
+          },
+        },
+      });
+      core.info(`  Go: ${output.trim()}`);
+    } catch {
+      core.warning("Go not available - please set up in a prior step");
+    }
+  }
+
+  if (inputs.setupRust) {
+    try {
+      let output = "";
+      await exec.exec("rustc", ["--version"], {
+        silent: true,
+        listeners: {
+          stdout: (data) => {
+            output += data.toString();
+          },
+        },
+      });
+      core.info(`  Rust: ${output.trim()}`);
+    } catch {
+      core.warning("Rust not available - please set up in a prior step");
+    }
+  }
+
+  if (inputs.setupDotnet) {
+    try {
+      let output = "";
+      await exec.exec("dotnet", ["--version"], {
+        silent: true,
+        listeners: {
+          stdout: (data) => {
+            output += data.toString();
+          },
+        },
+      });
+      core.info(`  .NET: ${output.trim()}`);
+    } catch {
+      core.warning(".NET not available - please set up in a prior step");
+    }
+  }
+}
+
+/**
+ * Run initial build for current branch
+ */
+async function runInitialBuild(inputs: ActionInputs): Promise<void> {
+  core.info("🔨 Running initial build...");
+
+  if (inputs.installCommand) {
+    core.info(`  Install: ${inputs.installCommand}`);
+    await exec.exec("sh", ["-c", inputs.installCommand]);
+  }
+
+  if (inputs.buildCommand) {
+    core.info(`  Build: ${inputs.buildCommand}`);
+    await exec.exec("sh", ["-c", inputs.buildCommand]);
+  }
+}
+
+/**
+ * Main action entry point
+ */
+async function run(): Promise<void> {
+  try {
+    core.info("🚀 MCP Conformance Action");
+    core.info("");
+
+    // Get inputs
+    const inputs = getInputs();
+
+    core.info(`📋 Configuration:`);
+    core.info(`  Transport: ${inputs.transport}`);
+    core.info(`  Configurations: ${inputs.configurations.length}`);
+    for (const config of inputs.configurations) {
+      core.info(`    - ${config.name} (${config.transport})`);
+    }
+
+    // Set up languages
+    await setupLanguages(inputs);
+
+    // Run initial build
+    await runInitialBuild(inputs);
+
+    // Determine comparison ref
+    const currentBranch = await getCurrentBranch();
+    const compareRef = await determineCompareRef(inputs.compareRef, process.env.GITHUB_REF);
+    const compareRefDisplay = await getRefDisplayName(compareRef);
+
+    core.info("");
+    core.info(`📊 Comparison:`);
+    core.info(`  Current: ${currentBranch}`);
+    core.info(
+      `  Compare: ${compareRefDisplay}${compareRefDisplay !== compareRef ? ` (${compareRef.substring(0, 7)})` : ""}`
+    );
+
+    // Run all tests
+    core.info("");
+    core.info("🧪 Running diff...");
+
+    const workDir = process.cwd();
+    const results = await runAllTests({
+      workDir,
+      inputs,
+      compareRef,
+    });
+
+    // Generate and save report
+    core.info("");
+    core.info("📝 Generating report...");
+
+    const report = generateReport(results, currentBranch, compareRefDisplay);
+    const markdown = generateMarkdownReport(report);
+    saveReport(report, markdown, workDir);
+
+    // Set final status
+    core.info("");
+
+    // Check for actual probe errors (separate from differences)
+    const hasErrors = results.some((r) => r.diffs.has("error"));
+
+    if (hasErrors && inputs.failOnError) {
+      const errorConfigs = results.filter((r) => r.diffs.has("error")).map((r) => r.configName);
+      core.setFailed(`❌ Probe errors occurred in: ${errorConfigs.join(", ")}`);
+    } else if (report.diffCount > 0) {
+      if (inputs.failOnDiff) {
+        core.setFailed(`❌ ${report.diffCount} configuration(s) have API changes`);
+      } else {
+        core.info(`📋 ${report.diffCount} configuration(s) have API changes`);
+      }
+      if (hasErrors) {
+        core.warning("Some configurations had probe errors (fail_on_error is disabled)");
+      }
+    } else {
+      core.info("✅ All tests passed - no API changes detected");
+    }
+  } catch (error) {
+    core.setFailed(`Action failed: ${error}`);
+  }
+}
+
+// Run the action
+run();

package/src/logger.ts

@@ -0,0 +1,93 @@
+/**
+ * Logger abstraction - works in both CLI and GitHub Actions contexts
+ */
+
+import * as core from "@actions/core";
+
+export interface Logger {
+  info(message: string): void;
+  warning(message: string): void;
+  error(message: string): void;
+  debug(message: string): void;
+}
+
+/**
+ * GitHub Actions logger - wraps @actions/core
+ */
+export class ActionsLogger implements Logger {
+  info(message: string): void {
+    core.info(message);
+  }
+
+  warning(message: string): void {
+    core.warning(message);
+  }
+
+  error(message: string): void {
+    core.error(message);
+  }
+
+  debug(message: string): void {
+    core.debug(message);
+  }
+}
+
+/**
+ * Console logger for CLI usage
+ */
+export class ConsoleLogger implements Logger {
+  private verbose: boolean;
+
+  constructor(verbose: boolean = false) {
+    this.verbose = verbose;
+  }
+
+  info(message: string): void {
+    console.log(message);
+  }
+
+  warning(message: string): void {
+    console.log(`⚠️  ${message}`);
+  }
+
+  error(message: string): void {
+    console.error(`❌ ${message}`);
+  }
+
+  debug(message: string): void {
+    if (this.verbose) {
+      console.log(`🔍 ${message}`);
+    }
+  }
+}
+
+/**
+ * Quiet logger - only outputs errors
+ */
+export class QuietLogger implements Logger {
+  info(_message: string): void {}
+  warning(_message: string): void {}
+  error(message: string): void {
+    console.error(message);
+  }
+  debug(_message: string): void {}
+}
+
+// Global logger instance - defaults to Actions logger for backward compat
+let currentLogger: Logger = new ActionsLogger();
+
+export function setLogger(logger: Logger): void {
+  currentLogger = logger;
+}
+
+export function getLogger(): Logger {
+  return currentLogger;
+}
+
+// Convenience exports that use the current logger
+export const log = {
+  info: (message: string) => currentLogger.info(message),
+  warning: (message: string) => currentLogger.warning(message),
+  error: (message: string) => currentLogger.error(message),
+  debug: (message: string) => currentLogger.debug(message),
+};