@kirrosh/zond 0.7.0

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

@@ -0,0 +1,255 @@
+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 } from "../../core/diagnostics/failure-hints.ts";
+
+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;
+  }
+}
+
+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)"),
+    },
+  }, async ({ action, runId, runIdB, limit }) => {
+    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: r.error_message,
+              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);
+              return {
+                suite_name: r.suite_name,
+                test_name: r.test_name,
+                status: r.status,
+                failure_type,
+                error_message: r.error_message,
+                request_method: r.request_method,
+                request_url: r.request_url,
+                response_status: r.response_status,
+                ...(hint ? { hint } : {}),
+                response_body: parseBodySafe(r.response_body),
+                response_headers: r.response_headers
+                  ? JSON.parse(r.response_headers)
+                  : undefined,
+                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

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { executeRun } from "../../core/runner/execute-run.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)"),
+    },
+  }, async ({ testPath, envName, safe, tag, envVars, dryRun }) => {
+    const { runId, results } = await executeRun({
+      testPath,
+      envName,
+      trigger: "mcp",
+      dbPath,
+      safe,
+      tag,
+      envVars,
+      dryRun,
+    });
+
+    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,
+        })),
+      }))
+    );
+
+    const hints: string[] = [];
+    if (failedSteps.length > 0) {
+      hints.push("Use query_db(action: 'diagnose_failure', runId: " + runId + ") for detailed failure analysis");
+    }
+    hints.push("Use manage_server(action: 'start') to launch the Web UI and view results visually in a browser at http://localhost:8080");
+    hints.push("Ask the user if they want to set up CI/CD to run these tests automatically on push. If yes, use ci_init to generate a workflow and help them push to GitHub/GitLab.");
+
+    const summary = {
+      runId,
+      total,
+      passed,
+      failed,
+      skipped,
+      suites: results.length,
+      status: failed === 0 ? "all_passed" : "has_failures",
+      ...(failedSteps.length > 0 ? { failures: failedSteps } : {}),
+      hints,
+    };
+
+    return {
+      content: [{ type: "text" as const, text: JSON.stringify(summary, null, 2) }],
+    };
+  });
+}

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

@@ -0,0 +1,218 @@
+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_missing_tests 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

@@ -0,0 +1,63 @@
+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";
+
+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."),
+    },
+  }, async ({ method, url, headers, body, timeout, envName, collectionName }) => {
+    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,
+      );
+
+      const result = {
+        status: response.status,
+        headers: response.headers,
+        body: response.body_parsed ?? response.body,
+        duration_ms: response.duration_ms,
+      };
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, 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/set-work-dir.ts

@@ -0,0 +1,35 @@
+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) }],
+    };
+  });
+}