@opensearch-project/agent-health 0.0.1 → 0.1.0

package/cli/dist/index.js

@@ -0,0 +1,4293 @@
+#!/usr/bin/env node
+
+// cli/index.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { config as loadDotenv } from "dotenv";
+import open from "open";
+import ora4 from "ora";
+
+// cli/utils/startServer.ts
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function findPackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return join(__dirname, "..");
+}
+async function startServer(options) {
+  process.env.VITE_BACKEND_PORT = String(options.port);
+  const packageRoot = findPackageRoot();
+  const serverPath = join(packageRoot, "server", "dist", "app.js");
+  const { createApp } = await import(serverPath);
+  const app = await createApp();
+  return new Promise((resolve5) => {
+    app.listen(options.port, "0.0.0.0", () => {
+      resolve5();
+    });
+  });
+}
+
+// cli/commands/list.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import Table from "cli-table3";
+
+// lib/config/loader.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+
+// lib/debug.ts
+var isBrowser = typeof window !== "undefined";
+var serverDebugEnabled = !isBrowser && typeof process !== "undefined" && process.env?.DEBUG === "true";
+function isDebugEnabled() {
+  if (isBrowser) {
+    try {
+      return localStorage.getItem("agenteval_debug") === "true";
+    } catch {
+      return false;
+    }
+  }
+  return serverDebugEnabled;
+}
+function debug(module, ...args) {
+  if (isDebugEnabled()) {
+    console.debug(`[${module}]`, ...args);
+  }
+}
+
+// lib/config.ts
+var isServerSide = typeof window === "undefined";
+var SERVER_PORT = isServerSide ? process.env?.VITE_BACKEND_PORT || process.env?.PORT || "4001" : "4001";
+var BACKEND_URL = isServerSide ? `http://localhost:${SERVER_PORT}` : "";
+var browserEnv = {};
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  try {
+    browserEnv = import.meta?.env || {};
+  } catch {
+  }
+}
+var getEnvVar = (key, defaultValue) => {
+  if (isServerSide) {
+    return process.env?.[key] || defaultValue || "";
+  }
+  return browserEnv[key] || defaultValue || "";
+};
+var ENV_CONFIG = {
+  // Backend server - empty string means relative URLs
+  backendUrl: BACKEND_URL,
+  // API endpoints (derived from backend URL)
+  judgeApiUrl: `${BACKEND_URL}/api/judge`,
+  storageApiUrl: `${BACKEND_URL}/api/storage`,
+  agentProxyUrl: `${BACKEND_URL}/api/agent`,
+  openSearchProxyUrl: `${BACKEND_URL}/api/opensearch/logs`,
+  // AWS/Bedrock
+  awsRegion: getEnvVar("AWS_REGION", "us-east-1"),
+  awsProfile: getEnvVar("AWS_PROFILE", "default"),
+  bedrockModelId: getEnvVar("BEDROCK_MODEL_ID", "anthropic.claude-3-5-sonnet-20241022-v2:0"),
+  // OpenSearch Logs (for fetching agent observability data)
+  openSearchLogsEndpoint: getEnvVar("OPENSEARCH_LOGS_ENDPOINT", ""),
+  openSearchLogsUsername: getEnvVar("OPENSEARCH_LOGS_USERNAME", ""),
+  openSearchLogsPassword: getEnvVar("OPENSEARCH_LOGS_PASSWORD", ""),
+  openSearchLogsTracesIndex: getEnvVar("OPENSEARCH_LOGS_TRACES_INDEX", "otel-v1-apm-span-*"),
+  openSearchLogsIndex: getEnvVar("OPENSEARCH_LOGS_INDEX", "ml-commons-logs-*"),
+  // Per-agent endpoints
+  langgraphEndpoint: getEnvVar("LANGGRAPH_ENDPOINT", "http://localhost:3000"),
+  mlcommonsEndpoint: getEnvVar("MLCOMMONS_ENDPOINT", "http://localhost:9200/_plugins/_ml/agents/{agent_id}/_execute/stream"),
+  holmesGptEndpoint: getEnvVar("HOLMESGPT_ENDPOINT", "http://localhost:5050/api/agui/chat"),
+  // ML-Commons agent headers
+  mlcommonsHeaderOpenSearchUrl: getEnvVar("MLCOMMONS_HEADER_OPENSEARCH_URL", ""),
+  mlcommonsHeaderAuthorization: getEnvVar("MLCOMMONS_HEADER_AUTHORIZATION", ""),
+  mlcommonsHeaderAwsRegion: getEnvVar("MLCOMMONS_HEADER_AWS_REGION", ""),
+  mlcommonsHeaderAwsServiceName: getEnvVar("MLCOMMONS_HEADER_AWS_SERVICE_NAME", "es"),
+  mlcommonsHeaderAwsAccessKeyId: getEnvVar("MLCOMMONS_HEADER_AWS_ACCESS_KEY_ID", ""),
+  mlcommonsHeaderAwsSecretAccessKey: getEnvVar("MLCOMMONS_HEADER_AWS_SECRET_ACCESS_KEY", ""),
+  mlcommonsHeaderAwsSessionToken: getEnvVar("MLCOMMONS_HEADER_AWS_SESSION_TOKEN", ""),
+  // Claude Code Telemetry (optional - for OTEL traces from Claude Code)
+  claudeCodeTelemetryEnabled: getEnvVar("CLAUDE_CODE_TELEMETRY_ENABLED", "false") === "true",
+  otelExporterEndpoint: getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT", ""),
+  otelServiceName: getEnvVar("OTEL_SERVICE_NAME", "claude-code-agent"),
+  otelExporterProtocol: getEnvVar("OTEL_EXPORTER_OTLP_PROTOCOL", ""),
+  otelExporterHeaders: getEnvVar("OTEL_EXPORTER_OTLP_HEADERS", "")
+};
+function buildMLCommonsHeaders() {
+  debug("Config", "Building ML-Commons headers");
+  const headers = {};
+  if (ENV_CONFIG.mlcommonsHeaderOpenSearchUrl) {
+    headers["opensearch-url"] = ENV_CONFIG.mlcommonsHeaderOpenSearchUrl;
+  }
+  if (ENV_CONFIG.mlcommonsHeaderAwsRegion) {
+    headers["aws-region"] = ENV_CONFIG.mlcommonsHeaderAwsRegion;
+  }
+  if (ENV_CONFIG.mlcommonsHeaderAuthorization) {
+    headers["Authorization"] = ENV_CONFIG.mlcommonsHeaderAuthorization;
+  } else {
+    if (ENV_CONFIG.mlcommonsHeaderAwsServiceName) {
+      headers["aws-service-name"] = ENV_CONFIG.mlcommonsHeaderAwsServiceName;
+    }
+    if (ENV_CONFIG.mlcommonsHeaderAwsAccessKeyId) {
+      headers["aws-access-key-id"] = ENV_CONFIG.mlcommonsHeaderAwsAccessKeyId;
+    }
+    if (ENV_CONFIG.mlcommonsHeaderAwsSecretAccessKey) {
+      headers["aws-secret-access-key"] = ENV_CONFIG.mlcommonsHeaderAwsSecretAccessKey;
+    }
+    if (ENV_CONFIG.mlcommonsHeaderAwsSessionToken) {
+      headers["aws-session-token"] = ENV_CONFIG.mlcommonsHeaderAwsSessionToken;
+    }
+  }
+  debug("Config", "ML-Commons headers built, keys:", Object.keys(headers));
+  return headers;
+}
+
+// lib/constants.ts
+function getClaudeCodeConnectorEnv() {
+  const env = {
+    AWS_PROFILE: process.env.AWS_PROFILE || "Bedrock",
+    CLAUDE_CODE_USE_BEDROCK: "1",
+    AWS_REGION: process.env.AWS_REGION || "us-west-2",
+    DISABLE_PROMPT_CACHING: "1",
+    DISABLE_ERROR_REPORTING: "1"
+  };
+  if (ENV_CONFIG.claudeCodeTelemetryEnabled && ENV_CONFIG.otelExporterEndpoint) {
+    env.CLAUDE_CODE_ENABLE_TELEMETRY = "1";
+    env.OTEL_EXPORTER_OTLP_ENDPOINT = ENV_CONFIG.otelExporterEndpoint;
+    env.OTEL_SERVICE_NAME = ENV_CONFIG.otelServiceName;
+    if (ENV_CONFIG.otelExporterProtocol) {
+      env.OTEL_EXPORTER_OTLP_PROTOCOL = ENV_CONFIG.otelExporterProtocol;
+    }
+    if (ENV_CONFIG.otelExporterHeaders) {
+      env.OTEL_EXPORTER_OTLP_HEADERS = ENV_CONFIG.otelExporterHeaders;
+    }
+  } else {
+    env.DISABLE_TELEMETRY = "1";
+  }
+  return env;
+}
+var DEFAULT_CONFIG = {
+  agents: [
+    {
+      key: "demo",
+      name: "Demo Agent",
+      endpoint: "mock://demo",
+      description: "Mock agent for testing (simulated responses)",
+      connectorType: "mock",
+      models: ["demo-model"],
+      headers: {},
+      useTraces: false
+    },
+    {
+      key: "langgraph",
+      name: "Langgraph",
+      endpoint: ENV_CONFIG.langgraphEndpoint,
+      description: "Langgraph AG-UI agent server",
+      connectorType: "agui-streaming",
+      models: [
+        "claude-sonnet-4.5",
+        "claude-sonnet-4",
+        "claude-haiku-3.5"
+      ],
+      headers: {},
+      useTraces: true
+    },
+    {
+      key: "mlcommons-local",
+      name: "ML-Commons (Localhost)",
+      endpoint: ENV_CONFIG.mlcommonsEndpoint,
+      description: "Local OpenSearch ML-Commons conversational agent",
+      connectorType: "agui-streaming",
+      models: [
+        "claude-sonnet-4.5",
+        "claude-sonnet-4",
+        "claude-haiku-3.5"
+      ],
+      headers: buildMLCommonsHeaders(),
+      useTraces: true
+    },
+    {
+      key: "holmesgpt",
+      name: "HolmesGPT",
+      endpoint: ENV_CONFIG.holmesGptEndpoint,
+      description: "HolmesGPT AI-powered RCA agent (AG-UI)",
+      connectorType: "agui-streaming",
+      models: [
+        "claude-sonnet-4.5",
+        "claude-sonnet-4",
+        "claude-haiku-3.5"
+      ],
+      headers: {},
+      useTraces: true
+    },
+    {
+      key: "claude-code",
+      name: "Claude Code",
+      endpoint: "claude",
+      // Command name, not URL
+      description: "Claude Code CLI agent (requires claude command installed)",
+      connectorType: "claude-code",
+      models: ["claude-sonnet-4"],
+      headers: {},
+      get useTraces() {
+        return !!(ENV_CONFIG.claudeCodeTelemetryEnabled && ENV_CONFIG.otelExporterEndpoint);
+      },
+      // connectorConfig env vars are evaluated at runtime by getClaudeCodeConnectorEnv()
+      get connectorConfig() {
+        return {
+          env: getClaudeCodeConnectorEnv()
+        };
+      }
+    }
+  ],
+  models: {
+    "demo-model": {
+      model_id: "mock://demo-model",
+      display_name: "Demo Model",
+      provider: "demo",
+      context_window: 2e5,
+      max_output_tokens: 4096
+    },
+    "claude-sonnet-4.5": {
+      model_id: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+      display_name: "Claude Sonnet 4.5",
+      provider: "bedrock",
+      context_window: 2e5,
+      max_output_tokens: 4096
+    },
+    "claude-sonnet-4": {
+      model_id: "us.anthropic.claude-sonnet-4-20250514-v1:0",
+      display_name: "Claude Sonnet 4",
+      provider: "bedrock",
+      context_window: 2e5,
+      max_output_tokens: 4096
+    },
+    "claude-haiku-3.5": {
+      model_id: "us.anthropic.claude-3-5-haiku-20241022-v1:0",
+      display_name: "Claude Haiku 3.5",
+      provider: "bedrock",
+      context_window: 2e5,
+      max_output_tokens: 4096
+    }
+  },
+  defaults: {
+    retry_attempts: 2,
+    retry_delay_ms: 1e3
+  }
+};
+
+// lib/config/loader.ts
+var DEFAULT_SERVER_CONFIG = {
+  port: 4001,
+  reuseExistingServer: !process.env.CI,
+  startTimeout: 3e4
+};
+var CONFIG_FILE_NAMES = [
+  "agent-health.config.ts",
+  "agent-health.config.js",
+  "agent-health.config.mjs"
+];
+function findConfigFile(cwd = process.cwd()) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = resolve(cwd, fileName);
+    if (existsSync2(filePath)) {
+      const format = fileName.endsWith(".ts") ? "typescript" : "javascript";
+      return { path: filePath, format, exists: true };
+    }
+  }
+  return null;
+}
+function toAgentConfig(userAgent) {
+  return {
+    key: userAgent.key,
+    name: userAgent.name,
+    endpoint: userAgent.endpoint,
+    description: userAgent.description,
+    enabled: userAgent.enabled ?? true,
+    models: userAgent.models,
+    headers: userAgent.headers ?? {},
+    useTraces: userAgent.useTraces ?? false,
+    connectorType: userAgent.connectorType,
+    connectorConfig: userAgent.connectorConfig,
+    hooks: userAgent.hooks
+  };
+}
+function toModelConfig(userModel) {
+  return [
+    userModel.key,
+    {
+      model_id: userModel.model_id,
+      display_name: userModel.display_name,
+      provider: userModel.provider ?? "bedrock",
+      context_window: userModel.context_window ?? 2e5,
+      max_output_tokens: userModel.max_output_tokens ?? 4096
+    }
+  ];
+}
+function mergeConfigs(userConfig, defaultConfig) {
+  const shouldExtend = userConfig.extends !== false;
+  let agents;
+  if (shouldExtend) {
+    const agentMap = /* @__PURE__ */ new Map();
+    for (const agent of defaultConfig.agents) {
+      agentMap.set(agent.key, agent);
+    }
+    for (const userAgent of userConfig.agents ?? []) {
+      agentMap.set(userAgent.key, toAgentConfig(userAgent));
+    }
+    agents = Array.from(agentMap.values());
+  } else {
+    agents = (userConfig.agents ?? []).map(toAgentConfig);
+  }
+  let models;
+  if (shouldExtend) {
+    models = { ...defaultConfig.models };
+    for (const userModel of userConfig.models ?? []) {
+      const [key, config] = toModelConfig(userModel);
+      models[key] = config;
+    }
+  } else {
+    models = {};
+    for (const userModel of userConfig.models ?? []) {
+      const [key, config] = toModelConfig(userModel);
+      models[key] = config;
+    }
+  }
+  const connectors = userConfig.connectors ?? [];
+  const testCases = userConfig.testCases ? Array.isArray(userConfig.testCases) ? userConfig.testCases : [userConfig.testCases] : [];
+  const reporters = userConfig.reporters ?? [["console"]];
+  const judge = userConfig.judge ?? {
+    provider: "bedrock",
+    model: "claude-sonnet-4"
+  };
+  const server = {
+    ...DEFAULT_SERVER_CONFIG,
+    ...userConfig.server
+  };
+  return {
+    server,
+    agents,
+    models,
+    connectors,
+    testCases,
+    reporters,
+    judge
+  };
+}
+async function loadUserConfig(configPath) {
+  try {
+    const fileUrl = pathToFileURL(configPath).href;
+    const module = await import(fileUrl);
+    return module.default ?? module;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config file ${configPath}: ${message}`);
+  }
+}
+var cachedConfig = null;
+var cachedConfigPath = null;
+async function loadConfig(cwd = process.cwd(), force = false) {
+  const configFile = findConfigFile(cwd);
+  if (!force && cachedConfig && cachedConfigPath === configFile?.path) {
+    return cachedConfig;
+  }
+  let userConfig = {};
+  if (configFile) {
+    console.log(`[Config] Loading ${configFile.path}`);
+    userConfig = await loadUserConfig(configFile.path);
+  } else {
+    console.log("[Config] No config file found, using defaults + environment variables");
+  }
+  const resolved = mergeConfigs(userConfig, DEFAULT_CONFIG);
+  cachedConfig = resolved;
+  cachedConfigPath = configFile?.path ?? null;
+  console.log(`[Config] Loaded ${resolved.agents.length} agents, ${Object.keys(resolved.models).length} models`);
+  return resolved;
+}
+function getConfigFileInfo(cwd = process.cwd()) {
+  return findConfigFile(cwd);
+}
+
+// services/connectors/registry.ts
+var DEFAULT_CONNECTOR_TYPE = "agui-streaming";
+var ConnectorRegistryImpl = class {
+  constructor() {
+    this.connectors = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a connector implementation
+   * @throws Error if connector with same type is already registered
+   */
+  register(connector) {
+    if (this.connectors.has(connector.type)) {
+      console.warn(
+        `[ConnectorRegistry] Overwriting existing connector for type: ${connector.type}`
+      );
+    }
+    this.connectors.set(connector.type, connector);
+  }
+  /**
+   * Get a connector by protocol type
+   */
+  get(type) {
+    return this.connectors.get(type);
+  }
+  /**
+   * Get all registered connectors
+   */
+  getAll() {
+    return Array.from(this.connectors.values());
+  }
+  /**
+   * Check if a connector is registered
+   */
+  has(type) {
+    return this.connectors.has(type);
+  }
+  /**
+   * Get connector for an agent config
+   * Handles backwards compatibility with legacy configs
+   *
+   * Resolution order:
+   * 1. If endpoint starts with 'mock://', use mock connector
+   * 2. If connectorType is specified, use that
+   * 3. Default to 'agui-streaming'
+   */
+  getForAgent(agent) {
+    if (agent.endpoint.startsWith("mock://")) {
+      const mockConnector2 = this.get("mock");
+      if (mockConnector2) {
+        return mockConnector2;
+      }
+      console.warn("[ConnectorRegistry] Mock connector not registered, falling back to default");
+    }
+    const connectorType = agent.connectorType ?? DEFAULT_CONNECTOR_TYPE;
+    const connector = this.get(connectorType);
+    if (!connector) {
+      console.error(
+        `[ConnectorRegistry] Connector not found for type: ${connectorType}, falling back to ${DEFAULT_CONNECTOR_TYPE}`
+      );
+      const defaultConnector = this.get(DEFAULT_CONNECTOR_TYPE);
+      if (!defaultConnector) {
+        throw new Error(
+          `No connector registered for type '${connectorType}' and no default connector available`
+        );
+      }
+      return defaultConnector;
+    }
+    return connector;
+  }
+  /**
+   * Clear all registered connectors (useful for testing)
+   */
+  clear() {
+    this.connectors.clear();
+  }
+  /**
+   * Get list of registered connector types
+   */
+  getRegisteredTypes() {
+    return Array.from(this.connectors.keys());
+  }
+};
+var connectorRegistry = new ConnectorRegistryImpl();
+
+// services/connectors/base/BaseConnector.ts
+var BaseConnector = class {
+  /**
+   * Build HTTP headers from auth configuration
+   * @param auth Authentication configuration
+   * @returns Headers object ready for fetch/axios
+   */
+  buildAuthHeaders(auth) {
+    const headers = {};
+    switch (auth.type) {
+      case "basic":
+        if (auth.username && auth.password) {
+          const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+          headers["Authorization"] = `Basic ${credentials}`;
+        }
+        break;
+      case "bearer":
+        if (auth.token) {
+          headers["Authorization"] = `Bearer ${auth.token}`;
+        }
+        break;
+      case "api-key":
+        if (auth.token) {
+          headers["X-API-Key"] = auth.token;
+          headers["x-api-key"] = auth.token;
+        }
+        break;
+      case "aws-sigv4":
+        console.warn("[BaseConnector] AWS SigV4 auth requires runtime signing");
+        break;
+      case "none":
+      default:
+        break;
+    }
+    if (auth.headers) {
+      Object.assign(headers, auth.headers);
+    }
+    return headers;
+  }
+  /**
+   * Build environment variables from auth configuration
+   * Used by subprocess connectors
+   */
+  buildAuthEnv(auth) {
+    const env = {};
+    if (auth.type === "aws-sigv4") {
+      if (auth.awsRegion) env["AWS_REGION"] = auth.awsRegion;
+      if (auth.awsAccessKeyId) env["AWS_ACCESS_KEY_ID"] = auth.awsAccessKeyId;
+      if (auth.awsSecretAccessKey) env["AWS_SECRET_ACCESS_KEY"] = auth.awsSecretAccessKey;
+      if (auth.awsSessionToken) env["AWS_SESSION_TOKEN"] = auth.awsSessionToken;
+    }
+    return env;
+  }
+  /**
+   * Generate a unique ID for trajectory steps
+   */
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Create a trajectory step with common fields
+   */
+  createStep(type, content, extra) {
+    return {
+      id: this.generateId(),
+      timestamp: Date.now(),
+      type,
+      content,
+      ...extra
+    };
+  }
+  /**
+   * Default health check implementation
+   * Subclasses can override for protocol-specific checks
+   */
+  async healthCheck(endpoint, auth) {
+    try {
+      const headers = this.buildAuthHeaders(auth);
+      const response = await fetch(endpoint, {
+        method: "HEAD",
+        headers
+      });
+      return response.ok;
+    } catch (error) {
+      console.error(`[${this.type}] Health check failed:`, error);
+      return false;
+    }
+  }
+  /**
+   * Log debug message with connector type prefix
+   */
+  debug(message, ...args) {
+    debug(this.type, message, ...args);
+  }
+  /**
+   * Log error message with connector type prefix
+   */
+  error(message, ...args) {
+    console.error(`[${this.type}] ${message}`, ...args);
+  }
+};
+
+// types/agui.ts
+import { EventType } from "@ag-ui/core";
+var AGUIEventType = EventType;
+
+// services/agent/sseStream.ts
+var SSEClient = class {
+  constructor() {
+    this.abortController = null;
+  }
+  /**
+   * Start consuming SSE stream from the agent endpoint
+   */
+  async consume(options) {
+    const {
+      url,
+      method = "POST",
+      headers = {},
+      body,
+      onEvent,
+      onError,
+      onComplete,
+      completeOnRunEnd = false,
+      idleTimeoutMs = 12e4
+      // 2 minute idle timeout by default (LLM agents can be slow)
+    } = options;
+    this.abortController = new AbortController();
+    debug("SSE", "Connecting to", url);
+    debug("SSE", "Method:", method);
+    debug("SSE", "Payload:", JSON.stringify(body, null, 2).substring(0, 500));
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...headers
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      debug("SSE", "Connected, streaming events...");
+      debug("SSE", "Response status:", response.status);
+      debug("SSE", "Content-Type:", response.headers.get("content-type"));
+      const completionReason = await this.processStream(response.body, onEvent, completeOnRunEnd, idleTimeoutMs);
+      debug("SSE", `Stream completed: ${completionReason}`);
+      onComplete?.();
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          debug("SSE", "Stream aborted (expected after run completion)");
+          onComplete?.();
+        } else {
+          console.error("[SSE] Stream error:", error.message);
+          onError?.(error);
+        }
+      } else {
+        onError?.(new Error("Unknown error occurred"));
+      }
+    }
+  }
+  /**
+   * Process the ReadableStream and parse SSE events
+   * @returns Reason for stream completion
+   */
+  async processStream(stream, onEvent, completeOnRunEnd = false, idleTimeoutMs = 12e4) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let lastEventTime = Date.now();
+    let eventCount = 0;
+    let idleCheckInterval = null;
+    const idleTimeoutPromise = new Promise((resolve5) => {
+      idleCheckInterval = setInterval(() => {
+        const idleTime = Date.now() - lastEventTime;
+        if (eventCount > 0 && idleTime > idleTimeoutMs) {
+          debug("SSE", `Idle timeout: no events for ${idleTime}ms (threshold: ${idleTimeoutMs}ms)`);
+          this.abort();
+          resolve5("idle_timeout");
+        }
+      }, 1e3);
+    });
+    try {
+      const streamPromise = (async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            return "connection_closed";
+          }
+          lastEventTime = Date.now();
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data.trim()) {
+                debug("SSE", "Raw event:", data.substring(0, 200) + (data.length > 200 ? "..." : ""));
+                try {
+                  const event = JSON.parse(data);
+                  debug("SSE", "Parsed:", event.type);
+                  eventCount++;
+                  onEvent(event);
+                  if (completeOnRunEnd && (event.type === AGUIEventType.RUN_FINISHED || event.type === AGUIEventType.RUN_ERROR)) {
+                    debug("SSE", `Received ${event.type}, completing stream`);
+                    this.abort();
+                    return `event:${event.type}`;
+                  }
+                } catch (parseError) {
+                  console.error("[SSE] Parse error:", parseError);
+                  debug("SSE", "Failed data:", data);
+                }
+              }
+            }
+          }
+        }
+      })();
+      const reason = await Promise.race([streamPromise, idleTimeoutPromise]);
+      return reason;
+    } finally {
+      if (idleCheckInterval) {
+        clearInterval(idleCheckInterval);
+      }
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Abort the current stream connection
+   */
+  abort() {
+    this.abortController?.abort();
+  }
+};
+async function consumeSSEStream(url, payload, onEvent, headers, options) {
+  const client = new SSEClient();
+  return new Promise((resolve5, reject) => {
+    client.consume({
+      url,
+      method: "POST",
+      headers,
+      body: payload,
+      onEvent,
+      onError: (error) => reject(error),
+      onComplete: () => resolve5(),
+      // Enable auto-completion on RUN_FINISHED/RUN_ERROR events
+      // This prevents hanging when the agent doesn't close the connection
+      completeOnRunEnd: true,
+      idleTimeoutMs: options?.idleTimeoutMs
+    });
+  });
+}
+
+// services/agent/payloadBuilder.ts
+var DEFAULT_PPL_TOOL = {
+  name: "execute_ppl_query",
+  description: "Update the query bar with a PPL query and optionally execute it",
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "The PPL query to set in the query bar"
+      },
+      autoExecute: {
+        type: "boolean",
+        description: "Whether to automatically execute the query (default: true)"
+      },
+      description: {
+        type: "string",
+        description: "Optional description of what the query does"
+      }
+    },
+    required: ["query"]
+  }
+};
+function generateId(prefix) {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}-${timestamp}-${random}`;
+}
+function buildAgentPayload(testCase, modelId, threadId, runId) {
+  const tools = testCase.tools || [DEFAULT_PPL_TOOL];
+  return {
+    threadId: threadId || generateId("thread"),
+    runId: runId || generateId("run"),
+    messages: [
+      {
+        id: generateId("msg"),
+        role: "user",
+        content: testCase.initialPrompt
+      }
+    ],
+    tools,
+    context: testCase.context || [],
+    state: {},
+    forwardedProps: {}
+  };
+}
+
+// services/agent/aguiConverter.ts
+import { v4 as uuidv4 } from "uuid";
+var AGUIToTrajectoryConverter = class {
+  constructor() {
+    this.currentTextMessage = null;
+    this.activeTools = /* @__PURE__ */ new Map();
+    this.hasEmittedAction = false;
+    this.runFinished = false;
+    this.pendingTextIsResponse = false;
+    this.runId = null;
+    this.threadId = null;
+    // Thinking state tracking
+    this.isThinking = false;
+    this.currentThinkingMessage = null;
+  }
+  /**
+   * Process a single AG UI event and convert it to TrajectoryStep(s)
+   * Returns an array of steps (usually 0 or 1, sometimes more)
+   */
+  processEvent(event) {
+    debug("Converter", `Event: ${event.type}`, JSON.stringify(event).substring(0, 300));
+    let steps = [];
+    switch (event.type) {
+      case AGUIEventType.RUN_STARTED:
+        steps = this.handleRunStarted(event);
+        break;
+      case AGUIEventType.RUN_FINISHED:
+        steps = this.handleRunFinished(event);
+        break;
+      case AGUIEventType.RUN_ERROR:
+        steps = this.handleRunError(event);
+        break;
+      case AGUIEventType.TEXT_MESSAGE_START:
+        steps = this.handleTextMessageStart(event);
+        break;
+      case AGUIEventType.TEXT_MESSAGE_CONTENT:
+        steps = this.handleTextMessageContent(event);
+        break;
+      case AGUIEventType.TEXT_MESSAGE_END:
+        steps = this.handleTextMessageEnd(event);
+        break;
+      case AGUIEventType.ACTIVITY_SNAPSHOT:
+        steps = this.handleActivitySnapshot(event);
+        break;
+      case AGUIEventType.ACTIVITY_DELTA:
+        steps = this.handleActivityDelta(event);
+        break;
+      case AGUIEventType.TOOL_CALL_START:
+        steps = this.handleToolCallStart(event);
+        break;
+      case AGUIEventType.TOOL_CALL_ARGS:
+        steps = this.handleToolCallArgs(event);
+        break;
+      case AGUIEventType.TOOL_CALL_END:
+        steps = this.handleToolCallEnd(event);
+        break;
+      case AGUIEventType.TOOL_CALL_RESULT:
+        steps = this.handleToolCallResult(event);
+        break;
+      // Thinking events - extended reasoning from the model
+      case AGUIEventType.THINKING_START:
+        steps = this.handleThinkingStart(event);
+        break;
+      case AGUIEventType.THINKING_END:
+        steps = this.handleThinkingEnd(event);
+        break;
+      case AGUIEventType.THINKING_TEXT_MESSAGE_START:
+        steps = this.handleThinkingTextMessageStart(event);
+        break;
+      case AGUIEventType.THINKING_TEXT_MESSAGE_CONTENT:
+        steps = this.handleThinkingTextMessageContent(event);
+        break;
+      case AGUIEventType.THINKING_TEXT_MESSAGE_END:
+        steps = this.handleThinkingTextMessageEnd(event);
+        break;
+      default:
+        debug("Converter", `Skipped unhandled event: ${event.type}`);
+        break;
+    }
+    if (steps.length > 0) {
+      debug("Converter", `Generated ${steps.length} step(s):`, steps.map((s) => `${s.type}${s.toolName ? `:${s.toolName}` : ""}`).join(", "));
+    }
+    return steps;
+  }
+  handleRunStarted(event) {
+    this.runId = event.runId;
+    this.threadId = event.threadId;
+    debug("Converter", `Run started - runId: ${this.runId}, threadId: ${this.threadId}`);
+    this.currentTextMessage = null;
+    this.activeTools.clear();
+    this.hasEmittedAction = false;
+    this.runFinished = false;
+    this.pendingTextIsResponse = false;
+    this.isThinking = false;
+    this.currentThinkingMessage = null;
+    return [];
+  }
+  getRunId() {
+    return this.runId;
+  }
+  getThreadId() {
+    return this.threadId;
+  }
+  handleRunFinished(event) {
+    this.runFinished = true;
+    if (this.currentTextMessage) {
+      this.pendingTextIsResponse = true;
+    }
+    return [];
+  }
+  handleRunError(event) {
+    console.error("[Converter] Run error:", event.message);
+    return [{
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: "tool_result",
+      content: `Error: ${event.message}`,
+      status: "FAILURE" /* FAILURE */
+    }];
+  }
+  handleTextMessageStart(event) {
+    debug("Converter", `Text message start: ${event.messageId}`);
+    this.currentTextMessage = {
+      messageId: event.messageId,
+      startTime: event.timestamp,
+      content: ""
+    };
+    return [];
+  }
+  handleTextMessageContent(event) {
+    if (this.currentTextMessage && this.currentTextMessage.messageId === event.messageId) {
+      this.currentTextMessage.content += event.delta;
+    }
+    return [];
+  }
+  handleTextMessageEnd(event) {
+    if (!this.currentTextMessage || this.currentTextMessage.messageId !== event.messageId) {
+      debug("Converter", `Text end for unknown message: ${event.messageId}`);
+      return [];
+    }
+    const latencyMs = event.timestamp - this.currentTextMessage.startTime;
+    const content = this.currentTextMessage.content.trim();
+    let stepType;
+    if (this.pendingTextIsResponse || this.runFinished) {
+      stepType = "response";
+    } else {
+      stepType = "assistant";
+    }
+    debug("Converter", `Classification: ${stepType} (runFinished=${this.runFinished}, pendingResponse=${this.pendingTextIsResponse}, hasAction=${this.hasEmittedAction})`);
+    if (stepType === "assistant" && content.length === 0) {
+      debug("Converter", "Skipping empty assistant message");
+      this.currentTextMessage = null;
+      return [];
+    }
+    const step = {
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: stepType,
+      content,
+      latencyMs
+    };
+    this.currentTextMessage = null;
+    return [step];
+  }
+  handleActivitySnapshot(event) {
+    const toolName = this.extractToolName(event.content.title);
+    const toolArgs = this.parseToolArgs(event.content.description);
+    const actionStepId = uuidv4();
+    this.activeTools.set(event.messageId, {
+      messageId: event.messageId,
+      toolName,
+      toolArgs,
+      argsAccumulator: "",
+      startTime: event.timestamp,
+      actionStepId
+    });
+    this.hasEmittedAction = true;
+    debug("Converter", `Tool action: ${toolName}`, toolArgs);
+    return [{
+      id: actionStepId,
+      timestamp: event.timestamp,
+      type: "action",
+      content: `Calling ${toolName}...`,
+      toolName,
+      toolArgs
+    }];
+  }
+  handleActivityDelta(event) {
+    const toolState = this.activeTools.get(event.messageId);
+    if (!toolState) return [];
+    const isCompletion = event.patch.some(
+      (op) => op.path === "/icon" && (op.value === "CheckCircle" || op.value === "Check")
+    );
+    if (!isCompletion) return [];
+    const descriptionPatch = event.patch.find((op) => op.path === "/description");
+    const resultContent = descriptionPatch?.value || "Tool execution completed";
+    const latencyMs = event.timestamp - toolState.startTime;
+    this.activeTools.delete(event.messageId);
+    return [{
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: "tool_result",
+      content: resultContent,
+      status: "SUCCESS" /* SUCCESS */,
+      latencyMs
+    }];
+  }
+  handleToolCallStart(event) {
+    const actionStepId = uuidv4();
+    this.activeTools.set(event.toolCallId, {
+      messageId: event.toolCallId,
+      toolName: event.toolCallName,
+      toolArgs: {},
+      argsAccumulator: "",
+      // Will accumulate delta strings
+      startTime: event.timestamp,
+      actionStepId
+    });
+    this.hasEmittedAction = true;
+    debug("Converter", `Tool call started: ${event.toolCallName} (${event.toolCallId})`);
+    return [];
+  }
+  handleToolCallArgs(event) {
+    const toolState = this.activeTools.get(event.toolCallId);
+    if (toolState) {
+      toolState.argsAccumulator += event.delta;
+      debug("Converter", `Tool args delta accumulated (${toolState.argsAccumulator.length} chars total)`);
+    }
+    return [];
+  }
+  /**
+   * Handle TOOL_CALL_END - emits the action step with complete args
+   * This is called when the agent is done sending tool call arguments
+   * and expects the client to execute the tool
+   */
+  handleToolCallEnd(event) {
+    const toolState = this.activeTools.get(event.toolCallId);
+    if (!toolState) {
+      debug("Converter", `Tool call end for unknown tool: ${event.toolCallId}`);
+      return [];
+    }
+    let parsedArgs = {};
+    if (toolState.argsAccumulator) {
+      try {
+        parsedArgs = JSON.parse(toolState.argsAccumulator);
+        debug("Converter", `Tool args parsed: ${JSON.stringify(parsedArgs).substring(0, 200)}`);
+      } catch {
+        parsedArgs = { _raw: toolState.argsAccumulator };
+      }
+    }
+    toolState.toolArgs = parsedArgs;
+    const latencyMs = event.timestamp - toolState.startTime;
+    const actionStep = {
+      id: toolState.actionStepId,
+      timestamp: toolState.startTime,
+      type: "action",
+      content: `Calling ${toolState.toolName}...`,
+      toolName: toolState.toolName,
+      toolArgs: parsedArgs,
+      latencyMs
+    };
+    debug("Converter", `Tool call end: ${toolState.toolName} - action step emitted with args`);
+    toolState.actionStepId = "";
+    return [actionStep];
+  }
+  handleToolCallResult(event) {
+    const toolState = this.activeTools.get(event.toolCallId);
+    if (!toolState) return [];
+    const latencyMs = event.timestamp - toolState.startTime;
+    const steps = [];
+    const actionAlreadyEmitted = !toolState.actionStepId;
+    if (!actionAlreadyEmitted) {
+      let parsedArgs = {};
+      if (toolState.argsAccumulator) {
+        try {
+          parsedArgs = JSON.parse(toolState.argsAccumulator);
+          debug("Converter", `Tool args parsed: ${JSON.stringify(parsedArgs).substring(0, 200)}`);
+        } catch {
+          parsedArgs = { _raw: toolState.argsAccumulator };
+        }
+      }
+      toolState.toolArgs = parsedArgs;
+      steps.push({
+        id: toolState.actionStepId,
+        timestamp: toolState.startTime,
+        type: "action",
+        content: `Calling ${toolState.toolName}...`,
+        toolName: toolState.toolName,
+        toolArgs: parsedArgs
+      });
+    }
+    let resultContent;
+    try {
+      const parsed = JSON.parse(event.content);
+      resultContent = typeof parsed === "string" ? parsed : JSON.stringify(parsed, null, 2);
+    } catch (e) {
+      resultContent = event.content;
+    }
+    steps.push({
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: "tool_result",
+      content: resultContent,
+      status: "SUCCESS" /* SUCCESS */,
+      latencyMs
+    });
+    this.activeTools.delete(event.toolCallId);
+    debug("Converter", `Tool call result: ${toolState.toolName} -> ${steps.length} steps emitted (action already emitted: ${actionAlreadyEmitted})`);
+    return steps;
+  }
+  // ============ THINKING Event Handlers ============
+  handleThinkingStart(event) {
+    this.isThinking = true;
+    debug("Converter", "Thinking started");
+    return [];
+  }
+  handleThinkingEnd(event) {
+    this.isThinking = false;
+    debug("Converter", "Thinking ended");
+    return [];
+  }
+  handleThinkingTextMessageStart(event) {
+    this.currentThinkingMessage = {
+      startTime: event.timestamp || Date.now(),
+      content: ""
+    };
+    debug("Converter", "Thinking text message started");
+    return [];
+  }
+  handleThinkingTextMessageContent(event) {
+    if (this.currentThinkingMessage) {
+      this.currentThinkingMessage.content += event.delta;
+    }
+    return [];
+  }
+  handleThinkingTextMessageEnd(event) {
+    if (!this.currentThinkingMessage) {
+      debug("Converter", "Thinking text end with no active thinking message");
+      return [];
+    }
+    const content = this.currentThinkingMessage.content.trim();
+    if (content.length === 0) {
+      debug("Converter", "Skipping empty thinking message");
+      this.currentThinkingMessage = null;
+      return [];
+    }
+    const latencyMs = (event.timestamp || Date.now()) - this.currentThinkingMessage.startTime;
+    const step = {
+      id: uuidv4(),
+      timestamp: this.currentThinkingMessage.startTime,
+      type: "thinking",
+      content,
+      latencyMs
+    };
+    debug("Converter", `Thinking message completed: ${content.length} chars`);
+    this.currentThinkingMessage = null;
+    return [step];
+  }
+  extractToolName(title) {
+    const runningMatch = title.match(/^Running\s+(.+)$/);
+    if (runningMatch) return runningMatch[1];
+    const completedMatch = title.match(/^(.+)\s+completed$/i);
+    if (completedMatch) return completedMatch[1];
+    return title;
+  }
+  parseToolArgs(description) {
+    try {
+      const args = {};
+      const pairs = description.match(/(\w+):\s*("(?:[^"]|\\")*"|\w+)/g);
+      if (pairs) {
+        pairs.forEach((pair) => {
+          const [key, rawValue] = pair.split(":").map((s) => s.trim());
+          let value = rawValue;
+          if (rawValue.startsWith('"') && rawValue.endsWith('"')) {
+            value = rawValue.slice(1, -1);
+          } else if (rawValue === "true") {
+            value = true;
+          } else if (rawValue === "false") {
+            value = false;
+          } else if (!isNaN(Number(rawValue))) {
+            value = Number(rawValue);
+          }
+          args[key] = value;
+        });
+        return args;
+      }
+      return { description };
+    } catch (e) {
+      return { description };
+    }
+  }
+};
+function computeTrajectoryFromRawEvents(rawEvents) {
+  const converter = new AGUIToTrajectoryConverter();
+  const trajectory = [];
+  for (const event of rawEvents) {
+    const steps = converter.processEvent(event);
+    trajectory.push(...steps);
+  }
+  trajectory.sort((a, b) => a.timestamp - b.timestamp);
+  return trajectory;
+}
+
+// services/connectors/agui/AGUIStreamingConnector.ts
+var AGUIStreamingConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "agui-streaming";
+    this.name = "AG-UI Streaming";
+    this.supportsStreaming = true;
+  }
+  /**
+   * Build AG-UI payload from standard request
+   */
+  buildPayload(request) {
+    return buildAgentPayload(
+      request.testCase,
+      request.modelId,
+      request.threadId,
+      request.runId
+    );
+  }
+  /**
+   * Execute the request using SSE streaming
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    const hasPrebuiltPayload = !!request.payload;
+    const payload = request.payload || this.buildPayload(request);
+    const headers = this.buildAuthHeaders(auth);
+    const trajectory = [];
+    const rawEvents = [];
+    const converter = new AGUIToTrajectoryConverter();
+    this.debug("Executing AG-UI streaming request");
+    await consumeSSEStream(
+      endpoint,
+      payload,
+      (event) => {
+        rawEvents.push(event);
+        onRawEvent?.(event);
+        const steps = converter.processEvent(event);
+        steps.forEach((step) => {
+          trajectory.push(step);
+          onProgress?.(step);
+        });
+      },
+      headers
+    );
+    const runId = converter.getRunId();
+    this.debug("Stream completed. RunId:", runId, "Steps:", trajectory.length);
+    return {
+      trajectory,
+      runId,
+      rawEvents,
+      metadata: {
+        threadId: converter.getThreadId()
+      }
+    };
+  }
+  /**
+   * Parse raw AG-UI events into trajectory steps
+   * Used for re-processing stored raw events
+   */
+  parseResponse(rawEvents) {
+    return computeTrajectoryFromRawEvents(rawEvents);
+  }
+  /**
+   * Health check for AG-UI endpoint
+   * Tries to connect without sending a full request
+   */
+  async healthCheck(endpoint, auth) {
+    try {
+      const headers = this.buildAuthHeaders(auth);
+      const response = await fetch(endpoint, {
+        method: "OPTIONS",
+        headers
+      });
+      return true;
+    } catch (error) {
+      this.error("Health check failed:", error);
+      return false;
+    }
+  }
+};
+var aguiStreamingConnector = new AGUIStreamingConnector();
+
+// services/connectors/mock/MockConnector.ts
+var MockConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "mock";
+    this.name = "Demo Agent (Mock)";
+    this.supportsStreaming = true;
+  }
+  /**
+   * Build payload - not used for mock but required by interface
+   */
+  buildPayload(request) {
+    return {
+      question: request.testCase.initialPrompt,
+      context: request.testCase.context
+    };
+  }
+  /**
+   * Execute mock request - generates realistic trajectory with delays
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    const trajectory = [];
+    const rawEvents = [];
+    const runId = `mock-run-${Date.now()}`;
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    this.debug("Generating mock trajectory for:", request.testCase.name);
+    const emitStep = (step) => {
+      trajectory.push(step);
+      onProgress?.(step);
+      rawEvents.push({ type: "MOCK_STEP", step });
+      onRawEvent?.({ type: "MOCK_STEP", step });
+    };
+    await sleep(100);
+    emitStep(this.createStep(
+      "assistant",
+      "I need to investigate this issue. Let me start by checking the cluster health and then drill down into specific metrics."
+    ));
+    await sleep(300);
+    emitStep(this.createStep(
+      "action",
+      "Calling opensearch_cluster_health...",
+      {
+        toolName: "opensearch_cluster_health",
+        toolArgs: { local: true }
+      }
+    ));
+    await sleep(500);
+    emitStep(this.createStep(
+      "tool_result",
+      JSON.stringify({ status: "yellow", number_of_nodes: 3, unassigned_shards: 0 }, null, 2),
+      {
+        status: "SUCCESS",
+        latencyMs: 500
+      }
+    ));
+    await sleep(300);
+    emitStep(this.createStep(
+      "assistant",
+      "The cluster is in yellow state. Let me check the node stats to identify which node might be causing issues."
+    ));
+    await sleep(300);
+    emitStep(this.createStep(
+      "action",
+      "Calling opensearch_nodes_stats...",
+      {
+        toolName: "opensearch_nodes_stats",
+        toolArgs: { metric: "jvm,os" }
+      }
+    ));
+    await sleep(600);
+    emitStep(this.createStep(
+      "tool_result",
+      "Node-1: CPU 12%, JVM Heap 45%\nNode-2: CPU 15%, JVM Heap 52%\nNode-3: CPU 98%, JVM Heap 89% (Data Node)",
+      {
+        status: "SUCCESS",
+        latencyMs: 600
+      }
+    ));
+    await sleep(400);
+    emitStep(this.createStep(
+      "response",
+      `## Root Cause Analysis Complete
+
+**Finding:** High CPU utilization detected on Node-3 (98% CPU, 89% JVM Heap)
+
+**Root Cause:** Node-3 is experiencing resource exhaustion, likely due to:
+1. Heavy indexing or search operations
+2. Garbage collection pressure from high heap usage
+3. Possible hot spot in shard distribution
+
+**Recommendations:**
+1. Check hot threads on Node-3 using \`_nodes/Node-3/hot_threads\`
+2. Review shard distribution and consider rebalancing
+3. Monitor GC logs for long pauses
+4. Consider scaling horizontally if load persists`
+    ));
+    this.debug("Mock trajectory completed. Steps:", trajectory.length);
+    return {
+      trajectory,
+      runId,
+      rawEvents,
+      metadata: {
+        mock: true,
+        testCaseId: request.testCase.id,
+        testCaseName: request.testCase.name
+      }
+    };
+  }
+  /**
+   * Parse raw events - for mock, just extract steps from our custom format
+   */
+  parseResponse(rawEvents) {
+    return rawEvents.filter((e) => e.type === "MOCK_STEP" && e.step).map((e) => e.step);
+  }
+  /**
+   * Health check - mock is always "healthy"
+   */
+  async healthCheck(endpoint, auth) {
+    return true;
+  }
+};
+var mockConnector = new MockConnector();
+
+// services/connectors/rest/RESTConnector.ts
+var RESTConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "rest";
+    this.name = "REST API";
+    this.supportsStreaming = false;
+  }
+  /**
+   * Build generic REST payload
+   * Can be customized via connectorConfig
+   */
+  buildPayload(request) {
+    return {
+      prompt: request.testCase.initialPrompt,
+      context: request.testCase.context,
+      model: request.modelId,
+      tools: request.testCase.tools
+    };
+  }
+  /**
+   * Execute REST request
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    const payload = request.payload || this.buildPayload(request);
+    const headers = this.buildAuthHeaders(auth);
+    this.debug("Executing REST request");
+    this.debug("Endpoint:", endpoint);
+    this.debug("Payload:", JSON.stringify(payload).substring(0, 500));
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`REST request failed: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    onRawEvent?.(data);
+    const trajectory = this.parseResponse(data);
+    trajectory.forEach((step) => onProgress?.(step));
+    return {
+      trajectory,
+      runId: data.runId || data.id || null,
+      rawEvents: [data],
+      metadata: {
+        status: response.status,
+        responseHeaders: Object.fromEntries(response.headers.entries())
+      }
+    };
+  }
+  /**
+   * Parse REST response into trajectory steps
+   * This is a generic implementation - subclass for specific APIs
+   */
+  parseResponse(data) {
+    const steps = [];
+    if (data.thinking) {
+      steps.push(this.createStep("thinking", data.thinking));
+    }
+    if (data.toolCalls && Array.isArray(data.toolCalls)) {
+      for (const call of data.toolCalls) {
+        steps.push(this.createStep("action", `Calling ${call.name}...`, {
+          toolName: call.name,
+          toolArgs: call.args || call.input
+        }));
+        if (call.result !== void 0) {
+          steps.push(this.createStep(
+            "tool_result",
+            typeof call.result === "string" ? call.result : JSON.stringify(call.result),
+            { status: "SUCCESS" }
+          ));
+        }
+      }
+    }
+    const responseContent = data.response || data.content || data.answer || data.text || data.message;
+    if (responseContent) {
+      steps.push(this.createStep(
+        "response",
+        typeof responseContent === "string" ? responseContent : JSON.stringify(responseContent)
+      ));
+    }
+    if (data.inference_results) {
+      const outputs = data.inference_results[0]?.output || [];
+      for (const output of outputs) {
+        if (output.name === "response") {
+          const content = output.dataAsMap?.response || output.result;
+          if (content) {
+            steps.push(this.createStep("response", content));
+          }
+        }
+      }
+    }
+    if (steps.length === 0 && data) {
+      steps.push(this.createStep("response", JSON.stringify(data, null, 2)));
+    }
+    return steps;
+  }
+};
+var restConnector = new RESTConnector();
+
+// services/connectors/index.ts
+connectorRegistry.register(aguiStreamingConnector);
+connectorRegistry.register(mockConnector);
+connectorRegistry.register(restConnector);
+console.log("[Connectors] Browser-safe connectors registered:", connectorRegistry.getRegisteredTypes().join(", "));
+
+// services/connectors/subprocess/SubprocessConnector.ts
+import { spawn } from "child_process";
+var DEFAULT_SUBPROCESS_CONFIG = {
+  command: "",
+  args: [],
+  env: {},
+  inputMode: "stdin",
+  outputParser: "text",
+  timeout: 3e5
+  // 5 minutes
+};
+var SubprocessConnector = class extends BaseConnector {
+  constructor(config) {
+    super();
+    this.type = "subprocess";
+    this.name = "Subprocess (CLI)";
+    this.supportsStreaming = true;
+    this.config = { ...DEFAULT_SUBPROCESS_CONFIG, ...config };
+  }
+  /**
+   * Build input for the subprocess
+   */
+  buildPayload(request) {
+    let prompt = request.testCase.initialPrompt;
+    if (request.testCase.context && request.testCase.context.length > 0) {
+      const contextStr = request.testCase.context.map((c) => `${c.description}: ${c.value}`).join("\n");
+      prompt = `Context:
+${contextStr}
+
+Question: ${prompt}`;
+    }
+    return prompt;
+  }
+  /**
+   * Execute subprocess and capture output
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    this.debug("========== execute() STARTED ==========");
+    const command = endpoint || this.config.command;
+    const args = this.config.args || [];
+    const input = request.payload || this.buildPayload(request);
+    this.debug("Command:", command);
+    this.debug("Args:", args);
+    this.debug("Input mode:", this.config.inputMode);
+    this.debug("Output parser:", this.config.outputParser);
+    this.debug("Timeout:", this.config.timeout);
+    this.debug("Input (first 500 chars):", input.substring(0, 500));
+    this.debug("Working dir:", this.config.workingDir || process.cwd());
+    const env = {
+      ...process.env,
+      ...this.buildAuthEnv(auth),
+      ...this.config.env
+    };
+    return new Promise((resolve5, reject) => {
+      const trajectory = [];
+      const rawOutput = [];
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const finalArgs = this.config.inputMode === "arg" ? [...args, input] : args;
+      this.debug("Spawning process...");
+      this.debug("Full command:", command, finalArgs.join(" "));
+      const proc = spawn(command, finalArgs, {
+        env,
+        cwd: this.config.workingDir,
+        shell: true
+      });
+      this.debug("Process spawned, PID:", proc.pid);
+      const timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        this.debug("TIMEOUT reached, killing process");
+        proc.kill("SIGTERM");
+        reject(new Error(`Subprocess timed out after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      if (this.config.inputMode === "stdin") {
+        this.debug("Writing input to stdin...");
+        proc.stdin.write(input);
+        proc.stdin.end();
+        this.debug("stdin closed");
+      }
+      proc.stdout.on("data", (data) => {
+        const chunk = data.toString();
+        this.debug("stdout received:", chunk.length, "bytes");
+        this.debug("stdout preview:", chunk.substring(0, 200));
+        stdout += chunk;
+        rawOutput.push({ type: "stdout", data: chunk, timestamp: Date.now() });
+        onRawEvent?.({ type: "stdout", data: chunk });
+        if (this.config.outputParser === "streaming") {
+          this.parseStreamingOutput(chunk, trajectory, onProgress);
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        const chunk = data.toString();
+        this.debug("stderr received:", chunk.length, "bytes");
+        this.debug("stderr:", chunk);
+        stderr += chunk;
+        onRawEvent?.({ type: "stderr", data: chunk });
+        this.debug("stderr:", chunk);
+      });
+      proc.on("close", (code, signal) => {
+        this.debug("Process closed with code:", code, "signal:", signal);
+        clearTimeout(timeoutId);
+        if (settled) return;
+        settled = true;
+        if (code !== 0) {
+          this.debug("Non-zero exit code:", code);
+          this.error(`Process exited with code ${code}`);
+          this.error("stderr:", stderr);
+        }
+        const finalTrajectory = this.config.outputParser === "streaming" ? trajectory : this.parseResponse({ stdout, stderr, exitCode: code });
+        if (this.config.outputParser !== "streaming") {
+          finalTrajectory.forEach((step) => onProgress?.(step));
+        }
+        this.debug("Resolving with trajectory of", finalTrajectory.length, "steps");
+        resolve5({
+          trajectory: finalTrajectory,
+          runId: `subprocess-${Date.now()}`,
+          rawEvents: rawOutput,
+          metadata: {
+            command,
+            args: finalArgs,
+            exitCode: code,
+            stderr: stderr || void 0
+          }
+        });
+      });
+      proc.on("error", (error) => {
+        this.debug("ERROR event:", error.message);
+        clearTimeout(timeoutId);
+        if (settled) return;
+        settled = true;
+        let errorMsg = `Failed to spawn subprocess: ${error.message}`;
+        if (error.message.includes("ENOENT")) {
+          errorMsg = `Command '${command}' not found. Is it installed and in PATH?`;
+          console.error(`[Subprocess] ENOENT error - command '${command}' not found in PATH`);
+        } else if (error.message.includes("EACCES")) {
+          errorMsg = `Permission denied executing '${command}'. Check file permissions.`;
+          console.error(`[Subprocess] EACCES error - permission denied for '${command}'`);
+        } else if (error.message.includes("EPERM")) {
+          errorMsg = `Operation not permitted for '${command}'. May require elevated privileges.`;
+          console.error(`[Subprocess] EPERM error - operation not permitted`);
+        }
+        reject(new Error(errorMsg));
+      });
+    });
+    this.debug("========== execute() COMPLETED ==========");
+  }
+  /**
+   * Parse streaming output and emit steps in real-time
+   */
+  parseStreamingOutput(chunk, trajectory, onProgress) {
+    const lines = chunk.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const step = this.createStep("assistant", line);
+      trajectory.push(step);
+      onProgress?.(step);
+    }
+  }
+  /**
+   * Parse final subprocess output
+   */
+  parseResponse(data) {
+    const steps = [];
+    if (this.config.outputParser === "json") {
+      try {
+        const parsed = JSON.parse(data.stdout);
+        return this.parseJsonOutput(parsed);
+      } catch {
+        this.debug("Failed to parse JSON output, falling back to text");
+      }
+    }
+    if (data.stdout.trim()) {
+      steps.push(this.createStep("response", data.stdout.trim()));
+    }
+    if (data.exitCode !== 0 && data.stderr.trim()) {
+      steps.push(this.createStep("tool_result", `Error: ${data.stderr.trim()}`, {
+        status: "FAILURE"
+      }));
+    }
+    return steps;
+  }
+  /**
+   * Parse JSON output into trajectory steps
+   */
+  parseJsonOutput(data) {
+    const steps = [];
+    if (data.thinking) {
+      steps.push(this.createStep("thinking", data.thinking));
+    }
+    if (data.steps && Array.isArray(data.steps)) {
+      for (const step of data.steps) {
+        steps.push(this.createStep(step.type || "assistant", step.content, {
+          toolName: step.toolName,
+          toolArgs: step.toolArgs
+        }));
+      }
+    }
+    if (data.response || data.answer || data.content) {
+      steps.push(this.createStep("response", data.response || data.answer || data.content));
+    }
+    return steps;
+  }
+  /**
+   * Health check - verify command exists
+   */
+  async healthCheck(endpoint, auth) {
+    const command = endpoint || this.config.command;
+    if (!command) return false;
+    return new Promise((resolve5) => {
+      const proc = spawn("which", [command], { shell: true });
+      proc.on("close", (code) => resolve5(code === 0));
+      proc.on("error", () => resolve5(false));
+    });
+  }
+};
+var subprocessConnector = new SubprocessConnector();
+
+// services/connectors/claude-code/ClaudeCodeConnector.ts
+var CLAUDE_CODE_DEFAULT_CONFIG = {
+  command: "claude",
+  args: ["--print", "--verbose", "--output-format", "stream-json"],
+  // Structured JSON output (--verbose required with stream-json)
+  env: {
+    // These can be overridden by agent config or environment
+    DISABLE_PROMPT_CACHING: "1",
+    DISABLE_ERROR_REPORTING: "1"
+    // Note: DISABLE_TELEMETRY removed - telemetry enabled by default
+    // Configure OTEL_EXPORTER_OTLP_ENDPOINT in .env to send traces
+  },
+  inputMode: "stdin",
+  outputParser: "streaming",
+  timeout: 6e5
+  // 10 minutes for Claude Code
+};
+var ClaudeCodeConnector = class extends SubprocessConnector {
+  constructor(config) {
+    super({ ...CLAUDE_CODE_DEFAULT_CONFIG, ...config });
+    this.type = "claude-code";
+    this.name = "Claude Code CLI";
+    this.outputBuffer = "";
+    this.thinkingBuffer = "";
+    this.isInThinking = false;
+  }
+  /**
+   * Build prompt for Claude Code
+   * Structures the input to get the best RCA results
+   */
+  buildPayload(request) {
+    const parts = [];
+    if (request.testCase.context && request.testCase.context.length > 0) {
+      parts.push("## Context");
+      for (const ctx of request.testCase.context) {
+        parts.push(`**${ctx.description}:**`);
+        parts.push(ctx.value);
+        parts.push("");
+      }
+    }
+    parts.push("## Task");
+    parts.push(request.testCase.initialPrompt);
+    return parts.join("\n");
+  }
+  /**
+   * Parse Claude Code streaming output (stream-json format)
+   * Each line is a JSON object with type and content
+   */
+  parseStreamingOutput(chunk, trajectory, onProgress) {
+    this.outputBuffer += chunk;
+    const lines = this.outputBuffer.split("\n");
+    this.outputBuffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const event = JSON.parse(trimmed);
+        const steps = this.parseJsonEvent(event);
+        for (const step of steps) {
+          trajectory.push(step);
+          onProgress?.(step);
+        }
+      } catch {
+        if (trimmed) {
+          const step = this.createStep("assistant", trimmed);
+          trajectory.push(step);
+          onProgress?.(step);
+        }
+      }
+    }
+  }
+  /**
+   * Parse a single JSON event from stream-json output
+   */
+  parseJsonEvent(event) {
+    const steps = [];
+    if (event.type === "assistant" && event.message?.content) {
+      for (const block of event.message.content) {
+        if (block.type === "thinking" && block.thinking) {
+          steps.push(this.createStep("thinking", block.thinking));
+        } else if (block.type === "text" && block.text) {
+          steps.push(this.createStep("assistant", block.text));
+        } else if (block.type === "tool_use") {
+          steps.push(this.createStep("action", JSON.stringify(block.input || {}), {
+            toolName: block.name,
+            toolArgs: block.input
+          }));
+        }
+      }
+    } else if (event.type === "content_block_delta") {
+      if (event.delta?.type === "thinking_delta" && event.delta.thinking) {
+        this.thinkingBuffer += event.delta.thinking;
+      } else if (event.delta?.type === "text_delta" && event.delta.text) {
+        steps.push(this.createStep("assistant", event.delta.text));
+      }
+    } else if (event.type === "content_block_stop" && this.thinkingBuffer) {
+      steps.push(this.createStep("thinking", this.thinkingBuffer));
+      this.thinkingBuffer = "";
+    } else if (event.type === "result" && event.result) {
+      steps.push(this.createStep(
+        "response",
+        typeof event.result === "string" ? event.result : JSON.stringify(event.result)
+      ));
+    } else if (event.type === "tool_result") {
+      steps.push(this.createStep(
+        "tool_result",
+        typeof event.content === "string" ? event.content : JSON.stringify(event.content),
+        { status: event.is_error ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */ }
+      ));
+    }
+    return steps;
+  }
+  /**
+   * Parse final output for Claude Code
+   */
+  parseResponse(data) {
+    const steps = [];
+    let content = data.stdout;
+    const thinkingMatches = content.matchAll(/<thinking>([\s\S]*?)<\/thinking>/g);
+    for (const match of thinkingMatches) {
+      const thinking = match[1].trim();
+      if (thinking) {
+        steps.push(this.createStep("thinking", thinking));
+      }
+      content = content.replace(match[0], "");
+    }
+    const response = content.trim();
+    if (response) {
+      steps.push(this.createStep("response", response));
+    }
+    if (data.exitCode !== 0 && data.stderr.trim()) {
+      steps.push(this.createStep("tool_result", `Error: ${data.stderr.trim()}`, {
+        status: "FAILURE" /* FAILURE */
+      }));
+    }
+    return steps;
+  }
+  /**
+   * Reset state for new execution
+   */
+  resetState() {
+    this.outputBuffer = "";
+    this.thinkingBuffer = "";
+    this.isInThinking = false;
+  }
+  /**
+   * Override execute to reset state
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    this.debug("========== execute() STARTED ==========");
+    this.debug("Endpoint:", endpoint);
+    this.debug("Test case:", request.testCase.name);
+    this.debug("Config:", this["config"]);
+    this.resetState();
+    this.debug("State reset, calling super.execute()...");
+    const result = await super.execute(endpoint, request, auth, onProgress, onRawEvent);
+    this.debug("super.execute() returned with", result.trajectory.length, "steps");
+    this.debug("========== execute() COMPLETED ==========");
+    return result;
+  }
+  /**
+   * Health check - verify claude command exists
+   */
+  async healthCheck(endpoint, auth) {
+    return super.healthCheck(endpoint || "claude", auth);
+  }
+};
+var claudeCodeConnector = new ClaudeCodeConnector();
+
+// services/connectors/server.ts
+connectorRegistry.register(subprocessConnector);
+connectorRegistry.register(claudeCodeConnector);
+console.log("[Connectors] Server connectors registered:", connectorRegistry.getRegisteredTypes().join(", "));
+
+// cli/utils/serverLifecycle.ts
+import { spawn as spawn2, execSync } from "child_process";
+import net from "net";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join3 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var packageJsonPath = join3(__dirname2, "..", "..", "package.json");
+var cachedVersion = null;
+function getCliVersion() {
+  if (cachedVersion !== null) {
+    return cachedVersion;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    cachedVersion = packageJson.version || "unknown";
+  } catch {
+    try {
+      const altPath = join3(__dirname2, "..", "..", "..", "package.json");
+      const packageJson = JSON.parse(readFileSync(altPath, "utf-8"));
+      cachedVersion = packageJson.version || "unknown";
+    } catch {
+      cachedVersion = "unknown";
+    }
+  }
+  return cachedVersion;
+}
+async function isServerRunning(port) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 2e3);
+  try {
+    const response = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal
+    });
+    if (response.ok) {
+      return true;
+    }
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+  return new Promise((resolve5) => {
+    const socket = new net.Socket();
+    socket.setTimeout(1e3);
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve5(true);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve5(false);
+    });
+    socket.on("error", () => {
+      resolve5(false);
+    });
+    socket.connect(port, "localhost");
+  });
+}
+async function checkServerStatus(port) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 2e3);
+  try {
+    const response = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return {
+        running: true,
+        version: data.version
+      };
+    }
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+  return { running: false };
+}
+async function killServerOnPort(port) {
+  try {
+    if (process.platform !== "win32") {
+      try {
+        execSync(`lsof -t -i:${port} -sTCP:LISTEN | xargs kill -9 2>/dev/null || true`, { stdio: "ignore" });
+      } catch {
+      }
+    } else {
+      try {
+        const result = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+        const lines = result.trim().split("\n");
+        for (const line of lines) {
+          const parts = line.trim().split(/\s+/);
+          const pid = parts[parts.length - 1];
+          if (pid && !isNaN(parseInt(pid))) {
+            try {
+              execSync(`taskkill /PID ${pid} /F`, { stdio: "ignore" });
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const maxRetries = 10;
+    const retryDelay = 500;
+    for (let i = 0; i < maxRetries; i++) {
+      await new Promise((r) => setTimeout(r, retryDelay));
+      const stillRunning = await isServerRunning(port);
+      if (!stillRunning) {
+        return;
+      }
+    }
+    console.warn(`[ServerLifecycle] Port ${port} may still be in use after ${maxRetries} retries`);
+  } catch {
+  }
+}
+async function waitForServer(port, timeout) {
+  const startTime = Date.now();
+  const pollInterval = 500;
+  while (Date.now() - startTime < timeout) {
+    if (await isServerRunning(port)) {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, pollInterval));
+  }
+  return false;
+}
+async function startServer2(port, timeout) {
+  const packageRoot = join3(__dirname2, "..", "..");
+  const cliPath = join3(packageRoot, "bin", "cli.js");
+  const child = spawn2("node", [cliPath, "serve", "-p", String(port), "--no-browser"], {
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: {
+      ...process.env
+    }
+  });
+  let stderrOutput = "";
+  let stdoutOutput = "";
+  child.stderr?.on("data", (data) => {
+    stderrOutput += data.toString();
+  });
+  child.stdout?.on("data", (data) => {
+    stdoutOutput += data.toString();
+  });
+  let earlyExit = false;
+  let exitCode = null;
+  child.on("exit", (code) => {
+    earlyExit = true;
+    exitCode = code;
+  });
+  child.unref();
+  const ready = await waitForServer(port, timeout);
+  if (!ready) {
+    try {
+      child.kill();
+    } catch {
+    }
+    if (earlyExit) {
+      console.error(`[ServerLifecycle] Server process exited with code ${exitCode} before becoming ready`);
+    } else {
+      console.error(`[ServerLifecycle] Server process did not respond to health checks within ${timeout}ms`);
+    }
+    if (stderrOutput) {
+      console.error(`[ServerLifecycle] Server stderr:
+${stderrOutput}`);
+    }
+    if (stdoutOutput) {
+      console.error(`[ServerLifecycle] Server stdout:
+${stdoutOutput}`);
+    }
+    if (!stderrOutput && !stdoutOutput) {
+      console.error(`[ServerLifecycle] No output captured from server process`);
+      console.error(`[ServerLifecycle] CLI path: ${cliPath}`);
+      console.error(`[ServerLifecycle] Package root: ${packageRoot}`);
+    }
+    throw new Error(`Server failed to start within ${timeout}ms on port ${port}`);
+  }
+  return child;
+}
+function stopServer(process2) {
+  try {
+    if (process2.pid) {
+      try {
+        process2.kill("SIGTERM");
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+async function ensureServer(config) {
+  const { port, reuseExistingServer, startTimeout } = config;
+  const baseUrl = `http://localhost:${port}`;
+  const serverStatus = await checkServerStatus(port);
+  const cliVersion = getCliVersion();
+  if (serverStatus.running) {
+    const versionMatches = serverStatus.version === cliVersion || serverStatus.version === "unknown" || cliVersion === "unknown";
+    if (!versionMatches) {
+      console.log(`[ServerLifecycle] Version mismatch detected!`);
+      console.log(`[ServerLifecycle]   Server version: ${serverStatus.version}`);
+      console.log(`[ServerLifecycle]   CLI version: ${cliVersion}`);
+      if (reuseExistingServer) {
+        console.log(`[ServerLifecycle] Stopping old server and starting v${cliVersion}...`);
+        await killServerOnPort(port);
+      } else {
+        throw new Error(
+          `Server version mismatch: server=${serverStatus.version}, CLI=${cliVersion}. Stop the existing server or upgrade to matching version.`
+        );
+      }
+    } else if (reuseExistingServer) {
+      console.log(`[ServerLifecycle] Reusing existing server (version ${serverStatus.version})`);
+      return {
+        wasStarted: false,
+        baseUrl
+      };
+    } else {
+      throw new Error(
+        `Server already running on port ${port}. In CI mode (reuseExistingServer=false), this is an error. Stop the existing server or set reuseExistingServer: true.`
+      );
+    }
+  }
+  const serverProcess = await startServer2(port, startTimeout);
+  return {
+    wasStarted: true,
+    baseUrl,
+    process: serverProcess
+  };
+}
+function createServerCleanup(result, isCI) {
+  return () => {
+    if (result.wasStarted && isCI && result.process) {
+      stopServer(result.process);
+    }
+  };
+}
+
+// cli/utils/apiClient.ts
+var ApiClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Check if server is healthy, with optional retries and exponential backoff.
+   */
+  async checkHealth(retries = 2, delayMs = 500) {
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const res = await fetch(`${this.baseUrl}/health`);
+        if (!res.ok) {
+          throw new Error(`Server health check failed: ${res.status} ${res.statusText}`);
+        }
+        return res.json();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < retries) {
+          await new Promise((resolve5) => setTimeout(resolve5, delayMs * Math.pow(2, attempt)));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * List all benchmarks
+   */
+  async listBenchmarks() {
+    const res = await fetch(`${this.baseUrl}/api/storage/benchmarks`);
+    if (!res.ok) {
+      throw new Error(`Failed to list benchmarks: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.benchmarks || [];
+  }
+  /**
+   * Get benchmark by ID
+   */
+  async getBenchmark(id) {
+    const res = await fetch(`${this.baseUrl}/api/storage/benchmarks/${encodeURIComponent(id)}`);
+    if (res.status === 404) {
+      return null;
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to get benchmark: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * Find benchmark by name or ID
+   *
+   * Prioritizes:
+   * 1. Exact ID match
+   * 2. Exact name match (case-sensitive)
+   */
+  async findBenchmark(identifier) {
+    const byId = await this.getBenchmark(identifier);
+    if (byId) {
+      return byId;
+    }
+    const benchmarks = await this.listBenchmarks();
+    return benchmarks.find((b) => b.name === identifier) || null;
+  }
+  /**
+   * Execute benchmark run (SSE stream)
+   *
+   * Streams progress events and returns the completed run.
+   * If the SSE stream disconnects, falls back to polling for status.
+   */
+  async executeBenchmark(benchmarkId, runConfig, onProgress) {
+    const res = await fetch(
+      `${this.baseUrl}/api/storage/benchmarks/${encodeURIComponent(benchmarkId)}/execute`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(runConfig)
+      }
+    );
+    if (!res.ok) {
+      const errorBody = await res.text();
+      let errorMessage;
+      try {
+        const parsed = JSON.parse(errorBody);
+        errorMessage = parsed.error || errorBody;
+      } catch {
+        errorMessage = errorBody;
+      }
+      throw new Error(`Failed to execute benchmark: ${errorMessage}`);
+    }
+    if (!res.body) {
+      throw new Error("Response body is missing");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finalRun = null;
+    let runId = null;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              onProgress?.(event);
+              if (event.type === "started") {
+                runId = event.runId;
+              } else if (event.type === "completed" || event.type === "cancelled") {
+                finalRun = event.run;
+              } else if (event.type === "error") {
+                throw new Error(event.error);
+              }
+            } catch (e) {
+              if (e instanceof SyntaxError) continue;
+              throw e;
+            }
+          }
+        }
+      }
+    } catch (streamError) {
+      if (runId) {
+        console.warn(`[ApiClient] SSE stream disconnected: ${streamError instanceof Error ? streamError.message : streamError}`);
+        console.warn(`[ApiClient] Falling back to polling for run ${runId}...`);
+        await new Promise((resolve5) => setTimeout(resolve5, 2e3));
+        const polledRun = await this.pollRunStatus(benchmarkId, runId, (run) => {
+          const completedCount = Object.values(run.results || {}).filter(
+            (r) => r.status === "completed" || r.status === "failed"
+          ).length;
+          const totalCount = Object.keys(run.results || {}).length;
+          onProgress?.({
+            type: "progress",
+            currentTestCaseIndex: completedCount - 1,
+            totalTestCases: totalCount,
+            currentTestCase: { id: "polling", name: "Polling for status..." }
+          });
+        });
+        if (polledRun) {
+          return polledRun;
+        }
+      }
+      throw streamError;
+    } finally {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+    }
+    if (!finalRun) {
+      if (runId) {
+        console.warn("[ApiClient] SSE stream ended without completion event, polling for status...");
+        const polledRun = await this.pollRunStatus(benchmarkId, runId);
+        if (polledRun) {
+          return polledRun;
+        }
+      }
+      throw new Error("No final run received from server");
+    }
+    return finalRun;
+  }
+  /**
+   * Cancel an in-progress benchmark run
+   */
+  async cancelRun(benchmarkId, runId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/storage/benchmarks/${encodeURIComponent(benchmarkId)}/cancel`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ runId })
+      }
+    );
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Failed to cancel run: ${errorBody}`);
+    }
+  }
+  /**
+   * Get a specific run from a benchmark by ID.
+   *
+   * Fetches the benchmark and extracts the run with the matching ID.
+   *
+   * @param benchmarkId - The benchmark ID
+   * @param runId - The run ID within the benchmark
+   * @returns The run if found, null otherwise
+   */
+  async getRun(benchmarkId, runId) {
+    const benchmark = await this.getBenchmark(benchmarkId);
+    if (!benchmark) {
+      return null;
+    }
+    return benchmark.runs?.find((r) => r.id === runId) || null;
+  }
+  /**
+   * Poll a run until it reaches a terminal state (completed, failed, cancelled).
+   *
+   * Used as a fallback when SSE stream connection is lost but server continues
+   * processing in the background.
+   *
+   * @param benchmarkId - The benchmark ID
+   * @param runId - The run ID to poll
+   * @param onProgress - Optional callback for progress updates during polling
+   * @param timeoutMs - Maximum time to wait (default: 10 minutes)
+   * @returns The final run state, or null if not found
+   */
+  async pollRunStatus(benchmarkId, runId, onProgress, timeoutMs = 6e5) {
+    const startTime = Date.now();
+    const pollInterval = 5e3;
+    while (Date.now() - startTime < timeoutMs) {
+      const run = await this.getRun(benchmarkId, runId);
+      if (!run) return null;
+      onProgress?.(run);
+      if (run.status && ["completed", "failed", "cancelled"].includes(run.status)) {
+        return run;
+      }
+      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
+    }
+    return this.getRun(benchmarkId, runId);
+  }
+  /**
+   * Get a single report (TestCaseRun) by ID.
+   *
+   * This is the preferred method for fetching reports - use report IDs
+   * from run.results[testCaseId].reportId.
+   *
+   * @param reportId - The report ID to fetch
+   * @returns The report if found, null otherwise
+   */
+  async getReportById(reportId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/storage/runs/${encodeURIComponent(reportId)}`
+    );
+    if (res.status === 404) {
+      return null;
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to get report: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * List all test cases (basic)
+   */
+  async listTestCases() {
+    const res = await fetch(`${this.baseUrl}/api/storage/test-cases`);
+    if (!res.ok) {
+      throw new Error(`Failed to list test cases: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.testCases || [];
+  }
+  /**
+   * List all test cases with full data and metadata
+   */
+  async listTestCasesWithMeta() {
+    const res = await fetch(`${this.baseUrl}/api/storage/test-cases`);
+    if (!res.ok) {
+      throw new Error(`Failed to list test cases: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return {
+      data: data.testCases || [],
+      total: data.total || 0,
+      meta: data.meta || {
+        storageConfigured: false,
+        storageReachable: false,
+        realDataCount: 0,
+        sampleDataCount: data.testCases?.length || 0
+      }
+    };
+  }
+  /**
+   * Bulk create test cases
+   */
+  async bulkCreateTestCases(testCases) {
+    const res = await fetch(`${this.baseUrl}/api/storage/test-cases/bulk`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ testCases })
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      let errorMessage;
+      try {
+        const parsed = JSON.parse(errorBody);
+        errorMessage = parsed.error || errorBody;
+      } catch {
+        errorMessage = errorBody;
+      }
+      throw new Error(`Failed to bulk create test cases: ${errorMessage}`);
+    }
+    return res.json();
+  }
+  /**
+   * List all benchmarks with metadata
+   */
+  async listBenchmarksWithMeta() {
+    const res = await fetch(`${this.baseUrl}/api/storage/benchmarks`);
+    if (!res.ok) {
+      throw new Error(`Failed to list benchmarks: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return {
+      data: data.benchmarks || [],
+      total: data.total || 0,
+      meta: data.meta || {
+        storageConfigured: false,
+        storageReachable: false,
+        realDataCount: 0,
+        sampleDataCount: data.benchmarks?.length || 0
+      }
+    };
+  }
+  /**
+   * List all configured agents
+   */
+  async listAgents() {
+    const res = await fetch(`${this.baseUrl}/api/agents`);
+    if (!res.ok) {
+      throw new Error(`Failed to list agents: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.agents || [];
+  }
+  /**
+   * List all configured models
+   */
+  async listModels() {
+    const res = await fetch(`${this.baseUrl}/api/models`);
+    if (!res.ok) {
+      throw new Error(`Failed to list models: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.models || [];
+  }
+  /**
+   * Get a single test case by ID
+   */
+  async getTestCase(id) {
+    const res = await fetch(`${this.baseUrl}/api/storage/test-cases/${encodeURIComponent(id)}`);
+    if (res.status === 404) {
+      return null;
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to get test case: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * Find test case by ID or name
+   */
+  async findTestCase(identifier) {
+    const byId = await this.getTestCase(identifier);
+    if (byId) {
+      return byId;
+    }
+    const response = await this.listTestCasesWithMeta();
+    return response.data.find(
+      (tc) => tc.name.toLowerCase() === identifier.toLowerCase()
+    ) || null;
+  }
+  /**
+   * Evaluation progress event types
+   */
+  /**
+   * Run a single test case evaluation via server API (SSE stream)
+   */
+  async runEvaluation(testCaseId, agentKey, modelId, onProgress) {
+    const res = await fetch(`${this.baseUrl}/api/evaluate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ testCaseId, agentKey, modelId })
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      let errorMessage;
+      try {
+        const parsed = JSON.parse(errorBody);
+        errorMessage = parsed.error || errorBody;
+      } catch {
+        errorMessage = errorBody;
+      }
+      throw new Error(`Failed to run evaluation: ${errorMessage}`);
+    }
+    if (!res.body) {
+      throw new Error("Response body is missing");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let result = null;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              onProgress?.(event);
+              if (event.type === "completed") {
+                result = event.report;
+              } else if (event.type === "error") {
+                throw new Error(event.error);
+              }
+            } catch (e) {
+              if (e instanceof SyntaxError) continue;
+              throw e;
+            }
+          }
+        }
+      }
+    } finally {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+    }
+    if (!result) {
+      throw new Error("No result received from evaluation");
+    }
+    return result;
+  }
+  /**
+   * Export benchmark test cases as import-compatible JSON
+   */
+  async exportBenchmark(benchmarkId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/storage/benchmarks/${encodeURIComponent(benchmarkId)}/export`
+    );
+    if (res.status === 404) {
+      throw new Error(`Benchmark not found: ${benchmarkId}`);
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to export benchmark: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * Create a new benchmark
+   */
+  async createBenchmark(input) {
+    const res = await fetch(`${this.baseUrl}/api/storage/benchmarks`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Failed to create benchmark: ${errorBody}`);
+    }
+    return res.json();
+  }
+};
+
+// cli/commands/list.ts
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function displayStorageWarnings(meta) {
+  if (!meta.storageConfigured) {
+    console.log(chalk.yellow("\n  \u26A0 Storage not configured"));
+    console.log(chalk.gray("    Showing sample data only. Set OPENSEARCH_STORAGE_* env vars for persistent storage.\n"));
+  } else if (!meta.storageReachable) {
+    console.log(chalk.yellow("\n  \u26A0 Storage unreachable"));
+    meta.warnings?.forEach((w) => console.log(chalk.gray(`    - ${w}`)));
+    console.log();
+  }
+}
+async function listAgents(format, config) {
+  const serverResult = await ensureServer(config.server);
+  const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+  try {
+    const client = new ApiClient(serverResult.baseUrl);
+    const agents = await client.listAgents();
+    if (format === "json") {
+      console.log(formatJson(agents));
+      return;
+    }
+    const table = new Table({
+      head: [
+        chalk.cyan("Key"),
+        chalk.cyan("Name"),
+        chalk.cyan("Connector"),
+        chalk.cyan("Models"),
+        chalk.cyan("Endpoint")
+      ],
+      colWidths: [15, 20, 15, 25, 40],
+      wordWrap: true
+    });
+    for (const agent of agents) {
+      table.push([
+        agent.key,
+        agent.name,
+        agent.connectorType || "agui-streaming",
+        agent.models.slice(0, 3).join(", ") + (agent.models.length > 3 ? "..." : ""),
+        agent.endpoint.substring(0, 37) + (agent.endpoint.length > 37 ? "..." : "")
+      ]);
+    }
+    console.log(chalk.bold("\nAvailable Agents:\n"));
+    console.log(table.toString());
+    console.log(chalk.gray(`
+  Total: ${agents.length} agents
+`));
+  } catch (error) {
+    console.error(chalk.red(`
+  Error: ${error.message}`));
+    console.log(chalk.gray("  Is the server running? Start with: npm run dev:server\n"));
+    process.exit(1);
+  } finally {
+    cleanup();
+  }
+}
+async function listTestCases(format, config) {
+  const serverResult = await ensureServer(config.server);
+  const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+  try {
+    const client = new ApiClient(serverResult.baseUrl);
+    const response = await client.listTestCasesWithMeta();
+    displayStorageWarnings(response.meta);
+    if (format === "json") {
+      console.log(formatJson(response));
+      return;
+    }
+    const table = new Table({
+      head: [
+        chalk.cyan("ID"),
+        chalk.cyan("Name"),
+        chalk.cyan("Labels"),
+        chalk.cyan("Version"),
+        chalk.cyan("Source")
+      ],
+      colWidths: [25, 28, 28, 10, 10],
+      wordWrap: true
+    });
+    for (const tc of response.data) {
+      const isDemo = tc.id.startsWith("demo-");
+      table.push([
+        tc.id,
+        tc.name,
+        tc.labels?.slice(0, 3).join(", ") || "",
+        `v${tc.currentVersion || 1}`,
+        isDemo ? chalk.gray("Sample") : chalk.green("Stored")
+      ]);
+    }
+    console.log(chalk.bold("\nAvailable Test Cases:\n"));
+    console.log(table.toString());
+    const { meta } = response;
+    if (meta.realDataCount > 0 || meta.sampleDataCount > 0) {
+      console.log(chalk.gray(`
+  Total: ${response.total} test cases (${meta.realDataCount} stored, ${meta.sampleDataCount} sample)
+`));
+    } else {
+      console.log(chalk.gray(`
+  Total: ${response.total} test cases
+`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`
+  Error: ${error.message}`));
+    console.log(chalk.gray("  Is the server running? Start with: npm run dev:server\n"));
+    process.exit(1);
+  } finally {
+    cleanup();
+  }
+}
+async function listBenchmarks(format, config) {
+  const serverResult = await ensureServer(config.server);
+  const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+  try {
+    const client = new ApiClient(serverResult.baseUrl);
+    const response = await client.listBenchmarksWithMeta();
+    displayStorageWarnings(response.meta);
+    if (format === "json") {
+      console.log(formatJson(response));
+      return;
+    }
+    const table = new Table({
+      head: [
+        chalk.cyan("ID"),
+        chalk.cyan("Name"),
+        chalk.cyan("Test Cases"),
+        chalk.cyan("Created"),
+        chalk.cyan("Source")
+      ],
+      colWidths: [28, 28, 12, 22, 10],
+      wordWrap: true
+    });
+    for (const b of response.data) {
+      const isDemo = b.id.startsWith("demo-");
+      table.push([
+        b.id,
+        b.name,
+        b.testCaseIds.length.toString(),
+        new Date(b.createdAt).toLocaleDateString(),
+        isDemo ? chalk.gray("Sample") : chalk.green("Stored")
+      ]);
+    }
+    console.log(chalk.bold("\nAvailable Benchmarks:\n"));
+    console.log(table.toString());
+    const { meta } = response;
+    if (meta.realDataCount > 0 || meta.sampleDataCount > 0) {
+      console.log(chalk.gray(`
+  Total: ${response.total} benchmarks (${meta.realDataCount} stored, ${meta.sampleDataCount} sample)
+`));
+    } else {
+      console.log(chalk.gray(`
+  Total: ${response.total} benchmarks
+`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`
+  Error: ${error.message}`));
+    console.log(chalk.gray("  Is the server running? Start with: npm run dev:server\n"));
+    process.exit(1);
+  } finally {
+    cleanup();
+  }
+}
+function listConnectors(format) {
+  const types = connectorRegistry.getRegisteredTypes();
+  const connectors = types.map((type) => {
+    const connector = connectorRegistry.get(type);
+    return {
+      type,
+      name: connector?.name || "Unknown",
+      streaming: connector?.supportsStreaming || false
+    };
+  });
+  if (format === "json") {
+    console.log(formatJson(connectors));
+    return;
+  }
+  const table = new Table({
+    head: [
+      chalk.cyan("Type"),
+      chalk.cyan("Name"),
+      chalk.cyan("Streaming")
+    ],
+    colWidths: [20, 25, 12]
+  });
+  for (const c of connectors) {
+    table.push([
+      c.type,
+      c.name,
+      c.streaming ? chalk.green("Yes") : chalk.gray("No")
+    ]);
+  }
+  console.log(chalk.bold("\nRegistered Connectors:\n"));
+  console.log(table.toString());
+  console.log(chalk.gray(`
+  Total: ${connectors.length} connectors
+`));
+}
+async function listModels(format, config) {
+  const serverResult = await ensureServer(config.server);
+  const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+  try {
+    const client = new ApiClient(serverResult.baseUrl);
+    const models = await client.listModels();
+    if (format === "json") {
+      console.log(formatJson(models));
+      return;
+    }
+    const table = new Table({
+      head: [
+        chalk.cyan("Key"),
+        chalk.cyan("Display Name"),
+        chalk.cyan("Provider"),
+        chalk.cyan("Context")
+      ],
+      colWidths: [25, 30, 12, 12],
+      wordWrap: true
+    });
+    for (const m of models) {
+      table.push([
+        m.key,
+        m.display_name || m.key,
+        m.provider || "bedrock",
+        m.context_window ? `${Math.round(m.context_window / 1e3)}k` : "-"
+      ]);
+    }
+    console.log(chalk.bold("\nAvailable Models:\n"));
+    console.log(table.toString());
+    console.log(chalk.gray(`
+  Total: ${models.length} models
+`));
+  } catch (error) {
+    console.error(chalk.red(`
+  Error: ${error.message}`));
+    console.log(chalk.gray("  Is the server running? Start with: npm run dev:server\n"));
+    process.exit(1);
+  } finally {
+    cleanup();
+  }
+}
+function createListCommand() {
+  const command = new Command("list").description("List available resources").argument("<resource>", "Resource type: agents, test-cases, benchmarks, connectors, models").option("-o, --output <format>", "Output format: table, json", "table").action(async (resource, options) => {
+    const format = options.output;
+    const config = await loadConfig();
+    for (const connector of config.connectors) {
+      connectorRegistry.register(connector);
+    }
+    switch (resource.toLowerCase()) {
+      case "agents":
+        await listAgents(format, config);
+        break;
+      case "test-cases":
+      case "testcases":
+      case "tc":
+        await listTestCases(format, config);
+        break;
+      case "benchmarks":
+      case "bench":
+        await listBenchmarks(format, config);
+        break;
+      case "connectors":
+        listConnectors(format);
+        break;
+      case "models":
+        await listModels(format, config);
+        break;
+      default:
+        console.error(chalk.red(`
+  Unknown resource type: ${resource}`));
+        console.log(chalk.gray("  Available: agents, test-cases, benchmarks, connectors, models\n"));
+        process.exit(1);
+    }
+  });
+  return command;
+}
+
+// cli/commands/run.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import Table2 from "cli-table3";
+function findAgent(identifier, config) {
+  return config.agents.find(
+    (a) => a.key === identifier || a.name.toLowerCase() === identifier.toLowerCase()
+  );
+}
+function getDefaultModel(agent) {
+  return agent.models[0] || "claude-sonnet";
+}
+async function commandExists(command) {
+  const { execSync: execSync2 } = await import("child_process");
+  const checkCommand = process.platform === "win32" ? `where ${command}` : `which ${command}`;
+  try {
+    execSync2(checkCommand, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function validateAgentRequirements(agent) {
+  if (agent.connectorType === "claude-code") {
+    if (!await commandExists("claude")) {
+      return `Claude CLI not found in PATH. Install Claude Code CLI: https://claude.ai/code`;
+    }
+  }
+  if (agent.connectorType === "subprocess" && agent.endpoint) {
+    const command = agent.endpoint.split(" ")[0];
+    if (!await commandExists(command)) {
+      return `Command '${command}' not found in PATH`;
+    }
+  }
+  return void 0;
+}
+async function runForAgent(client, testCaseId, agent, modelId, verbose) {
+  const spinner = ora(`Running ${agent.name}...`).start();
+  try {
+    const report = await client.runEvaluation(
+      testCaseId,
+      agent.key,
+      modelId,
+      (event) => {
+        if (event.type === "step" && verbose) {
+          spinner.text = `${agent.name}: Step ${event.stepIndex + 1} (${event.step.type})`;
+        } else if (event.type === "started") {
+          spinner.text = `${agent.name}: Started evaluation...`;
+        }
+      }
+    );
+    if (report.status === "completed" && report.passFailStatus === "passed") {
+      spinner.succeed(`${agent.name}: ${chalk2.green("PASSED")}`);
+    } else if (report.status === "completed") {
+      spinner.succeed(`${agent.name}: ${chalk2.red("FAILED")}`);
+    } else {
+      spinner.fail(`${agent.name}: ${chalk2.yellow(report.status)}`);
+    }
+    return report;
+  } catch (error) {
+    spinner.fail(`${agent.name}: ${chalk2.red("ERROR")}`);
+    throw error;
+  }
+}
+function displayTableResults(results) {
+  const table = new Table2({
+    head: [
+      chalk2.cyan("Agent"),
+      chalk2.cyan("Status"),
+      chalk2.cyan("Accuracy"),
+      chalk2.cyan("Steps"),
+      chalk2.cyan("Report ID")
+    ],
+    colWidths: [20, 12, 12, 10, 30]
+  });
+  for (const r of results) {
+    if (!r.report) {
+      table.push([
+        r.agent.name,
+        chalk2.red("ERROR"),
+        "-",
+        "-",
+        "-"
+      ]);
+      continue;
+    }
+    const statusStr = r.report.passFailStatus === "passed" ? chalk2.green("PASSED") : r.report.passFailStatus === "failed" ? chalk2.red("FAILED") : chalk2.yellow(r.report.status);
+    table.push([
+      r.agent.name,
+      statusStr,
+      r.report.metrics?.accuracy ? `${Math.round(r.report.metrics.accuracy)}%` : "-",
+      r.report.trajectorySteps.toString(),
+      r.report.id?.substring(0, 27) + "..." || "-"
+    ]);
+  }
+  console.log("\n");
+  console.log(table.toString());
+}
+function createRunCommand() {
+  const command = new Command2("run").description("Run a test case against agents").requiredOption("-t, --test-case <id>", "Test case ID or name").option("-a, --agent <key>", "Agent key (can be specified multiple times)", (val, arr) => [...arr, val], []).option("-m, --model <id>", "Model ID (uses agent default if not specified)").option("-o, --output <format>", "Output format: table, json", "table").option("-v, --verbose", "Show detailed trajectory output").action(async (options) => {
+    console.log(chalk2.bold("\nAgent Health - Test Case Runner\n"));
+    const config = await loadConfig();
+    for (const connector of config.connectors) {
+      connectorRegistry.register(connector);
+    }
+    const serverResult = await ensureServer(config.server);
+    const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+    try {
+      const client = new ApiClient(serverResult.baseUrl);
+      await client.checkHealth();
+      const testCase = await client.findTestCase(options.testCase);
+      if (!testCase) {
+        console.error(chalk2.red(`  Error: Test case not found: ${options.testCase}`));
+        console.log(chalk2.gray("  Use `agent-health list test-cases` to see available test cases\n"));
+        process.exit(1);
+      }
+      console.log(chalk2.gray(`  Test Case: ${testCase.name} (${testCase.id})`));
+      console.log(chalk2.gray(`  Server: ${serverResult.baseUrl}`));
+      let agents = [];
+      if (options.agent.length === 0) {
+        agents = [config.agents[0]];
+        console.log(chalk2.gray(`  Agent: ${agents[0].name} (default)`));
+      } else {
+        for (const agentId of options.agent) {
+          const agent = findAgent(agentId, config);
+          if (!agent) {
+            console.error(chalk2.red(`  Error: Agent not found: ${agentId}`));
+            console.log(chalk2.gray("  Use `agent-health list agents` to see available agents\n"));
+            process.exit(1);
+          }
+          agents.push(agent);
+        }
+        console.log(chalk2.gray(`  Agents: ${agents.map((a) => a.name).join(", ")}`));
+      }
+      console.log("");
+      const results = [];
+      for (const agent of agents) {
+        const modelId = options.model || getDefaultModel(agent);
+        const validationError = await validateAgentRequirements(agent);
+        if (validationError) {
+          console.error(chalk2.red(`  Error: ${validationError}`));
+          results.push({ agent, report: null });
+          continue;
+        }
+        try {
+          const report = await runForAgent(client, testCase.id, agent, modelId, options.verbose || false);
+          results.push({ agent, report });
+        } catch (error) {
+          console.error(chalk2.red(`  Error running ${agent.name}: ${error instanceof Error ? error.message : error}`));
+          results.push({ agent, report: null });
+        }
+      }
+      if (options.output === "json") {
+        console.log(JSON.stringify(results.map((r) => ({
+          agent: { key: r.agent.key, name: r.agent.name },
+          report: r.report
+        })), null, 2));
+      } else {
+        displayTableResults(results);
+      }
+    } catch (error) {
+      console.error(chalk2.red(`
+  Error: ${error.message}`));
+      console.log(chalk2.gray("  Is the server running? Start with: npm run dev:server\n"));
+      process.exit(1);
+    } finally {
+      cleanup();
+    }
+  });
+  return command;
+}
+
+// cli/commands/benchmark.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import Table3 from "cli-table3";
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+
+// lib/testCaseValidation.ts
+import { z } from "zod";
+var contextItemSchema = z.object({
+  description: z.string(),
+  value: z.string()
+}).required();
+var difficultySchema = z.enum(["Easy", "Medium", "Hard"]);
+var testCaseSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  description: z.string().optional().default(""),
+  category: z.string().min(1, "Category is required"),
+  subcategory: z.string().optional(),
+  difficulty: difficultySchema,
+  initialPrompt: z.string().min(1, "Initial prompt is required"),
+  context: z.array(contextItemSchema).optional().default([]),
+  expectedOutcomes: z.array(z.string()).refine(
+    (outcomes) => outcomes.some((o) => o.trim().length > 0),
+    "At least one non-empty expected outcome is required"
+  )
+});
+var testCasesArraySchema = z.array(testCaseSchema).min(1, "Array cannot be empty");
+function zodErrorToValidationErrors(error) {
+  return error.errors.map((e) => ({
+    path: e.path.join("."),
+    message: e.message,
+    type: "error"
+  }));
+}
+function validateTestCaseJson(json) {
+  if (Array.isArray(json)) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: "Received an array. Use Bulk Import mode for multiple test cases", type: "error" }]
+    };
+  }
+  const result = testCaseSchema.safeParse(json);
+  if (!result.success) {
+    return {
+      valid: false,
+      errors: zodErrorToValidationErrors(result.error)
+    };
+  }
+  return { valid: true, errors: [], data: result.data };
+}
+function validateTestCasesArrayJson(json) {
+  if (json && typeof json === "object" && !Array.isArray(json)) {
+    const singleResult = validateTestCaseJson(json);
+    if (singleResult.valid && singleResult.data) {
+      return {
+        valid: true,
+        errors: [],
+        data: [singleResult.data]
+      };
+    }
+    return { valid: false, errors: singleResult.errors };
+  }
+  const result = testCasesArraySchema.safeParse(json);
+  if (!result.success) {
+    return {
+      valid: false,
+      errors: zodErrorToValidationErrors(result.error)
+    };
+  }
+  return { valid: true, errors: [], data: result.data };
+}
+
+// lib/runStats.ts
+function calculateRunStats(run, reports) {
+  let passed = 0;
+  let failed = 0;
+  let pending = 0;
+  let total = 0;
+  Object.entries(run.results || {}).forEach(([testCaseId, result]) => {
+    total++;
+    if (result.status === "pending" || result.status === "running") {
+      pending++;
+      return;
+    }
+    if (result.status === "failed" || result.status === "cancelled") {
+      failed++;
+      return;
+    }
+    if (result.status === "completed" && result.reportId) {
+      const report = reports[result.reportId];
+      if (!report) {
+        pending++;
+        return;
+      }
+      if (report.metricsStatus === "pending" || report.metricsStatus === "calculating") {
+        pending++;
+        return;
+      }
+      if (report.passFailStatus === "passed") {
+        passed++;
+      } else {
+        failed++;
+      }
+    } else {
+      pending++;
+    }
+  });
+  const passRate = total > 0 ? Math.round(passed / total * 100) : 0;
+  return {
+    passed,
+    failed,
+    pending,
+    total,
+    passRate
+  };
+}
+function getReportIdsFromRun(run) {
+  const reportIds = /* @__PURE__ */ new Set();
+  Object.values(run.results || {}).forEach((result) => {
+    if (result.reportId) {
+      reportIds.add(result.reportId);
+    }
+  });
+  return Array.from(reportIds);
+}
+
+// cli/commands/benchmark.ts
+function findAgent2(identifier, config) {
+  return config.agents.find(
+    (a) => a.key === identifier || a.name.toLowerCase() === identifier.toLowerCase()
+  );
+}
+function getDefaultModel2(agent) {
+  return agent.models[0] || "claude-sonnet";
+}
+function isFilePath(value) {
+  return value.toLowerCase().endsWith(".json");
+}
+function loadAndValidateTestCasesFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf-8");
+  } catch (err) {
+    throw new Error(`Cannot read file: ${filePath} (${err instanceof Error ? err.message : err})`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in file: ${filePath}`);
+  }
+  const result = validateTestCasesArrayJson(parsed);
+  if (!result.valid || !result.data) {
+    const msgs = result.errors.map((e) => e.path ? `${e.path}: ${e.message}` : e.message).join("\n  ");
+    throw new Error(`Validation failed for ${filePath}:
+  ${msgs}`);
+  }
+  return result.data;
+}
+async function fetchReportsForRun(api, run) {
+  const reportIds = getReportIdsFromRun(run);
+  const reportsMap = {};
+  await Promise.all(
+    reportIds.map(async (reportId) => {
+      reportsMap[reportId] = await api.getReportById(reportId);
+    })
+  );
+  return reportsMap;
+}
+async function runBenchmarkForAgent(api, agent, modelId, benchmark, verbose) {
+  const results = {
+    agent,
+    passed: 0,
+    failed: 0
+  };
+  const totalTestCases = benchmark.testCaseIds.length;
+  const spinner = ora2(`Running ${agent.name} (0/${totalTestCases})`).start();
+  let startedRunId;
+  try {
+    const completedRun = await api.executeBenchmark(
+      benchmark.id,
+      {
+        name: `CLI Run - ${agent.name}`,
+        agentKey: agent.key,
+        modelId
+      },
+      (event) => {
+        if (event.type === "started") {
+          startedRunId = event.runId;
+        } else if (event.type === "progress") {
+          const current = event.currentTestCaseIndex + 1;
+          const testCaseName = event.currentTestCase?.name || `Test ${current}`;
+          spinner.text = `${agent.name}: ${testCaseName} (${current}/${totalTestCases})`;
+          if (verbose && event.result) {
+            const status = event.result.status === "completed" ? chalk3.green("\u2713") : chalk3.red("\u2717");
+            spinner.text = `${agent.name}: ${testCaseName} ${status} (${current}/${totalTestCases})`;
+          }
+        }
+      }
+    );
+    results.run = completedRun;
+    const reportsMap = await fetchReportsForRun(api, completedRun);
+    const stats = calculateRunStats(completedRun, reportsMap);
+    results.passed = stats.passed;
+    results.failed = stats.failed;
+    results.reports = Object.values(reportsMap).filter((r) => r !== null);
+    const passRate = stats.passRate;
+    if (passRate >= 80) {
+      spinner.succeed(
+        `${agent.name}: ${chalk3.green(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+      );
+    } else if (passRate >= 50) {
+      spinner.warn(
+        `${agent.name}: ${chalk3.yellow(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+      );
+    } else {
+      spinner.fail(
+        `${agent.name}: ${chalk3.red(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+      );
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (startedRunId) {
+      results.runId = startedRunId;
+      try {
+        const run = await api.getRun(benchmark.id, startedRunId);
+        if (run) {
+          results.run = run;
+          const reportsMap = await fetchReportsForRun(api, run);
+          const stats = calculateRunStats(run, reportsMap);
+          results.passed = stats.passed;
+          results.failed = stats.failed;
+          results.reports = Object.values(reportsMap).filter((r) => r !== null);
+          if (run.status === "completed" || run.status === "cancelled") {
+            const passRate = stats.passRate;
+            if (passRate >= 80) {
+              spinner.succeed(
+                `${agent.name}: ${chalk3.green(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+              );
+            } else if (passRate >= 50) {
+              spinner.warn(
+                `${agent.name}: ${chalk3.yellow(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+              );
+            } else {
+              spinner.fail(
+                `${agent.name}: ${chalk3.red(`${stats.passed}/${stats.total} passed`)} (${passRate}% pass rate)`
+              );
+            }
+            return results;
+          }
+        }
+      } catch {
+      }
+    }
+    const isStreamError = errorMessage.includes("terminated") || errorMessage.includes("network") || errorMessage.includes("stream") || errorMessage.includes("aborted");
+    if (isStreamError && startedRunId) {
+      spinner.warn(`${agent.name}: ${chalk3.yellow("Stream disconnected")} - server may still be processing`);
+      console.log(chalk3.gray(`  Check status: Use the UI to monitor progress`));
+    } else {
+      spinner.fail(`${agent.name}: ${chalk3.red("Failed")} - ${errorMessage}`);
+    }
+  }
+  return results;
+}
+function displaySummaryTable(allResults, totalTestCases) {
+  const table = new Table3({
+    head: [
+      chalk3.cyan("Agent"),
+      chalk3.cyan("Passed"),
+      chalk3.cyan("Failed"),
+      chalk3.cyan("Pass Rate"),
+      chalk3.cyan("Run ID")
+    ],
+    colWidths: [25, 10, 10, 12, 35]
+  });
+  for (const results of allResults) {
+    const passRate = totalTestCases > 0 ? results.passed / totalTestCases * 100 : 0;
+    const passRateColor = passRate >= 80 ? chalk3.green : passRate >= 50 ? chalk3.yellow : chalk3.red;
+    table.push([
+      results.agent.name,
+      chalk3.green(results.passed.toString()),
+      chalk3.red(results.failed.toString()),
+      passRateColor(`${passRate.toFixed(0)}%`),
+      results.run?.id || results.runId || chalk3.gray("N/A")
+    ]);
+  }
+  console.log("\n");
+  console.log(chalk3.bold("Benchmark Summary"));
+  console.log(table.toString());
+}
+function exportResults(benchmark, allResults, exportPath) {
+  const exportData = {
+    benchmark: {
+      id: benchmark.id,
+      name: benchmark.name,
+      testCaseCount: benchmark.testCaseIds.length
+    },
+    runs: allResults.map((r) => ({
+      agent: { key: r.agent.key, name: r.agent.name },
+      runId: r.run?.id || r.runId,
+      status: r.run?.status,
+      passed: r.passed,
+      failed: r.failed,
+      passRate: benchmark.testCaseIds.length > 0 ? r.passed / benchmark.testCaseIds.length * 100 : 0,
+      results: r.run?.results,
+      reports: r.reports
+    })),
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(exportPath, JSON.stringify(exportData, null, 2));
+  console.log(chalk3.green(`
+Results exported to: ${exportPath}`));
+}
+function createBenchmarkCommand() {
+  const command = new Command3("benchmark").description("Run a benchmark against one or more agents").option("-n, --name <name>", "Benchmark name or ID (optional in quick mode)").option("-f, --file <path>", "JSON file of test cases to import and benchmark").option(
+    "-a, --agent <key>",
+    "Agent key (can be specified multiple times)",
+    (val, arr) => [...arr, val],
+    []
+  ).option("-m, --model <id>", "Model ID (uses agent default if not specified)").option("-o, --output <format>", "Output format: table, json", "table").option("--export <path>", "Export results to JSON file").option("-v, --verbose", "Show detailed output").option("--stop-server", "Stop the server after benchmark completes (default: keep running)").action(async (options) => {
+    console.log(chalk3.bold("\nAgent Health - Benchmark Runner\n"));
+    const config = await loadConfig();
+    const serverConfig = { ...DEFAULT_SERVER_CONFIG, ...config.server };
+    const isCI = !!process.env.CI;
+    const serverWasRunning = await isServerRunning(serverConfig.port);
+    const filePath = options.file || (options.name && isFilePath(options.name) ? options.name : void 0);
+    const fileMode = !!filePath;
+    const quickMode = !options.name && !fileMode && !serverWasRunning;
+    if (!options.name && !fileMode && serverWasRunning) {
+      console.error(chalk3.red("  Error: Benchmark name required when server is already running."));
+      console.log("");
+      console.log(chalk3.cyan("  Options:"));
+      console.log(chalk3.gray('    1. Specify a benchmark:  benchmark -n "Name" -a claude-code'));
+      console.log(chalk3.gray("    2. Import from file:     benchmark -f ./test-cases.json -a mock"));
+      console.log(chalk3.gray("    3. Stop the server and run in quick mode"));
+      console.log(chalk3.gray("    4. List available:       npx agent-health list benchmarks"));
+      console.log("");
+      process.exit(1);
+    }
+    if (fileMode) {
+      console.log(chalk3.cyan(`  Running in file mode (importing test cases from ${filePath})`));
+    } else if (quickMode) {
+      console.log(chalk3.cyan("  Running in quick mode (auto-creating benchmark from test cases)"));
+    }
+    const connectSpinner = ora2("Connecting to server...").start();
+    let serverResult;
+    let cleanup;
+    const shouldStopServer = isCI || quickMode || fileMode || options.stopServer;
+    try {
+      serverResult = await ensureServer(serverConfig);
+      cleanup = createServerCleanup(serverResult, shouldStopServer);
+      if (serverResult.wasStarted) {
+        connectSpinner.succeed(`Started server on port ${serverConfig.port}`);
+      } else {
+        connectSpinner.succeed(`Connected to existing server on port ${serverConfig.port}`);
+      }
+    } catch (error) {
+      connectSpinner.fail(
+        `Failed to connect to server: ${error instanceof Error ? error.message : error}`
+      );
+      process.exit(1);
+    }
+    const api = new ApiClient(serverResult.baseUrl);
+    try {
+      let benchmark = null;
+      if (fileMode) {
+        const importSpinner = ora2(`Loading test cases from ${filePath}...`).start();
+        try {
+          const validatedTestCases = loadAndValidateTestCasesFile(filePath);
+          importSpinner.succeed(`Validated ${validatedTestCases.length} test cases from file`);
+          const uploadSpinner = ora2("Importing test cases to server...").start();
+          const bulkResult = await api.bulkCreateTestCases(validatedTestCases);
+          uploadSpinner.succeed(`Imported ${bulkResult.created} test cases`);
+          const benchmarkName = options.file && options.name ? options.name : `file-${Date.now()}`;
+          const createSpinner = ora2("Creating benchmark...").start();
+          benchmark = await api.createBenchmark({
+            name: benchmarkName,
+            description: `Imported from ${filePath}`,
+            testCaseIds: bulkResult.testCases.map((tc) => tc.id)
+          });
+          createSpinner.succeed(`Created benchmark: ${benchmark.name}`);
+        } catch (error) {
+          importSpinner.fail(`File import failed: ${error instanceof Error ? error.message : error}`);
+          process.exit(1);
+        }
+      } else if (quickMode) {
+        const testCasesSpinner = ora2("Fetching test cases...").start();
+        try {
+          const testCases = await api.listTestCases();
+          if (testCases.length === 0) {
+            testCasesSpinner.fail("No test cases found");
+            console.log(chalk3.gray("  Add test cases via the UI or provide a file with -f option."));
+            process.exit(1);
+          }
+          testCasesSpinner.succeed(`Found ${testCases.length} test cases`);
+          const createSpinner = ora2("Creating quick benchmark...").start();
+          benchmark = await api.createBenchmark({
+            name: `quick-${Date.now()}`,
+            description: "Auto-generated benchmark for quick mode",
+            testCaseIds: testCases.map((tc) => tc.id)
+          });
+          createSpinner.succeed(`Created benchmark: ${benchmark.name}`);
+        } catch (error) {
+          testCasesSpinner.fail(`Failed to create benchmark: ${error instanceof Error ? error.message : error}`);
+          process.exit(1);
+        }
+      } else {
+        benchmark = await api.findBenchmark(options.name);
+        if (!benchmark) {
+          console.error(chalk3.red(`  Error: Benchmark not found: "${options.name}"`));
+          console.log("");
+          console.log(chalk3.cyan("  The -n/--name option accepts:"));
+          console.log(chalk3.gray("    \u2022 Benchmark ID (e.g., demo-baseline)"));
+          console.log(chalk3.gray('    \u2022 Benchmark name (case-sensitive, e.g., "Baseline")'));
+          console.log("");
+          console.log(chalk3.cyan("  Or import from file:"));
+          console.log(chalk3.gray("    benchmark -f ./test-cases.json -a mock"));
+          console.log("");
+          console.log(chalk3.cyan("  Available benchmarks:"));
+          console.log(chalk3.gray("    npx agent-health list benchmarks"));
+          console.log("");
+          process.exit(1);
+        }
+        if (benchmark.id.startsWith("demo-")) {
+          console.error(chalk3.red(`  Error: Cannot execute sample benchmarks.`));
+          console.log(chalk3.gray("  Sample data is read-only with pre-completed runs."));
+          console.log(chalk3.gray("  Create a real benchmark in the UI to run evaluations."));
+          console.log("");
+          process.exit(1);
+        }
+      }
+      console.log(chalk3.gray(`  Benchmark: ${benchmark.name} (${benchmark.id})`));
+      console.log(chalk3.gray(`  Test Cases: ${benchmark.testCaseIds.length}`));
+      console.log(chalk3.gray(`  Server: ${serverResult.baseUrl}`));
+      let agents = [];
+      if (options.agent.length === 0) {
+        const enabledAgent = config.agents.find((a) => a.enabled !== false);
+        if (!enabledAgent) {
+          console.error(chalk3.red("  Error: No enabled agents found in config."));
+          process.exit(1);
+        }
+        agents = [enabledAgent];
+        console.log(chalk3.gray(`  Agent: ${agents[0].name} (default)`));
+      } else {
+        for (const agentId of options.agent) {
+          const agent = findAgent2(agentId, config);
+          if (!agent) {
+            console.error(chalk3.red(`  Error: Agent not found: ${agentId}`));
+            console.log(chalk3.gray("  Available agents:"));
+            for (const a of config.agents) {
+              console.log(chalk3.gray(`    - ${a.name} (${a.key})`));
+            }
+            console.log("");
+            process.exit(1);
+          }
+          agents.push(agent);
+        }
+        console.log(chalk3.gray(`  Agents: ${agents.map((a) => a.name).join(", ")}`));
+      }
+      console.log("");
+      const allResults = [];
+      for (const agent of agents) {
+        const modelId = options.model || getDefaultModel2(agent);
+        const results = await runBenchmarkForAgent(
+          api,
+          agent,
+          modelId,
+          benchmark,
+          options.verbose || false
+        );
+        allResults.push(results);
+      }
+      if (options.output === "json") {
+        const jsonOutput = allResults.map((r) => ({
+          agent: { key: r.agent.key, name: r.agent.name },
+          runId: r.run?.id || r.runId,
+          passed: r.passed,
+          failed: r.failed,
+          passRate: benchmark.testCaseIds.length > 0 ? r.passed / benchmark.testCaseIds.length * 100 : 0,
+          results: r.run?.results
+        }));
+        console.log(JSON.stringify(jsonOutput, null, 2));
+      } else {
+        displaySummaryTable(allResults, benchmark.testCaseIds.length);
+      }
+      if (options.export) {
+        exportResults(benchmark, allResults, options.export);
+      }
+      console.log("");
+      console.log(chalk3.cyan("View results:"));
+      for (const result of allResults) {
+        const runId = result.run?.id || result.runId;
+        if (runId) {
+          console.log(chalk3.gray(`  ${result.agent.name}: ${serverResult.baseUrl}/benchmarks/${benchmark.id}/runs/${runId}`));
+        }
+      }
+      if (process.env.OPENSEARCH_DASHBOARDS_URL) {
+        console.log(chalk3.gray(`  OpenSearch Dashboards: ${process.env.OPENSEARCH_DASHBOARDS_URL}`));
+      }
+      if (serverResult.wasStarted && !shouldStopServer) {
+        console.log("");
+        console.log(chalk3.gray(`Server still running on port ${serverConfig.port}`));
+        console.log(chalk3.gray(`  Use --stop-server flag to stop after benchmark`));
+        console.log(chalk3.gray(`  Or manually: kill $(lsof -t -i:${serverConfig.port})`));
+      }
+    } finally {
+      cleanup();
+    }
+  });
+  return command;
+}
+
+// cli/commands/export.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import { writeFileSync as writeFileSync2 } from "fs";
+
+// lib/benchmarkExport.ts
+function generateExportFilename(benchmarkName) {
+  const sanitized = (benchmarkName || "benchmark-export").trim().toLowerCase().replace(/[^a-z0-9_\-\s]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return `${sanitized || "benchmark-export"}.json`;
+}
+
+// cli/commands/export.ts
+function createExportCommand() {
+  const command = new Command4("export").description("Export benchmark test cases as JSON").requiredOption("-b, --benchmark <id-or-name>", "Benchmark ID or name").option("-o, --output <file>", "Output file path (default: <benchmark-name>.json)").option("--stdout", "Write to stdout instead of file").action(async (options) => {
+    const config = await loadConfig();
+    const serverResult = await ensureServer(config.server);
+    const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+    try {
+      const client = new ApiClient(serverResult.baseUrl);
+      const benchmark = await client.findBenchmark(options.benchmark);
+      if (!benchmark) {
+        console.error(chalk4.red(`
+  Error: Benchmark not found: ${options.benchmark}
+`));
+        process.exit(1);
+      }
+      const exportData = await client.exportBenchmark(benchmark.id);
+      if (options.stdout) {
+        process.stdout.write(JSON.stringify(exportData, null, 2) + "\n");
+        return;
+      }
+      const outputFile = options.output || generateExportFilename(benchmark.name);
+      writeFileSync2(outputFile, JSON.stringify(exportData, null, 2) + "\n", "utf-8");
+      console.log(chalk4.green(`
+  Exported ${exportData.length} test case(s) to ${chalk4.bold(outputFile)}`));
+      console.log(chalk4.gray(`  Benchmark: ${benchmark.name} (${benchmark.id})
+`));
+    } catch (error) {
+      console.error(chalk4.red(`
+  Error: ${error.message}`));
+      console.log(chalk4.gray("  Is the server running? Start with: npm run dev:server\n"));
+      process.exit(1);
+    } finally {
+      cleanup();
+    }
+  });
+  return command;
+}
+
+// cli/commands/doctor.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+function checkConfigFile() {
+  const configInfo = getConfigFileInfo();
+  if (configInfo) {
+    return {
+      name: "Config File",
+      status: "ok",
+      message: `Found: ${configInfo.path.split("/").pop()}`,
+      details: [`Format: ${configInfo.format}`]
+    };
+  }
+  return {
+    name: "Config File",
+    status: "ok",
+    message: "Using defaults + environment variables",
+    details: [
+      "Config file is optional (for custom agents)",
+      "Run `agent-health init` to create one if needed"
+    ]
+  };
+}
+function checkEnvFile() {
+  const envPath = resolve2(process.cwd(), ".env");
+  if (existsSync3(envPath)) {
+    return {
+      name: "Environment File",
+      status: "ok",
+      message: "Found: .env"
+    };
+  }
+  return {
+    name: "Environment File",
+    status: "ok",
+    message: "Not using .env file",
+    details: ["Env vars can be set in shell, CI/CD, or via --env-file"]
+  };
+}
+function checkAWSCredentials() {
+  const profile = process.env.AWS_PROFILE;
+  const accessKey = process.env.AWS_ACCESS_KEY_ID;
+  const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+  const details = [];
+  if (profile) {
+    details.push(`AWS_PROFILE: ${profile}`);
+  }
+  if (accessKey) {
+    details.push(`AWS_ACCESS_KEY_ID: ${accessKey.substring(0, 8)}...`);
+  }
+  if (region) {
+    details.push(`AWS_REGION: ${region}`);
+  }
+  if (profile || accessKey) {
+    return {
+      name: "AWS Credentials",
+      status: "ok",
+      message: profile ? `Profile: ${profile}` : "Using access key",
+      details: details.length > 0 ? details : void 0
+    };
+  }
+  return {
+    name: "AWS Credentials",
+    status: "warning",
+    message: "No AWS credentials detected",
+    details: [
+      "Set AWS_PROFILE or AWS_ACCESS_KEY_ID for Bedrock judge",
+      "Claude Code connector also requires AWS credentials"
+    ]
+  };
+}
+async function checkClaudeCodeCLI() {
+  const { execSync: execSync2 } = await import("child_process");
+  try {
+    execSync2("which claude", { stdio: "pipe" });
+    return {
+      name: "Claude Code CLI",
+      status: "ok",
+      message: "claude command available"
+    };
+  } catch {
+    return {
+      name: "Claude Code CLI",
+      status: "warning",
+      message: "claude command not found",
+      details: [
+        "Install Claude Code: npm install -g @anthropic/claude-code",
+        "Or skip if not using claude-code connector"
+      ]
+    };
+  }
+}
+function checkAgents(config) {
+  const agents = config.agents;
+  const details = [];
+  for (const agent of agents) {
+    const connectorType = agent.connectorType || "agui-streaming";
+    const hasConnector = connectorRegistry.get(connectorType);
+    const status = hasConnector ? "\u2713" : "\u2717";
+    details.push(`${status} ${agent.name} (${connectorType})`);
+  }
+  return {
+    name: "Agents",
+    status: "ok",
+    message: `${agents.length} agents configured`,
+    details
+  };
+}
+function checkConnectors() {
+  const types = connectorRegistry.getRegisteredTypes();
+  return {
+    name: "Connectors",
+    status: "ok",
+    message: `${types.length} connectors registered`,
+    details: types.map((t) => `\u2713 ${t}`)
+  };
+}
+function checkOpenSearchStorage() {
+  const endpoint = process.env.OPENSEARCH_STORAGE_ENDPOINT;
+  const user = process.env.OPENSEARCH_STORAGE_USERNAME;
+  if (endpoint) {
+    return {
+      name: "OpenSearch Storage",
+      status: "ok",
+      message: `Configured: ${endpoint.substring(0, 50)}...`,
+      details: user ? [`Username: ${user}`] : void 0
+    };
+  }
+  return {
+    name: "OpenSearch Storage",
+    status: "warning",
+    message: "Not configured (results won't persist)",
+    details: [
+      "Set OPENSEARCH_STORAGE_ENDPOINT, _USERNAME, _PASSWORD to save results",
+      "Without storage, results are shown in terminal only"
+    ]
+  };
+}
+function checkOpenSearchObservability() {
+  const endpoint = process.env.OPENSEARCH_LOGS_ENDPOINT;
+  const user = process.env.OPENSEARCH_LOGS_USERNAME;
+  if (endpoint) {
+    return {
+      name: "OpenSearch Observability",
+      status: "ok",
+      message: `Configured: ${endpoint.substring(0, 50)}...`,
+      details: user ? [`Username: ${user}`] : void 0
+    };
+  }
+  return {
+    name: "OpenSearch Observability",
+    status: "ok",
+    message: "Not configured (optional)",
+    details: [
+      "Set OPENSEARCH_LOGS_ENDPOINT for agent traces",
+      "Only needed for ML-Commons agent observability"
+    ]
+  };
+}
+function displayResults(results) {
+  console.log(chalk5.bold("\n  Configuration Check\n"));
+  for (const result of results) {
+    const icon = {
+      ok: chalk5.green("\u2713"),
+      warning: chalk5.yellow("\u26A0"),
+      error: chalk5.red("\u2717")
+    }[result.status];
+    const messageColor = {
+      ok: chalk5.green,
+      warning: chalk5.yellow,
+      error: chalk5.red
+    }[result.status];
+    console.log(`  ${icon} ${chalk5.bold(result.name)}: ${messageColor(result.message)}`);
+    if (result.details) {
+      for (const detail of result.details) {
+        console.log(chalk5.gray(`      ${detail}`));
+      }
+    }
+  }
+  console.log("");
+  const errors = results.filter((r) => r.status === "error").length;
+  const warnings = results.filter((r) => r.status === "warning").length;
+  if (errors > 0) {
+    console.log(chalk5.red(`  ${errors} error(s) found. Fix these before running evaluations.
+`));
+  } else if (warnings > 0) {
+    console.log(chalk5.yellow(`  ${warnings} warning(s). Some features may be limited.
+`));
+  } else {
+    console.log(chalk5.green("  All checks passed!\n"));
+  }
+}
+function createDoctorCommand() {
+  const command = new Command5("doctor").description("Check configuration and system requirements").option("-o, --output <format>", "Output format: text, json", "text").action(async (options) => {
+    const results = [];
+    const config = await loadConfig();
+    for (const connector of config.connectors) {
+      connectorRegistry.register(connector);
+    }
+    results.push(checkConfigFile());
+    results.push(checkEnvFile());
+    results.push(checkAWSCredentials());
+    results.push(await checkClaudeCodeCLI());
+    results.push(checkAgents(config));
+    results.push(checkConnectors());
+    results.push(checkOpenSearchStorage());
+    results.push(checkOpenSearchObservability());
+    if (options.output === "json") {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      displayResults(results);
+    }
+  });
+  return command;
+}
+
+// cli/commands/init.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import { writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
+import { resolve as resolve3 } from "path";
+var TYPESCRIPT_CONFIG = `/*
+ * Agent Health Configuration
+ * See docs/CONFIGURATION.md for full options
+ */
+
+import { defineConfig, AGUIStreamingConnector, ClaudeCodeConnector } from '@opensearch-project/agent-health';
+
+export default defineConfig({
+  agents: [
+    // ML-Commons agent (AG-UI streaming)
+    {
+      name: 'ml-commons',
+      key: 'ml-commons',
+      connector: new AGUIStreamingConnector(),
+      endpoint: process.env.MLCOMMONS_ENDPOINT || 'https://localhost:9200/_plugins/_ml/agents/YOUR_AGENT_ID/_execute',
+      auth: {
+        type: 'basic',
+        username: process.env.OPENSEARCH_USER || 'admin',
+        password: process.env.OPENSEARCH_PASS || 'admin',
+      },
+      models: ['claude-sonnet'],
+    },
+
+    // Claude Code CLI agent (optional)
+    // Uncomment to enable Claude Code comparison
+    /*
+    {
+      name: 'claude-code',
+      key: 'claude-code',
+      connector: new ClaudeCodeConnector({
+        env: {
+          AWS_PROFILE: process.env.AWS_PROFILE || 'Bedrock',
+          CLAUDE_CODE_USE_BEDROCK: '1',
+          AWS_REGION: process.env.AWS_REGION || 'us-west-2',
+        },
+      }),
+      endpoint: 'claude', // Command name
+      models: ['claude-sonnet-4'],
+    },
+    */
+  ],
+
+  // Test cases can be inline or loaded from files
+  testCases: './test-cases/*.yaml',
+
+  // Output reporters
+  reporters: [
+    ['console'],
+    ['json', { output: 'report.json' }],
+  ],
+
+  // Judge configuration
+  judge: {
+    provider: 'bedrock',
+    model: 'claude-sonnet',
+    region: process.env.AWS_REGION || 'us-west-2',
+  },
+});
+`;
+var ENV_TEMPLATE = `# Agent Health Environment Configuration
+# Copy this to .env and fill in your values
+
+# ============ AWS Configuration ============
+# For Bedrock judge and Claude Code CLI
+AWS_PROFILE=Bedrock
+AWS_REGION=us-west-2
+# Or use explicit credentials:
+# AWS_ACCESS_KEY_ID=
+# AWS_SECRET_ACCESS_KEY=
+# AWS_SESSION_TOKEN=
+
+# ============ OpenSearch/ML-Commons ============
+# Agent endpoint
+MLCOMMONS_ENDPOINT=https://localhost:9200/_plugins/_ml/agents/YOUR_AGENT_ID/_execute
+
+# Storage cluster (for test cases, benchmarks persistence)
+OPENSEARCH_STORAGE_URL=https://localhost:9200
+OPENSEARCH_STORAGE_USER=admin
+OPENSEARCH_STORAGE_PASS=admin
+
+# Optional: Headers for ML-Commons agent data source access
+# MLCOMMONS_HEADER_OPENSEARCH_URL=
+# MLCOMMONS_HEADER_AUTHORIZATION=
+
+# ============ Server Configuration ============
+# Backend port (default: 4001)
+# BACKEND_PORT=4001
+`;
+var SAMPLE_TEST_CASE = `# Sample Test Case
+# Place in test-cases/ directory
+
+id: sample-rca-001
+name: Sample RCA Test Case
+version: 1
+
+labels:
+  - category:RCA
+  - difficulty:Medium
+
+initialPrompt: |
+  A customer reports that their web application is experiencing
+  slow response times. The issue started approximately 2 hours ago.
+  Please investigate and identify the root cause.
+
+context:
+  - description: Application logs
+    value: |
+      2024-01-15 10:00:00 ERROR: Connection timeout to database
+      2024-01-15 10:00:05 WARN: Retry attempt 1 for DB connection
+      2024-01-15 10:00:10 ERROR: Connection timeout to database
+
+expectedOutcomes:
+  - The agent should identify database connectivity issues
+  - The agent should check database server health
+  - The agent should suggest investigating network connectivity
+`;
+function createInitCommand() {
+  const command = new Command6("init").description("Initialize configuration files").option("--force", "Overwrite existing files").option("--with-examples", "Include example test case").action(async (options) => {
+    console.log(chalk6.bold("\n  Agent Health - Initialize Configuration\n"));
+    const cwd = process.cwd();
+    const files = [];
+    files.push({
+      path: resolve3(cwd, "agent-health.config.ts"),
+      content: TYPESCRIPT_CONFIG,
+      name: "agent-health.config.ts"
+    });
+    files.push({
+      path: resolve3(cwd, ".env.example"),
+      content: ENV_TEMPLATE,
+      name: ".env.example"
+    });
+    if (options.withExamples) {
+      const { mkdirSync } = await import("fs");
+      const testCasesDir = resolve3(cwd, "test-cases");
+      if (!existsSync4(testCasesDir)) {
+        mkdirSync(testCasesDir, { recursive: true });
+      }
+      files.push({
+        path: resolve3(testCasesDir, "sample-rca.yaml"),
+        content: SAMPLE_TEST_CASE,
+        name: "test-cases/sample-rca.yaml"
+      });
+    }
+    let created = 0;
+    let skipped = 0;
+    for (const file of files) {
+      if (existsSync4(file.path) && !options.force) {
+        console.log(chalk6.yellow(`  \u26A0 Skipped: ${file.name} (already exists, use --force to overwrite)`));
+        skipped++;
+      } else {
+        writeFileSync3(file.path, file.content);
+        console.log(chalk6.green(`  \u2713 Created: ${file.name}`));
+        created++;
+      }
+    }
+    console.log("");
+    if (created > 0) {
+      console.log(chalk6.gray("  Next steps:"));
+      console.log(chalk6.gray("    1. Copy .env.example to .env and fill in your values"));
+      console.log(chalk6.gray("    2. Update the config file with your agent endpoint"));
+      console.log(chalk6.gray("    3. Run `agent-health doctor` to verify configuration"));
+      console.log(chalk6.gray("    4. Run `agent-health run -t sample-rca-001` to test\n"));
+    }
+    if (skipped > 0) {
+      console.log(chalk6.yellow(`  ${skipped} file(s) skipped. Use --force to overwrite.
+`));
+    }
+  });
+  return command;
+}
+
+// cli/commands/migrate.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora3 from "ora";
+function computeStatsFromReports(run, reports) {
+  const reportsMap = new Map(reports.map((r) => [r.id, r]));
+  let passed = 0;
+  let failed = 0;
+  let pending = 0;
+  const total = Object.keys(run.results || {}).length;
+  Object.values(run.results || {}).forEach((result) => {
+    if (result.status === "pending" || result.status === "running") {
+      pending++;
+      return;
+    }
+    if (result.status === "failed" || result.status === "cancelled") {
+      failed++;
+      return;
+    }
+    if (result.status === "completed" && result.reportId) {
+      const report = reportsMap.get(result.reportId);
+      if (!report) {
+        pending++;
+        return;
+      }
+      if (report.metricsStatus === "pending" || report.metricsStatus === "calculating") {
+        pending++;
+        return;
+      }
+      if (report.passFailStatus === "passed") {
+        passed++;
+      } else {
+        failed++;
+      }
+    } else {
+      pending++;
+    }
+  });
+  return { passed, failed, pending, total };
+}
+function createMigrateCommand() {
+  const command = new Command7("migrate").description("One-time migration to add stats to existing benchmark runs").option("--dry-run", "Show what would be migrated without making changes").option("-v, --verbose", "Show detailed progress").action(async (options) => {
+    console.log(chalk7.cyan.bold("\n  Benchmark Stats Migration\n"));
+    const config = await loadConfig();
+    const serverResult = await ensureServer(config.server);
+    const cleanup = createServerCleanup(serverResult, config.server.reuseExistingServer === false);
+    try {
+      const client = new ApiClient(serverResult.baseUrl);
+      const spinner = ora3("Fetching benchmarks...").start();
+      const benchmarks = await client.listBenchmarks();
+      spinner.succeed(`Found ${benchmarks.length} benchmarks`);
+      const migratable = benchmarks.filter(
+        (b) => !b.id.startsWith("demo-") && (b.runs?.length ?? 0) > 0
+      );
+      if (migratable.length === 0) {
+        console.log(chalk7.yellow("\n  No benchmarks to migrate.\n"));
+        console.log(chalk7.gray("  Only user-created benchmarks with runs can be migrated."));
+        console.log(chalk7.gray("  Sample data (demo-*) already has stats computed.\n"));
+        return;
+      }
+      console.log(chalk7.gray(`
+  Migrating ${migratable.length} benchmarks with runs...
+`));
+      let totalRuns = 0;
+      let migratedRuns = 0;
+      let skippedRuns = 0;
+      let errors = 0;
+      for (const benchmark of migratable) {
+        const runs = benchmark.runs || [];
+        totalRuns += runs.length;
+        if (options.verbose) {
+          console.log(chalk7.gray(`  Processing: ${benchmark.name} (${runs.length} runs)`));
+        }
+        for (const run of runs) {
+          if (run.stats && typeof run.stats.passed === "number") {
+            skippedRuns++;
+            if (options.verbose) {
+              console.log(chalk7.gray(`    \u2713 ${run.name} - already has stats`));
+            }
+            continue;
+          }
+          try {
+            const reportsRes = await fetch(
+              `${serverResult.baseUrl}/api/storage/runs/by-benchmark-run/${benchmark.id}/${run.id}`
+            );
+            if (!reportsRes.ok) {
+              throw new Error(`Failed to fetch reports: ${reportsRes.status}`);
+            }
+            const { runs: reports } = await reportsRes.json();
+            const stats = computeStatsFromReports(run, reports || []);
+            if (options.verbose) {
+              console.log(chalk7.gray(
+                `    \u2192 ${run.name}: passed=${stats.passed}, failed=${stats.failed}, pending=${stats.pending}`
+              ));
+            }
+            if (!options.dryRun) {
+              const updateRes = await fetch(
+                `${serverResult.baseUrl}/api/storage/benchmarks/${benchmark.id}/runs/${run.id}/stats`,
+                {
+                  method: "PATCH",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify(stats)
+                }
+              );
+              if (!updateRes.ok) {
+                const errorBody = await updateRes.text();
+                throw new Error(`Failed to update stats: ${errorBody}`);
+              }
+            }
+            migratedRuns++;
+          } catch (error) {
+            errors++;
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            if (options.verbose) {
+              console.log(chalk7.red(`    \u2717 ${run.name} - ${msg}`));
+            }
+          }
+        }
+        console.log(
+          options.dryRun ? chalk7.blue(`  [DRY RUN] ${benchmark.name} - ${runs.length} runs would be processed`) : chalk7.green(`  \u2713 ${benchmark.name} - ${runs.length} runs`)
+        );
+      }
+      console.log(chalk7.bold("\n  Migration Summary\n"));
+      console.log(chalk7.gray(`    Total runs:    ${totalRuns}`));
+      console.log(chalk7.green(`    Migrated:      ${migratedRuns}`));
+      console.log(chalk7.yellow(`    Already done:  ${skippedRuns}`));
+      if (errors > 0) {
+        console.log(chalk7.red(`    Errors:        ${errors}`));
+      }
+      if (options.dryRun) {
+        console.log(chalk7.blue("\n  This was a dry run. No changes were made."));
+        console.log(chalk7.blue("  Run without --dry-run to apply changes.\n"));
+      } else {
+        console.log(chalk7.green("\n  Migration complete!\n"));
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk7.red(`
+  Error: ${msg}
+`));
+      process.exit(1);
+    } finally {
+      cleanup();
+    }
+  });
+  return command;
+}
+
+// cli/index.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname3(__filename3);
+var packageJsonPath2 = join4(__dirname3, "..", "..", "package.json");
+var version = "0.1.0";
+try {
+  const packageJson = JSON.parse(readFileSync3(packageJsonPath2, "utf-8"));
+  version = packageJson.version;
+} catch {
+}
+function loadEnvFile(envPath) {
+  const absolutePath = resolve4(process.cwd(), envPath);
+  if (!existsSync5(absolutePath)) {
+    console.error(chalk8.red(`
+  Error: Environment file not found: ${absolutePath}
+`));
+    process.exit(1);
+  }
+  const result = loadDotenv({ path: absolutePath });
+  if (result.error) {
+    console.error(chalk8.red(`
+  Error loading environment file: ${result.error.message}
+`));
+    process.exit(1);
+  }
+  console.log(chalk8.gray(`  Loaded environment from: ${envPath}`));
+}
+var defaultEnvPath = resolve4(process.cwd(), ".env");
+if (existsSync5(defaultEnvPath)) {
+  loadDotenv({ path: defaultEnvPath });
+}
+var program = new Command8();
+program.name("agent-health").description("Agent Health Evaluation Framework - Evaluate and monitor AI agent performance").version(version).enablePositionalOptions().passThroughOptions();
+program.option("-p, --port <number>", "Server port", "4001").option("-e, --env-file <path>", "Load environment variables from file (e.g., .env)").option("--no-browser", "Do not open browser automatically");
+program.action(async (options) => {
+  console.log(chalk8.cyan.bold(`
+  Agent Health v${version} - AI Agent Evaluation Framework
+`));
+  console.log(chalk8.gray(`  Working directory: ${process.cwd()}`));
+  console.log(chalk8.gray(`  Package directory: ${__dirname3}`));
+  if (options.envFile) {
+    loadEnvFile(options.envFile);
+  } else if (existsSync5(defaultEnvPath)) {
+    console.log(chalk8.gray("  Auto-loaded .env from current directory"));
+  }
+  const port = parseInt(options.port, 10);
+  const spinner = ora4("Starting server...").start();
+  try {
+    await startServer({ port });
+    spinner.succeed("Server started");
+    console.log(chalk8.gray("\n  Configuration:"));
+    console.log(chalk8.gray(`    Storage: Sample data (configure OpenSearch for persistence)`));
+    console.log(chalk8.gray(`    Agent: Select in UI (Demo Agent for mock, real agents require endpoints)`));
+    console.log(chalk8.gray(`    Judge: Select in UI (Demo Judge for mock, Bedrock requires AWS creds)
+`));
+    const url = `http://localhost:${port}`;
+    console.log(chalk8.green(`  Server running at ${chalk8.bold(url)}
+`));
+    if (options.browser !== false) {
+      console.log(chalk8.gray("  Opening browser..."));
+      await open(url);
+    }
+    console.log(chalk8.gray("  Press Ctrl+C to stop\n"));
+  } catch (error) {
+    spinner.fail("Failed to start server");
+    console.error(chalk8.red(`
+  Error: ${error instanceof Error ? error.message : error}
+`));
+    process.exit(1);
+  }
+});
+program.addCommand(createListCommand());
+program.addCommand(createRunCommand());
+program.addCommand(createBenchmarkCommand());
+program.addCommand(createExportCommand());
+program.addCommand(createDoctorCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createMigrateCommand());
+program.command("serve").description("Start the Agent Health server (same as default action)").option("-p, --port <number>", "Server port", "4001").option("--no-browser", "Do not open browser automatically").action(async (options) => {
+  console.log(chalk8.cyan.bold(`
+  Agent Health v${version} - AI Agent Evaluation Framework
+`));
+  const port = parseInt(options.port, 10);
+  const spinner = ora4("Starting server...").start();
+  try {
+    await startServer({ port });
+    spinner.succeed("Server started");
+    const url = `http://localhost:${port}`;
+    console.log(chalk8.green(`  Server running at ${chalk8.bold(url)}
+`));
+    if (options.browser !== false) {
+      console.log(chalk8.gray("  Opening browser..."));
+      await open(url);
+    }
+    console.log(chalk8.gray("  Press Ctrl+C to stop\n"));
+  } catch (error) {
+    spinner.fail("Failed to start server");
+    console.error(chalk8.red(`
+  Error: ${error instanceof Error ? error.message : error}
+`));
+    process.exit(1);
+  }
+});
+program.on("command:*", (operands) => {
+  const unknownCommand = operands[0];
+  const availableCommands = program.commands.map((cmd) => cmd.name());
+  console.error(chalk8.red(`
+  Error: Unknown command '${unknownCommand}'`));
+  console.log("");
+  console.log(chalk8.cyan("  Available commands:"));
+  for (const cmd of availableCommands) {
+    console.log(chalk8.gray(`    - ${cmd}`));
+  }
+  console.log("");
+  console.log(chalk8.gray(`  Run ${chalk8.cyan("agent-health --help")} for usage information.
+`));
+  process.exitCode = 1;
+});
+program.parse();