@kirrosh/zond 0.14.0 → 0.17.0

package/src/mcp/tools/save-test-suite.ts

@@ -1,218 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { validateSuite } from "../../core/parser/schema.ts";
-import { join, dirname } from "node:path";
-import { existsSync, mkdirSync } from "node:fs";
-import YAML from "yaml";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export interface SaveResult {
-  saved: boolean;
-  filePath?: string;
-  suite?: { name: unknown; tests: number; base_url: unknown };
-  hint?: string;
-  coverage?: Record<string, unknown>;
-  error?: string;
-  detected?: string[];
-}
-
-export async function validateAndSave(
-  filePath: string,
-  content: string,
-  overwrite: boolean | undefined,
-  dbPath?: string,
-): Promise<{ result: SaveResult; isError: boolean }> {
-  // Parse YAML
-  let parsed: unknown;
-  try {
-    parsed = YAML.parse(content);
-  } catch (err) {
-    return {
-      result: {
-        saved: false,
-        error: `YAML parse error: ${(err as Error).message}`,
-        hint: "Check YAML syntax — indentation, colons, and quoting",
-      },
-      isError: true,
-    };
-  }
-
-  // Validate against test suite schema
-  try {
-    validateSuite(parsed);
-  } catch (err) {
-    const message = (err as Error).message;
-    let hint = "Check the test suite structure matches the expected format";
-    if (message.includes("status")) {
-      hint = "Status codes must be numbers, not strings (e.g. status: 200, not status: \"200\")";
-    } else if (message.includes("exists")) {
-      hint = "exists must be boolean true/false, not string \"true\"/\"false\"";
-    } else if (message.includes("tests")) {
-      hint = "Suite must have a 'tests' array with at least one test step";
-    }
-    return {
-      result: { saved: false, error: `Validation: ${message}`, hint },
-      isError: true,
-    };
-  }
-
-  // Detect hardcoded credentials — long opaque strings in auth headers
-  const credentialPattern = /Authorization\s*:\s*["']?(Basic|Bearer)\s+([A-Za-z0-9+/=_\-]{20,})["']?/g;
-  const credMatches = [...content.matchAll(credentialPattern)];
-  const suspiciousCredentials = credMatches.filter(m => {
-    const value = m[2]!;
-    return !value.startsWith("{{") && !value.endsWith("}}");
-  });
-  if (suspiciousCredentials.length > 0) {
-    return {
-      result: {
-        saved: false,
-        error: "Hardcoded credentials detected in Authorization header(s)",
-        hint: "Never put literal API keys or tokens in YAML files. Store them in the .env.yaml file in the API directory and reference as {{api_key}} in headers.",
-        detected: suspiciousCredentials.map(m => `${m[1]} <redacted>`),
-      },
-      isError: true,
-    };
-  }
-
-  // Resolve path
-  const resolvedPath = filePath.startsWith("/") || /^[a-zA-Z]:/.test(filePath)
-    ? filePath
-    : join(process.cwd(), filePath);
-
-  // Check existing file
-  if (!overwrite && existsSync(resolvedPath)) {
-    return {
-      result: {
-        saved: false,
-        error: `File already exists: ${resolvedPath}`,
-        hint: "Use overwrite: true to replace the existing file",
-      },
-      isError: true,
-    };
-  }
-
-  // Create directories
-  const dir = dirname(resolvedPath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  // Write original YAML content (preserve formatting/comments)
-  await Bun.write(resolvedPath, content);
-
-  // Extract summary info
-  const suite = parsed as Record<string, unknown>;
-  const tests = (suite.tests as unknown[]) ?? [];
-
-  const result: SaveResult = {
-    saved: true,
-    filePath: resolvedPath,
-    suite: {
-      name: suite.name,
-      tests: tests.length,
-      base_url: suite.base_url ?? null,
-    },
-    hint: "After tests are ready, ask the user if they want to set up CI/CD with ci_init to run tests automatically on push.",
-  };
-
-  // Attempt to compute coverage hint
-  try {
-    const testDir = dirname(resolvedPath);
-    const { findCollectionByTestPath } = await import("../../db/queries.ts");
-    const { getDb } = await import("../../db/schema.ts");
-    getDb(dbPath);
-    const collection = findCollectionByTestPath(testDir);
-    if (collection?.openapi_spec) {
-      const { readOpenApiSpec, extractEndpoints } = await import("../../core/generator/openapi-reader.ts");
-      const { scanCoveredEndpoints, filterUncoveredEndpoints } = await import("../../core/generator/coverage-scanner.ts");
-
-      const doc = await readOpenApiSpec(collection.openapi_spec);
-      const allEndpoints = extractEndpoints(doc);
-      const covered = await scanCoveredEndpoints(testDir);
-      const uncovered = filterUncoveredEndpoints(allEndpoints, covered);
-
-      const total = allEndpoints.length;
-      const coveredCount = total - uncovered.length;
-      const percentage = total > 0 ? Math.round((coveredCount / total) * 100) : 0;
-
-      const coverage: Record<string, unknown> = { percentage, covered: coveredCount, total, uncoveredCount: uncovered.length };
-      if (percentage < 80 && uncovered.length > 0) {
-        coverage.suggestion = `Use generate_and_save with testsDir to cover ${uncovered.length} remaining endpoint${uncovered.length > 1 ? "s" : ""}`;
-      }
-      result.coverage = coverage;
-    }
-  } catch { /* silently skip coverage if unavailable */ }
-
-  return { result, isError: false };
-}
-
-export function registerSaveTestSuiteTool(server: McpServer, dbPath?: string) {
-  server.registerTool("save_test_suite", {
-    description: TOOL_DESCRIPTIONS.save_test_suite,
-    inputSchema: {
-      filePath: z.string().describe("Path for saving the YAML test file (e.g. apis/petstore/tests/pets-crud.yaml)"),
-      content: z.string().describe("YAML content of the test suite"),
-      overwrite: z.optional(z.boolean()).describe("Overwrite existing file (default: false)"),
-    },
-  }, async ({ filePath, content, overwrite }) => {
-    try {
-      const { result, isError } = await validateAndSave(filePath, content, overwrite, dbPath);
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-        ...(isError ? { isError: true } : {}),
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({
-          saved: false,
-          error: (err as Error).message,
-        }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}
-
-export function registerSaveTestSuitesTool(server: McpServer, dbPath?: string) {
-  server.registerTool("save_test_suites", {
-    description: TOOL_DESCRIPTIONS.save_test_suites,
-    inputSchema: {
-      files: z.array(z.object({
-        filePath: z.string().describe("Path for saving the YAML test file"),
-        content: z.string().describe("YAML content of the test suite"),
-      })).describe("Array of files to save"),
-      overwrite: z.optional(z.boolean()).describe("Overwrite existing files (default: false)"),
-    },
-  }, async ({ files, overwrite }) => {
-    try {
-      const results: Array<SaveResult & { filePath: string; inputPath: string }> = [];
-      let hasErrors = false;
-
-      for (const file of files) {
-        const { result, isError } = await validateAndSave(file.filePath, file.content, overwrite, dbPath);
-        results.push({ ...result, inputPath: file.filePath, filePath: result.filePath ?? file.filePath });
-        if (isError) hasErrors = true;
-      }
-
-      const summary = {
-        total: files.length,
-        saved: results.filter(r => r.saved).length,
-        failed: results.filter(r => !r.saved).length,
-        files: results,
-      };
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(summary, null, 2) }],
-        ...(hasErrors ? { isError: true } : {}),
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({
-          error: (err as Error).message,
-        }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

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

@@ -1,97 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { executeRequest } from "../../core/runner/http-client.ts";
-import { loadEnvironment, substituteString, substituteDeep } from "../../core/parser/variables.ts";
-import { getDb } from "../../db/schema.ts";
-import { findCollectionByNameOrId } from "../../db/queries.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-function extractByPath(obj: unknown, path: string): unknown {
-  const segments = path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(Boolean);
-  let current: unknown = obj;
-  for (const seg of segments) {
-    if (current === null || current === undefined) return undefined;
-    if (Array.isArray(current)) {
-      const idx = parseInt(seg, 10);
-      if (isNaN(idx)) return undefined;
-      current = current[idx];
-    } else if (typeof current === 'object') {
-      current = (current as Record<string, unknown>)[seg];
-    } else {
-      return undefined;
-    }
-  }
-  return current;
-}
-
-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 {
-      let searchDir = process.cwd();
-      if (collectionName) {
-        getDb(dbPath);
-        const col = findCollectionByNameOrId(collectionName);
-        if (col?.base_dir) searchDir = col.base_dir;
-      }
-      const vars = await loadEnvironment(envName, searchDir);
-
-      const resolvedUrl = substituteString(url, vars) as string;
-      const parsedHeaders = headers ? JSON.parse(headers) as Record<string, string> : {};
-      const resolvedHeaders = Object.keys(parsedHeaders).length > 0 ? substituteDeep(parsedHeaders, vars) : {};
-      const resolvedBody = body ? substituteString(body, vars) as string : undefined;
-
-      const response = await executeRequest(
-        {
-          method,
-          url: resolvedUrl,
-          headers: resolvedHeaders,
-          body: resolvedBody,
-        },
-        timeout ? { timeout } : undefined,
-      );
-
-      let responseBody: unknown = response.body_parsed ?? response.body;
-
-      // Apply jsonPath filter
-      if (jsonPath && responseBody !== undefined) {
-        responseBody = extractByPath(responseBody, jsonPath);
-      }
-
-      const result = {
-        status: response.status,
-        headers: response.headers,
-        body: responseBody,
-        duration_ms: response.duration_ms,
-      };
-
-      let text = JSON.stringify(result, null, 2);
-
-      // Apply maxResponseChars truncation
-      if (maxResponseChars && text.length > maxResponseChars) {
-        text = text.slice(0, maxResponseChars) + '\n…[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/set-work-dir.ts

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { resolve, join } from "node:path";
-import { existsSync } from "node:fs";
-import { resetDb } from "../../db/schema.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerSetWorkDirTool(server: McpServer) {
-  server.registerTool("set_work_dir", {
-    description: TOOL_DESCRIPTIONS.set_work_dir,
-    inputSchema: {
-      workDir: z.string().describe(
-        "Absolute path to project root (e.g. /home/user/myproject or C:/Users/user/myproject)"
-      ),
-    },
-  }, async ({ workDir }) => {
-    const resolved = resolve(workDir);
-    if (!existsSync(resolved)) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: `Directory not found: ${resolved}` }, null, 2) }],
-        isError: true,
-      };
-    }
-    process.chdir(resolved);
-    resetDb();
-    const dbPath = join(resolved, "zond.db");
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify({
-        workDir: resolved,
-        zond_db: dbPath,
-        hint: "Working directory set. All relative paths and zond.db will now resolve from this directory.",
-      }, null, 2) }],
-    };
-  });
-}

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,
-      };
-    }
-  });
-}