@kirrosh/zond 0.16.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,84 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-import { getCollections, getRuns, getRunDetail, diagnoseRun, compareRuns } from "../../core/diagnostics/db-analysis.ts";
-
-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 {
-      switch (action) {
-        case "list_collections": {
-          const collections = getCollections(dbPath);
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(collections, null, 2) }],
-          };
-        }
-
-        case "list_runs": {
-          const runs = getRuns(limit ?? 20, dbPath);
-          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 detail = getRunDetail(runId, verbose, dbPath);
-          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 result = diagnoseRun(runId, verbose, dbPath);
-          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 compareResult = compareRuns(runId, runIdB, dbPath);
-          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,116 +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,
-        ...(r.suite_file ? { file: r.suite_file } : {}),
-        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) }],
-    };
-  });
-}

package/src/mcp/tools/send-request.ts

@@ -1,51 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { sendAdHocRequest } from "../../core/runner/send-request.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerSendRequestTool(server: McpServer, dbPath?: string) {
-  server.registerTool("send_request", {
-    description: TOOL_DESCRIPTIONS.send_request,
-    inputSchema: {
-      method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
-      url: z.string().describe("Request URL (supports {{variable}} interpolation)"),
-      headers: z.optional(z.string()).describe("Request headers as JSON string (e.g. '{\"Content-Type\": \"application/json\"}')"),
-      body: z.optional(z.string()).describe("Request body (JSON string)"),
-      timeout: z.optional(z.number().int().positive()).describe("Request timeout in ms"),
-      envName: z.optional(z.string()).describe("Environment name for variable interpolation"),
-      collectionName: z.optional(z.string()).describe("Collection name to load env from its base_dir (e.g. 'petstore'). Required for {{variable}} interpolation."),
-      jsonPath: z.optional(z.string()).describe("Simple dot-notation path to extract from response body (e.g. '[0].code', 'data.items', 'id'). Supports array indices."),
-      maxResponseChars: z.optional(z.number().int().positive()).describe("Truncate response body to this many characters"),
-    },
-  }, async ({ method, url, headers, body, timeout, envName, collectionName, jsonPath, maxResponseChars }) => {
-    try {
-      const parsedHeaders = headers ? JSON.parse(headers) as Record<string, string> : undefined;
-
-      const result = await sendAdHocRequest({
-        method,
-        url,
-        headers: parsedHeaders,
-        body: body ?? undefined,
-        timeout,
-        envName,
-        collectionName,
-        jsonPath,
-        dbPath,
-      });
-
-      let text = JSON.stringify(result, null, 2);
-      if (maxResponseChars && text.length > maxResponseChars) {
-        text = text.slice(0, maxResponseChars) + '\n\u2026[truncated]';
-      }
-
-      return {
-        content: [{ type: "text" as const, text }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

package/src/mcp/tools/setup-api.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { setupApi } from "../../core/setup-api.ts";
-import { resetDb } from "../../db/schema.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-function findProjectRoot(fromPath: string): string | null {
-  let current = existsSync(fromPath) ? fromPath : dirname(fromPath);
-  while (true) {
-    if (existsSync(join(current, ".git")) || existsSync(join(current, "package.json"))) {
-      return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-export function registerSetupApiTool(server: McpServer, dbPath?: string) {
-  server.registerTool("setup_api", {
-    description: TOOL_DESCRIPTIONS.setup_api,
-    inputSchema: {
-      name: z.optional(z.string()).describe("API name (auto-detected from spec title if omitted)"),
-      specPath: z.optional(z.string()).describe("Path or URL to OpenAPI spec"),
-      dir: z.optional(z.string()).describe("Base directory (default: ./apis/<name>/)"),
-      envVars: z.optional(z.string()).describe("Environment variables as JSON string (e.g. '{\"base_url\": \"...\", \"token\": \"...\"}')"),
-      force: z.optional(z.boolean()).describe("If true, delete existing API with same name and recreate from scratch"),
-      insecure: z.optional(z.boolean()).describe("Skip TLS certificate verification when fetching spec over HTTPS (for self-signed certs)"),
-    },
-  }, async ({ name, specPath, dir, envVars, force, insecure }) => {
-    try {
-      let parsedEnvVars: Record<string, string> | undefined;
-      if (envVars) {
-        try {
-          parsedEnvVars = JSON.parse(envVars);
-        } catch {
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify({ error: "envVars must be a valid JSON string" }, null, 2) }],
-            isError: true,
-          };
-        }
-      }
-
-      // Auto-chdir to project root when dir is an absolute path
-      if (dir && isAbsolute(resolve(dir))) {
-        const resolvedDir = resolve(dir);
-        const root = findProjectRoot(resolvedDir);
-        if (root && root !== process.cwd()) {
-          process.chdir(root);
-          resetDb();
-        }
-      }
-
-      const result = await setupApi({
-        name,
-        spec: specPath,
-        dir,
-        envVars: parsedEnvVars,
-        dbPath,
-        force,
-        insecure,
-      });
-
-      const envFilePath = join(result.baseDir, ".env.yaml");
-      const warningSteps = result.warnings?.map(w => `WARNING: ${w}`) ?? [];
-      const response = {
-        ...result,
-        nextSteps: [
-          ...warningSteps,
-          `Edit ${envFilePath} to add credentials (auth_token, api_key, base_url, etc.)`,
-          `File is already git-ignored via .gitignore`,
-          `Then run: run_tests(testPath: "${result.testPath}")`,
-        ],
-      };
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}