@kirrosh/zond 0.7.0

package/src/cli/commands/mcp.ts

@@ -0,0 +1,16 @@
+import { startMcpServer } from "../../mcp/server.ts";
+import { resolve } from "node:path";
+
+export interface McpCommandOptions {
+  dbPath?: string;
+  dir?: string;
+}
+
+export async function mcpCommand(options: McpCommandOptions): Promise<number> {
+  if (options.dir) {
+    process.chdir(resolve(options.dir));
+  }
+  await startMcpServer({ dbPath: options.dbPath });
+  // Server runs until stdin closes — this promise never resolves during normal operation
+  return 0;
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,156 @@
+import { dirname } from "path";
+import { stat } from "node:fs/promises";
+import { parse } from "../../core/parser/yaml-parser.ts";
+import { loadEnvironment } from "../../core/parser/variables.ts";
+import { filterSuitesByTags } from "../../core/parser/filter.ts";
+import { runSuite } from "../../core/runner/executor.ts";
+import { getReporter } from "../../core/reporter/index.ts";
+import type { ReporterName } from "../../core/reporter/types.ts";
+import type { TestSuite } from "../../core/parser/types.ts";
+import type { TestRunResult } from "../../core/runner/types.ts";
+import { printError, printWarning } from "../output.ts";
+import { getDb } from "../../db/schema.ts";
+import { createRun, finalizeRun, saveResults, findCollectionByTestPath } from "../../db/queries.ts";
+
+export interface RunOptions {
+  path: string;
+  env?: string;
+  report: ReporterName;
+  timeout?: number;
+  bail: boolean;
+  noDb?: boolean;
+  dbPath?: string;
+  authToken?: string;
+  safe?: boolean;
+  tag?: string[];
+  envVars?: string[];
+  dryRun?: boolean;
+}
+
+export async function runCommand(options: RunOptions): Promise<number> {
+  // 1. Parse test files
+  let suites: TestSuite[];
+  try {
+    suites = await parse(options.path);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+
+  if (suites.length === 0) {
+    printWarning(`No test files found in ${options.path}`);
+    return 0;
+  }
+
+  // 1b. Tag filter
+  if (options.tag && options.tag.length > 0) {
+    suites = filterSuitesByTags(suites, options.tag);
+    if (suites.length === 0) {
+      printWarning("No suites match the specified tags");
+      return 0;
+    }
+  }
+
+  // 1c. Safe mode: filter to GET-only tests
+  if (options.safe) {
+    for (const suite of suites) {
+      suite.tests = suite.tests.filter(t => t.method === "GET");
+    }
+    suites = suites.filter(s => s.tests.length > 0);
+    if (suites.length === 0) {
+      printWarning("No GET tests found. Nothing to run in safe mode.");
+      return 0;
+    }
+  }
+
+  // 2. Load environment (resolve collection for scoped envs)
+  // Use path itself as searchDir if it's a directory; dirname() on a dir path gives the parent
+  const pathStat = await stat(options.path).catch(() => null);
+  const searchDir = pathStat?.isDirectory() ? options.path : dirname(options.path);
+  let collectionForEnv: { id: number } | null = null;
+  if (!options.noDb) {
+    try {
+      getDb(options.dbPath);
+      collectionForEnv = findCollectionByTestPath(options.path);
+    } catch { /* DB not available — OK */ }
+  }
+
+  let env: Record<string, string> = {};
+  try {
+    env = await loadEnvironment(options.env, searchDir);
+  } catch (err) {
+    printError(`Failed to load environment: ${(err as Error).message}`);
+    return 2;
+  }
+
+  // Inject CLI auth token — overrides env file value
+  if (options.authToken) {
+    env.auth_token = options.authToken;
+  }
+
+  // Inject --env-var KEY=VALUE overrides (highest priority)
+  if (options.envVars && options.envVars.length > 0) {
+    for (const pair of options.envVars) {
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx > 0) {
+        env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+      }
+    }
+  }
+
+  // Warn if --env was explicitly set but file was not found (empty env)
+  if (options.env && Object.keys(env).length === 0) {
+    printWarning(`Environment file .env.${options.env}.yaml not found in ${searchDir}`);
+  }
+
+  // 3. Apply timeout override
+  if (options.timeout !== undefined) {
+    for (const suite of suites) {
+      suite.config.timeout = options.timeout;
+    }
+  }
+
+  // 4. Run suites
+  const results: TestRunResult[] = [];
+  const dryRun = options.dryRun === true;
+  if (options.bail) {
+    // Sequential with bail at suite level
+    for (const suite of suites) {
+      const result = await runSuite(suite, env, dryRun);
+      results.push(result);
+      if (!dryRun && (result.failed > 0 || result.steps.some((s) => s.status === "error"))) {
+        break;
+      }
+    }
+  } else {
+    // Parallel
+    const all = await Promise.all(suites.map((suite) => runSuite(suite, env, dryRun)));
+    results.push(...all);
+  }
+
+  // 5. Report
+  const reporter = getReporter(options.report);
+  reporter.report(results);
+
+  // 6. Save to DB
+  if (!options.noDb) {
+    try {
+      getDb(options.dbPath);
+      const collection = findCollectionByTestPath(options.path);
+      const runId = createRun({
+        started_at: results[0]?.started_at ?? new Date().toISOString(),
+        environment: options.env,
+        collection_id: collection?.id,
+      });
+      finalizeRun(runId, results);
+      saveResults(runId, results);
+    } catch (err) {
+      printWarning(`Failed to save results to DB: ${(err as Error).message}`);
+    }
+  }
+
+  // 7. Exit code (always 0 in dry-run mode)
+  if (dryRun) return 0;
+  const hasFailures = results.some((r) => r.failed > 0 || r.steps.some((s) => s.status === "error"));
+  return hasFailures ? 1 : 0;
+}

package/src/cli/commands/runs.ts

@@ -0,0 +1,108 @@
+import { getDb } from "../../db/schema.ts";
+import { listRuns, getRunById, getResultsByRunId } from "../../db/queries.ts";
+import { printError } from "../output.ts";
+
+export interface RunsOptions {
+  runId?: number;
+  limit?: number;
+  dbPath?: string;
+}
+
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+
+function useColor(): boolean {
+  return process.stdout.isTTY ?? false;
+}
+
+function statusIcon(passed: number, failed: number): string {
+  const color = useColor();
+  if (failed === 0) return color ? `${GREEN}PASS${RESET}` : "PASS";
+  return color ? `${RED}FAIL${RESET}` : "FAIL";
+}
+
+export function runsCommand(options: RunsOptions): number {
+  const { runId, limit = 20, dbPath } = options;
+
+  try {
+    getDb(dbPath);
+  } catch (err) {
+    printError(`Failed to open database: ${(err as Error).message}`);
+    return 2;
+  }
+
+  if (runId !== undefined) {
+    return showRunDetail(runId);
+  }
+  return showRunList(limit);
+}
+
+function showRunList(limit: number): number {
+  const runs = listRuns(limit);
+
+  if (runs.length === 0) {
+    console.log("No runs found.");
+    return 0;
+  }
+
+  // Print table
+  const header = "ID     STATUS  TOTAL  PASS  FAIL  ENV         DURATION  STARTED";
+  console.log(header);
+  console.log("-".repeat(header.length));
+
+  for (const run of runs) {
+    const status = statusIcon(run.passed, run.failed);
+    const env = (run.environment ?? "-").slice(0, 10).padEnd(10);
+    const duration = run.duration_ms != null ? `${run.duration_ms}ms` : "-";
+    const started = run.started_at.slice(0, 19).replace("T", " ");
+    console.log(
+      `${String(run.id).padEnd(6)} ${status.padEnd(useColor() ? 14 : 6)}  ${String(run.total).padEnd(5)}  ${String(run.passed).padEnd(4)}  ${String(run.failed).padEnd(4)}  ${env}  ${duration.padEnd(8)}  ${started}`,
+    );
+  }
+
+  return 0;
+}
+
+function showRunDetail(runId: number): number {
+  const run = getRunById(runId);
+  if (!run) {
+    printError(`Run #${runId} not found`);
+    return 1;
+  }
+
+  const color = useColor();
+
+  console.log(`Run #${run.id}`);
+  console.log(`  Started:     ${run.started_at}`);
+  if (run.finished_at) console.log(`  Finished:    ${run.finished_at}`);
+  if (run.environment) console.log(`  Environment: ${run.environment}`);
+  if (run.duration_ms != null) console.log(`  Duration:    ${run.duration_ms}ms`);
+  console.log(`  Total: ${run.total}  Passed: ${run.passed}  Failed: ${run.failed}  Skipped: ${run.skipped}`);
+
+  const results = getResultsByRunId(runId);
+  if (results.length === 0) {
+    console.log("\nNo step results recorded.");
+    return 0;
+  }
+
+  console.log("\nSteps:");
+  for (const r of results) {
+    let statusStr: string;
+    if (r.status === "pass") {
+      statusStr = color ? `${GREEN}PASS${RESET}` : "PASS";
+    } else if (r.status === "fail" || r.status === "error") {
+      statusStr = color ? `${RED}${r.status.toUpperCase()}${RESET}` : r.status.toUpperCase();
+    } else {
+      statusStr = color ? `${YELLOW}SKIP${RESET}` : "SKIP";
+    }
+
+    console.log(`  ${statusStr} ${r.test_name} (${r.duration_ms}ms)`);
+    if (r.error_message) {
+      console.log(`       ${color ? RED : ""}${r.error_message}${color ? RESET : ""}`);
+    }
+  }
+
+  return 0;
+}

package/src/cli/commands/serve.ts

@@ -0,0 +1,22 @@
+import { startServer } from "../../web/server.ts";
+
+export interface ServeOptions {
+  port?: number;
+  host?: string;
+  openapiSpec?: string;
+  testsDir?: string;
+  dbPath?: string;
+  watch?: boolean;
+}
+
+export async function serveCommand(options: ServeOptions): Promise<number> {
+  await startServer({
+    port: options.port,
+    host: options.host,
+    dbPath: options.dbPath,
+    dev: options.watch,
+  });
+
+  // Keep running — Bun.serve keeps the process alive
+  return 0;
+}

package/src/cli/commands/update.ts

@@ -0,0 +1,142 @@
+import { tmpdir } from "os";
+import { join } from "path";
+import { existsSync, unlinkSync, renameSync, copyFileSync, chmodSync } from "fs";
+import { VERSION } from "../index.ts";
+import { isCompiledBinary } from "../runtime.ts";
+
+export interface UpdateCommandOptions {
+  force?: boolean;
+}
+
+export function detectTarget(): { target: string; archive: "tar.gz" | "zip" } {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const os = platform === "win32" ? "win" : platform;
+  const archSuffix = arch === "arm64" ? "arm64" : "x64";
+  const target = `${os}-${archSuffix}`;
+  const archive = platform === "win32" ? "zip" : ("tar.gz" as const);
+
+  return { target, archive };
+}
+
+export function parseVersion(tag: string): string {
+  return tag.replace(/^v/, "");
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+
+export async function updateCommand(options: UpdateCommandOptions): Promise<number> {
+  if (!isCompiledBinary()) {
+    console.log("Running from source — use git pull to update.");
+    return 0;
+  }
+
+  console.log("Checking for updates...");
+
+  // Fetch latest release
+  const res = await fetch("https://api.github.com/repos/kirrosh/zond/releases/latest", {
+    headers: { "User-Agent": "zond-updater" },
+  });
+
+  if (!res.ok) {
+    console.error(`Failed to check for updates: HTTP ${res.status}`);
+    return 1;
+  }
+
+  const release = (await res.json()) as { tag_name: string };
+  const latestVersion = parseVersion(release.tag_name);
+  const currentVersion = VERSION;
+
+  if (!options.force && compareVersions(currentVersion, latestVersion) >= 0) {
+    console.log(`Already up to date (v${currentVersion}).`);
+    return 0;
+  }
+
+  console.log(`Updating v${currentVersion} → v${latestVersion}...`);
+
+  const { target, archive } = detectTarget();
+  const assetName = `zond-${target}.${archive}`;
+  const downloadUrl = `https://github.com/kirrosh/zond/releases/download/${release.tag_name}/${assetName}`;
+
+  // Download artifact
+  const dlRes = await fetch(downloadUrl);
+  if (!dlRes.ok) {
+    console.error(`Failed to download ${assetName}: HTTP ${dlRes.status}`);
+    return 1;
+  }
+
+  const tempDir = tmpdir();
+  const archivePath = join(tempDir, assetName);
+  const archiveBytes = new Uint8Array(await dlRes.arrayBuffer());
+  await Bun.write(archivePath, archiveBytes);
+
+  // Extract
+  const extractDir = join(tempDir, `zond-update-${Date.now()}`);
+  const mkdirResult = Bun.spawnSync(["mkdir", "-p", extractDir]);
+  if (mkdirResult.exitCode !== 0) {
+    // Fallback for Windows
+    const { mkdirSync } = await import("fs");
+    mkdirSync(extractDir, { recursive: true });
+  }
+
+  if (archive === "tar.gz") {
+    const tar = Bun.spawnSync(["tar", "-xzf", archivePath, "-C", extractDir]);
+    if (tar.exitCode !== 0) {
+      console.error("Failed to extract archive.");
+      return 1;
+    }
+  } else {
+    // Windows zip — use tar (Windows 10+ includes bsdtar)
+    const tar = Bun.spawnSync(["tar", "-xf", archivePath, "-C", extractDir]);
+    if (tar.exitCode !== 0) {
+      console.error("Failed to extract archive.");
+      return 1;
+    }
+  }
+
+  // Find extracted binary
+  const binaryName = process.platform === "win32" ? "zond.exe" : "zond";
+  const newBinary = join(extractDir, binaryName);
+
+  if (!existsSync(newBinary)) {
+    console.error(`Expected binary not found: ${newBinary}`);
+    return 1;
+  }
+
+  // Replace current binary
+  const currentBinary = process.execPath;
+
+  if (process.platform === "win32") {
+    // Windows: can't overwrite running exe — rename current to .old, copy new
+    const oldPath = currentBinary + ".old";
+    try {
+      if (existsSync(oldPath)) unlinkSync(oldPath);
+    } catch { /* ignore */ }
+    renameSync(currentBinary, oldPath);
+    copyFileSync(newBinary, currentBinary);
+  } else {
+    // Unix: rename new over current (atomic on same filesystem, but we copy across)
+    unlinkSync(currentBinary);
+    copyFileSync(newBinary, currentBinary);
+    chmodSync(currentBinary, 0o755);
+  }
+
+  // Cleanup
+  try {
+    unlinkSync(archivePath);
+    unlinkSync(newBinary);
+  } catch { /* best effort */ }
+
+  console.log(`Updated to v${latestVersion}.`);
+  return 0;
+}

package/src/cli/commands/validate.ts

@@ -0,0 +1,18 @@
+import { parse } from "../../core/parser/yaml-parser.ts";
+import { printError, printSuccess } from "../output.ts";
+
+export interface ValidateOptions {
+  path: string;
+}
+
+export async function validateCommand(options: ValidateOptions): Promise<number> {
+  try {
+    const suites = await parse(options.path);
+    const totalSteps = suites.reduce((sum, s) => sum + s.tests.length, 0);
+    printSuccess(`OK: ${suites.length} suite(s), ${totalSteps} test(s) validated successfully`);
+    return 0;
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+}