@kirrosh/zond 0.14.0 → 0.17.0

package/src/mcp/tools/manage-server.ts

@@ -1,86 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-let serverInstance: ReturnType<typeof Bun.serve> | null = null;
-let serverPort: number = 0;
-
-export function registerManageServerTool(server: McpServer, dbPath?: string) {
-  server.registerTool("manage_server", {
-    description: TOOL_DESCRIPTIONS.manage_server,
-    inputSchema: {
-      action: z.enum(["start", "stop", "restart", "status"]).describe("Action to perform"),
-      port: z.optional(z.number().int().min(1).max(65535)).describe("Port number (default: 8080, only for start/restart)"),
-    },
-  }, async ({ action, port }) => {
-    const targetPort = port ?? 8080;
-
-    switch (action) {
-      case "start": {
-        if (serverInstance) {
-          return result({ running: true, port: serverPort, url: `http://localhost:${serverPort}`, message: "Server already running" });
-        }
-        return await startServer(targetPort, dbPath);
-      }
-
-      case "stop": {
-        if (!serverInstance) {
-          return result({ running: false, message: "Server is not running" });
-        }
-        serverInstance.stop();
-        serverInstance = null;
-        const stoppedPort = serverPort;
-        serverPort = 0;
-        return result({ running: false, message: `Server stopped (was on port ${stoppedPort})` });
-      }
-
-      case "restart": {
-        if (serverInstance) {
-          serverInstance.stop();
-          serverInstance = null;
-          serverPort = 0;
-        }
-        return await startServer(targetPort, dbPath);
-      }
-
-      case "status": {
-        if (serverInstance) {
-          return result({ running: true, port: serverPort, url: `http://localhost:${serverPort}` });
-        }
-        return result({ running: false });
-      }
-    }
-  });
-}
-
-async function startServer(port: number, dbPath?: string) {
-  try {
-    const { getDb } = await import("../../db/schema.ts");
-    const { createApp } = await import("../../web/server.ts");
-
-    getDb(dbPath);
-    const app = createApp();
-
-    serverInstance = Bun.serve({
-      fetch: app.fetch,
-      port,
-      hostname: "0.0.0.0",
-    });
-    serverPort = port;
-
-    return result({ running: true, port, url: `http://localhost:${port}`, message: "Server started" });
-  } catch (err) {
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify({
-        running: false,
-        error: (err as Error).message,
-      }, null, 2) }],
-      isError: true,
-    };
-  }
-}
-
-function result(data: Record<string, unknown>) {
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-  };
-}

package/src/mcp/tools/query-db.ts

@@ -1,300 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { getDb } from "../../db/schema.ts";
-import { listCollections, listRuns, getRunById, getResultsByRunId, getCollectionById } from "../../db/queries.ts";
-import { join } from "node:path";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-import { statusHint, classifyFailure, envHint, envCategory, schemaHint } from "../../core/diagnostics/failure-hints.ts";
-
-function truncateErrorMessage(raw: string | null | undefined, verbose?: boolean): string | undefined {
-  if (!raw) return undefined;
-  if (verbose || raw.length < 500) return raw;
-  const lines = raw.split(/\r?\n/);
-  // First line is the error message itself
-  const msgLines = [lines[0]!];
-  // Grab up to 3 stack-trace lines (indented or starting with "at ")
-  let traceCount = 0;
-  for (let i = 1; i < lines.length && traceCount < 3; i++) {
-    const line = lines[i]!;
-    if (/^\s+/.test(line) || /^\s*at\s/.test(line)) {
-      msgLines.push(line);
-      traceCount++;
-    }
-  }
-  const remaining = lines.length - msgLines.length;
-  if (remaining > 0) {
-    msgLines.push(`...[truncated ${remaining} lines]`);
-  }
-  return msgLines.join("\n");
-}
-
-function parseBodySafe(raw: string | null | undefined): unknown {
-  if (!raw) return undefined;
-  const truncated = raw.length > 2000 ? raw.slice(0, 2000) + "…[truncated]" : raw;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return truncated;
-  }
-}
-
-const USEFUL_HEADERS = new Set([
-  "content-type", "content-length", "location", "retry-after",
-  "www-authenticate", "allow",
-]);
-const USEFUL_PREFIXES = ["x-", "ratelimit"];
-
-function filterHeaders(raw: string | null | undefined): Record<string, string> | undefined {
-  if (!raw) return undefined;
-  try {
-    const h = JSON.parse(raw) as Record<string, string>;
-    const out: Record<string, string> = {};
-    for (const [k, v] of Object.entries(h)) {
-      const l = k.toLowerCase();
-      if (USEFUL_HEADERS.has(l) || USEFUL_PREFIXES.some(p => l.startsWith(p))) {
-        out[k] = v;
-      }
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-  } catch { return undefined; }
-}
-
-export function registerQueryDbTool(server: McpServer, dbPath?: string) {
-  server.registerTool("query_db", {
-    description: TOOL_DESCRIPTIONS.query_db,
-    inputSchema: {
-      action: z.enum(["list_collections", "list_runs", "get_run_results", "diagnose_failure", "compare_runs"])
-        .describe("Query action to perform"),
-      runId: z.optional(z.number().int())
-        .describe("Run ID (required for get_run_results and diagnose_failure)"),
-      runIdB: z.optional(z.number().int())
-        .describe("Second run ID (required for compare_runs — this is the newer run)"),
-      limit: z.optional(z.number().int().min(1).max(100))
-        .describe("Max number of runs to return (default: 20, only for list_runs)"),
-      verbose: z.optional(z.boolean())
-        .describe("Show full error messages and stack traces (default: false, truncates long traces)"),
-    },
-  }, async ({ action, runId, runIdB, limit, verbose }) => {
-    try {
-      getDb(dbPath);
-
-      switch (action) {
-        case "list_collections": {
-          const collections = listCollections();
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(collections, null, 2) }],
-          };
-        }
-
-        case "list_runs": {
-          const runs = listRuns(limit ?? 20);
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(runs, null, 2) }],
-          };
-        }
-
-        case "get_run_results": {
-          if (runId == null) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: "runId is required for get_run_results" }, null, 2) }],
-              isError: true,
-            };
-          }
-          const run = getRunById(runId);
-          if (!run) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${runId} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-          const results = getResultsByRunId(runId);
-          const detail = {
-            run: {
-              id: run.id,
-              started_at: run.started_at,
-              finished_at: run.finished_at,
-              total: run.total,
-              passed: run.passed,
-              failed: run.failed,
-              skipped: run.skipped,
-              trigger: run.trigger,
-              environment: run.environment,
-              duration_ms: run.duration_ms,
-            },
-            results: results.map(r => ({
-              suite_name: r.suite_name,
-              test_name: r.test_name,
-              status: r.status,
-              duration_ms: r.duration_ms,
-              request_method: r.request_method,
-              request_url: r.request_url,
-              response_status: r.response_status,
-              error_message: truncateErrorMessage(r.error_message, verbose),
-              assertions: r.assertions,
-            })),
-          };
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(detail, null, 2) }],
-          };
-        }
-
-        case "diagnose_failure": {
-          if (runId == null) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: "runId is required for diagnose_failure" }, null, 2) }],
-              isError: true,
-            };
-          }
-          const diagRun = getRunById(runId);
-          if (!diagRun) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${runId} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-
-          // Resolve env file path from collection for actionable hints
-          let envFilePath: string | undefined;
-          if (diagRun.collection_id) {
-            const collection = getCollectionById(diagRun.collection_id);
-            if (collection?.base_dir) {
-              envFilePath = join(collection.base_dir, ".env.yaml").replace(/\\/g, "/");
-            }
-          }
-
-          const allResults = getResultsByRunId(runId);
-          const failures = allResults
-            .filter(r => r.status === "fail" || r.status === "error")
-            .map(r => {
-              // env issues take priority over generic status hints
-              const hint = envHint(r.request_url, r.error_message, envFilePath) ?? statusHint(r.response_status);
-              const failure_type = classifyFailure(r.status, r.response_status);
-              const sHint = schemaHint(failure_type, r.response_status);
-              return {
-                suite_name: r.suite_name,
-                test_name: r.test_name,
-                status: r.status,
-                failure_type,
-                error_message: truncateErrorMessage(r.error_message, verbose),
-                request_method: r.request_method,
-                request_url: r.request_url,
-                response_status: r.response_status,
-                ...(hint ? { hint } : {}),
-                ...(sHint ? { schema_hint: sHint } : {}),
-                response_body: parseBodySafe(r.response_body),
-                response_headers: filterHeaders(r.response_headers),
-                assertions: r.assertions,
-                duration_ms: r.duration_ms,
-              };
-            });
-
-          // Top-level env_issue when all failures have the same env problem category
-          const categories = new Set(failures.map(f => envCategory(f.hint)).filter(Boolean));
-          const sharedEnvHint = categories.size === 1
-            ? categories.has("base_url_missing")
-              ? `All failures: base_url is not set — add base_url to ${envFilePath ?? ".env.yaml"}`
-              : categories.has("unresolved_variable")
-              ? `All failures: some variables are not substituted — check variable names in ${envFilePath ?? ".env.yaml"}`
-              : [...failures.map(f => f.hint).filter(Boolean)][0]
-            : undefined;
-
-          const apiErrors = failures.filter(f => f.failure_type === "api_error").length;
-          const assertionFailures = failures.filter(f => f.failure_type === "assertion_failed").length;
-          const networkErrors = failures.filter(f => f.failure_type === "network_error").length;
-
-          const result = {
-            run: {
-              id: diagRun.id,
-              started_at: diagRun.started_at,
-              environment: diagRun.environment,
-              duration_ms: diagRun.duration_ms,
-            },
-            summary: {
-              total: diagRun.total,
-              passed: diagRun.passed,
-              failed: diagRun.failed,
-              api_errors: apiErrors,
-              assertion_failures: assertionFailures,
-              network_errors: networkErrors,
-            },
-            ...(sharedEnvHint ? { env_issue: sharedEnvHint } : {}),
-            failures,
-          };
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-          };
-        }
-
-        case "compare_runs": {
-          if (runId == null || runIdB == null) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: "Both runId (run A) and runIdB (run B) are required for compare_runs" }, null, 2) }],
-              isError: true,
-            };
-          }
-          const runARecord = getRunById(runId);
-          const runBRecord = getRunById(runIdB);
-          if (!runARecord) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run #${runId} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-          if (!runBRecord) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run #${runIdB} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-
-          const resultsA = getResultsByRunId(runId);
-          const resultsB = getResultsByRunId(runIdB);
-
-          const mapA = new Map<string, string>();
-          const mapB = new Map<string, string>();
-          for (const r of resultsA) mapA.set(`${r.suite_name}::${r.test_name}`, r.status);
-          for (const r of resultsB) mapB.set(`${r.suite_name}::${r.test_name}`, r.status);
-
-          const regressions: Array<{ suite: string; test: string; before: string; after: string }> = [];
-          const fixes: Array<{ suite: string; test: string; before: string; after: string }> = [];
-          let unchanged = 0;
-          let newTests = 0;
-          let removedTests = 0;
-
-          for (const [key, statusB] of mapB) {
-            const statusA = mapA.get(key);
-            if (statusA === undefined) { newTests++; continue; }
-            const [suite, test] = key.split("::") as [string, string];
-            const wasPass = statusA === "pass";
-            const isPass = statusB === "pass";
-            const wasFail = statusA === "fail" || statusA === "error";
-            const isFail = statusB === "fail" || statusB === "error";
-            if (wasPass && isFail) regressions.push({ suite, test, before: statusA, after: statusB });
-            else if (wasFail && isPass) fixes.push({ suite, test, before: statusA, after: statusB });
-            else unchanged++;
-          }
-          for (const key of mapA.keys()) {
-            if (!mapB.has(key)) removedTests++;
-          }
-
-          const compareResult = {
-            runA: { id: runId, started_at: runARecord.started_at },
-            runB: { id: runIdB, started_at: runBRecord.started_at },
-            summary: { regressions: regressions.length, fixes: fixes.length, unchanged, newTests, removedTests },
-            regressions,
-            fixes,
-            hasRegressions: regressions.length > 0,
-          };
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(compareResult, null, 2) }],
-          };
-        }
-      }
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

package/src/mcp/tools/run-tests.ts

@@ -1,115 +0,0 @@
-import { z } from "zod";
-import { resolve } from "node:path";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { executeRun } from "../../core/runner/execute-run.ts";
-import { getDb } from "../../db/schema.ts";
-import { getResultsByRunId, findCollectionByTestPath } from "../../db/queries.ts";
-import { readOpenApiSpec, extractEndpoints, scanCoveredEndpoints, filterUncoveredEndpoints } from "../../core/generator/index.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerRunTestsTool(server: McpServer, dbPath?: string) {
-  server.registerTool("run_tests", {
-    description: TOOL_DESCRIPTIONS.run_tests,
-    inputSchema: {
-      testPath: z.string().describe("Path to test YAML file or directory"),
-      envName: z.optional(z.string()).describe("Environment name (loads .env.<name>.yaml)"),
-      safe: z.optional(z.boolean()).describe("Run only GET tests (read-only, safe mode)"),
-      tag: z.optional(z.array(z.string())).describe("Filter suites by tag (OR logic)"),
-      envVars: z.optional(z.record(z.string(), z.string())).describe("Environment variables to inject (override env file, e.g. {\"TOKEN\": \"xxx\"})"),
-      dryRun: z.optional(z.boolean()).describe("Show requests without sending them (always exits 0)"),
-      rerunFrom: z.optional(z.number().int()).describe("Re-run only tests that failed/errored in this run ID"),
-    },
-  }, async ({ testPath, envName, safe, tag, envVars, dryRun, rerunFrom }) => {
-    // Build filter from previous failed run
-    let rerunFilter: Set<string> | undefined;
-    if (rerunFrom != null) {
-      getDb(dbPath);
-      const prevResults = getResultsByRunId(rerunFrom);
-      const failed = prevResults.filter(r => r.status === "fail" || r.status === "error");
-      if (failed.length === 0) {
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${rerunFrom} has no failures to rerun` }, null, 2) }],
-          isError: true,
-        };
-      }
-      rerunFilter = new Set(failed.map(r => `${r.suite_name}::${r.test_name}`));
-    }
-
-    const { runId, results } = await executeRun({
-      testPath,
-      envName,
-      trigger: "mcp",
-      dbPath,
-      safe,
-      tag,
-      envVars,
-      dryRun,
-      rerunFilter,
-    });
-
-    const total = results.reduce((s, r) => s + r.total, 0);
-    const passed = results.reduce((s, r) => s + r.passed, 0);
-    const failed = results.reduce((s, r) => s + r.failed, 0);
-    const skipped = results.reduce((s, r) => s + r.skipped, 0);
-
-    const failedSteps = results.flatMap(r =>
-      r.steps.filter(s => s.status === "fail" || s.status === "error").map(s => ({
-        suite: r.suite_name,
-        test: s.name,
-        status: s.status,
-        error: s.error,
-        assertions: s.assertions.filter(a => !a.passed).map(a => ({
-          field: a.field,
-          expected: a.expected,
-          actual: a.actual,
-        })),
-      }))
-    );
-
-    // Best-effort coverage calculation
-    let coverage: { covered: number; total: number; percentage: number } | undefined;
-    try {
-      const resolvedPath = resolve(testPath);
-      const collection = findCollectionByTestPath(resolvedPath);
-      if (collection?.openapi_spec) {
-        const doc = await readOpenApiSpec(collection.openapi_spec);
-        const allEndpoints = extractEndpoints(doc);
-        const coveredEps = await scanCoveredEndpoints(collection.test_path);
-        const uncovered = filterUncoveredEndpoints(allEndpoints, coveredEps);
-        const coveredCount = allEndpoints.length - uncovered.length;
-        coverage = {
-          covered: coveredCount,
-          total: allEndpoints.length,
-          percentage: allEndpoints.length > 0 ? Math.round((coveredCount / allEndpoints.length) * 100) : 100,
-        };
-      }
-    } catch { /* coverage is best-effort, don't fail run */ }
-
-    const hints: string[] = [];
-    if (failedSteps.length > 0) {
-      hints.push("Use query_db(action: 'diagnose_failure', runId: " + runId + ") for detailed failure analysis");
-      const hasAssertionFailures = failedSteps.some(s => s.assertions.length > 0);
-      if (hasAssertionFailures) {
-        hints.push(
-          "Some tests have assertion failures — use describe_endpoint(specPath, method, path) to verify expected schemas"
-        );
-      }
-    }
-    const summary = {
-      runId,
-      total,
-      passed,
-      failed,
-      skipped,
-      suites: results.length,
-      status: failed === 0 ? "all_passed" : "has_failures",
-      ...(failedSteps.length > 0 ? { failures: failedSteps } : {}),
-      ...(coverage ? { coverage } : {}),
-      hints,
-    };
-
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify(summary, null, 2) }],
-    };
-  });
-}