@kirrosh/zond 0.13.0 → 0.16.0

package/src/cli/commands/init.ts

@@ -1,84 +1,57 @@
-import { resolve, dirname } from "path";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { printSuccess } from "../output.ts";
-
-export interface InitCommandOptions {
-  force: boolean;
+import { setupApi } from "../../core/setup-api.ts";
+import { printError, printSuccess } from "../output.ts";
+import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
+
+export interface InitOptions {
+  name?: string;
+  spec?: string;
+  baseUrl?: string;
+  dir?: string;
+  force?: boolean;
+  insecure?: boolean;
+  dbPath?: string;
+  json?: boolean;
 }
 
-const EXAMPLE_TEST = `name: Example Smoke Test
-base_url: "{{base_url}}"
-
-tests:
-  - name: "List posts"
-    GET: /posts
-    expect:
-      status: 200
-      body:
-        id: { type: integer }
-
-  - name: "Get single post"
-    GET: /posts/1
-    expect:
-      status: 200
-      body:
-        id: { equals: 1 }
-        title: { type: string }
-`;
-
-const ENV_DEV = `base_url: https://jsonplaceholder.typicode.com
-`;
-
-const MCP_CONFIG = `{
-  "mcpServers": {
-    "zond": {
-      "command": "zond",
-      "args": ["mcp"]
-    }
-  }
-}
-`;
-
-function writeIfMissing(filePath: string, content: string, force: boolean): boolean {
-  if (!force && existsSync(filePath)) {
-    console.log(`  Skipped ${filePath} (already exists)`);
-    return false;
-  }
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(filePath, content, "utf-8");
-  console.log(`  Created ${filePath}`);
-  return true;
-}
-
-function isClaudeCodeAvailable(): boolean {
+export async function initCommand(options: InitOptions): Promise<number> {
   try {
-    const result = Bun.spawnSync(["claude", "--version"], {
-      stdout: "ignore",
-      stderr: "ignore",
+    const envVars: Record<string, string> = {};
+    if (options.baseUrl) envVars.base_url = options.baseUrl;
+
+    const result = await setupApi({
+      name: options.name,
+      spec: options.spec,
+      dir: options.dir,
+      envVars: Object.keys(envVars).length > 0 ? envVars : undefined,
+      dbPath: options.dbPath,
+      force: options.force,
+      insecure: options.insecure,
     });
-    return result.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-export async function initCommand(options: InitCommandOptions): Promise<number> {
-  const cwd = process.cwd();
 
-  console.log("Initializing zond project...\n");
-
-  writeIfMissing(resolve(cwd, "tests/example.yaml"), EXAMPLE_TEST, options.force);
-  writeIfMissing(resolve(cwd, ".env.dev.yaml"), ENV_DEV, options.force);
-
-  // Create .mcp.json if Claude Code is detected
-  if (isClaudeCodeAvailable()) {
-    writeIfMissing(resolve(cwd, ".mcp.json"), MCP_CONFIG, options.force);
-    printSuccess("Claude Code detected — .mcp.json created");
+    if (options.json) {
+      printJson(jsonOk("init", {
+        collectionId: result.collectionId,
+        baseDir: result.baseDir,
+        testPath: result.testPath,
+        endpoints: result.specEndpoints,
+        warnings: result.warnings ?? [],
+      }, result.warnings));
+    } else {
+      printSuccess(`Created API '${options.name ?? "api"}' at ${result.baseDir} (${result.specEndpoints} endpoints)`);
+      if (result.warnings) {
+        for (const w of result.warnings) {
+          process.stderr.write(`Warning: ${w}\n`);
+        }
+      }
+    }
+    return 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.json) {
+      printJson(jsonError("init", [message]));
+    } else {
+      printError(message);
+    }
+    return 2;
   }
-
-  console.log("\nReady! Run: zond run tests/");
-  return 0;
 }

package/src/cli/commands/request.ts

@@ -0,0 +1,57 @@
+import { sendAdHocRequest } from "../../core/runner/send-request.ts";
+import { printError } from "../output.ts";
+import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
+
+export interface RequestOptions {
+  method: string;
+  url: string;
+  headers?: string[];
+  body?: string;
+  timeout?: number;
+  env?: string;
+  api?: string;
+  jsonPath?: string;
+  dbPath?: string;
+  json?: boolean;
+}
+
+export async function requestCommand(options: RequestOptions): Promise<number> {
+  try {
+    const headers: Record<string, string> = {};
+    if (options.headers) {
+      for (const h of options.headers) {
+        const colonIdx = h.indexOf(":");
+        if (colonIdx > 0) {
+          headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+        }
+      }
+    }
+
+    const result = await sendAdHocRequest({
+      method: options.method.toUpperCase(),
+      url: options.url,
+      headers: Object.keys(headers).length > 0 ? headers : undefined,
+      body: options.body,
+      timeout: options.timeout,
+      envName: options.env,
+      collectionName: options.api,
+      jsonPath: options.jsonPath,
+      dbPath: options.dbPath,
+    });
+
+    if (options.json) {
+      printJson(jsonOk("request", result));
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    return 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.json) {
+      printJson(jsonError("request", [message]));
+    } else {
+      printError(message);
+    }
+    return 1;
+  }
+}

package/src/cli/commands/run.ts

@@ -9,6 +9,7 @@ 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 { jsonOk, jsonError, printJson } from "../json-envelope.ts";
 import { getDb } from "../../db/schema.ts";
 import { createRun, finalizeRun, saveResults, findCollectionByTestPath } from "../../db/queries.ts";
 
@@ -25,6 +26,7 @@ export interface RunOptions {
   tag?: string[];
   envVars?: string[];
   dryRun?: boolean;
+  json?: boolean;
 }
 
 export async function runCommand(options: RunOptions): Promise<number> {
@@ -51,14 +53,19 @@ export async function runCommand(options: RunOptions): Promise<number> {
     }
   }
 
-  // 1c. Safe mode: filter to GET-only tests
+  // 1c. Safe mode: keep GET, set-only steps, and auth-related requests
   if (options.safe) {
+    const AUTH_PATH_RE = /\/(auth|login|signin|token|oauth)\b/i;
     for (const suite of suites) {
-      suite.tests = suite.tests.filter(t => t.method === "GET");
+      suite.tests = suite.tests.filter(t => {
+        if (t.method === "GET" || !t.method) return true;
+        if (AUTH_PATH_RE.test(t.path)) return true;
+        return false;
+      });
     }
     suites = suites.filter(s => s.tests.length > 0);
     if (suites.length === 0) {
-      printWarning("No GET tests found. Nothing to run in safe mode.");
+      printWarning("No safe tests found. Nothing to run in safe mode.");
       return 0;
     }
   }
@@ -128,29 +135,65 @@ export async function runCommand(options: RunOptions): Promise<number> {
     results.push(...all);
   }
 
-  // 5. Report
-  const reporter = getReporter(options.report);
-  reporter.report(results);
+  // 5. Collect warnings
+  const warnings: string[] = [];
+  const rateLimited = results.flatMap(r => r.steps)
+    .filter(s => s.response?.status === 429);
+  if (rateLimited.length > 0) {
+    warnings.push(`${rateLimited.length} request(s) hit rate limit (429). Consider: consolidating login steps, adding --bail, or using retry_until with delay.`);
+  }
+
+  // 5b. Report
+  if (!options.json) {
+    const reporter = getReporter(options.report);
+    reporter.report(results);
+    for (const w of warnings) {
+      printWarning(w);
+    }
+  }
 
   // 6. Save to DB
+  let savedRunId: number | undefined;
   if (!options.noDb) {
     try {
       getDb(options.dbPath);
       const collection = findCollectionByTestPath(options.path);
-      const runId = createRun({
+      savedRunId = createRun({
         started_at: results[0]?.started_at ?? new Date().toISOString(),
         environment: options.env,
         collection_id: collection?.id,
       });
-      finalizeRun(runId, results);
-      saveResults(runId, results);
+      finalizeRun(savedRunId, results);
+      saveResults(savedRunId, 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;
+  if (dryRun) {
+    if (options.json) {
+      printJson(jsonOk("run", { summary: { total: results.length, passed: 0, failed: 0 }, dryRun: true }));
+    }
+    return 0;
+  }
   const hasFailures = results.some((r) => r.failed > 0 || r.steps.some((s) => s.status === "error"));
+
+  if (options.json) {
+    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 failures = 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,
+      }))
+    );
+    printJson(jsonOk("run", { summary: { total, passed, failed }, failures, warnings, runId: savedRunId }));
+  }
+
   return hasFailures ? 1 : 0;
 }

package/src/cli/commands/serve.ts

@@ -3,20 +3,79 @@ import { startServer } from "../../web/server.ts";
 export interface ServeOptions {
   port?: number;
   host?: string;
-  openapiSpec?: string;
-  testsDir?: string;
   dbPath?: string;
   watch?: boolean;
+  open?: boolean;
+}
+
+/** Kill any existing process listening on the given port (Windows + Unix) */
+async function killPortHolder(port: number): Promise<void> {
+  const isWin = process.platform === "win32";
+  try {
+    if (isWin) {
+      // PowerShell: find PID on port, then kill it
+      const find = Bun.spawn(["powershell", "-NoProfile", "-Command",
+        `(Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue).OwningProcess`], {
+        stdout: "pipe", stderr: "ignore",
+      });
+      const out = await new Response(find.stdout).text();
+      const pids = [...new Set(out.trim().split(/\s+/).filter(s => /^\d+$/.test(s) && s !== "0"))];
+      for (const pid of pids) {
+        Bun.spawn(["powershell", "-NoProfile", "-Command",
+          `Stop-Process -Id ${pid} -Force -ErrorAction SilentlyContinue`], {
+          stdout: "ignore", stderr: "ignore",
+        });
+      }
+      if (pids.length > 0) {
+        // Give OS time to release the port
+        await Bun.sleep(500);
+      }
+    } else {
+      // Unix: lsof + kill
+      const find = Bun.spawn(["lsof", "-ti", `:${port}`], {
+        stdout: "pipe", stderr: "ignore",
+      });
+      const out = await new Response(find.stdout).text();
+      const pids = out.trim().split(/\s+/).filter(s => /^\d+$/.test(s));
+      for (const pid of pids) {
+        Bun.spawn(["kill", "-9", pid], { stdout: "ignore", stderr: "ignore" });
+      }
+      if (pids.length > 0) {
+        await Bun.sleep(300);
+      }
+    }
+  } catch {
+    // Best effort — if we can't kill, startServer will fail with port-in-use
+  }
 }
 
 export async function serveCommand(options: ServeOptions): Promise<number> {
+  const port = options.port ?? 8080;
+
+  // Kill previous instance on the same port
+  await killPortHolder(port);
+
   await startServer({
-    port: options.port,
+    port,
     host: options.host,
     dbPath: options.dbPath,
     dev: options.watch,
   });
 
+  // Open browser if requested
+  if (options.open) {
+    const host = options.host === "0.0.0.0" || !options.host ? "localhost" : options.host;
+    const url = `http://${host}:${port}`;
+    try {
+      const cmd = process.platform === "win32" ? ["cmd", "/c", "start", url]
+        : process.platform === "darwin" ? ["open", url]
+        : ["xdg-open", url];
+      Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore" });
+    } catch {
+      // Best effort — if browser can't open, server still runs
+    }
+  }
+
   // Keep running — Bun.serve keeps the process alive
   return 0;
 }

package/src/cli/commands/validate.ts

@@ -1,18 +1,34 @@
 import { parse } from "../../core/parser/yaml-parser.ts";
 import { printError, printSuccess } from "../output.ts";
+import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
 
 export interface ValidateOptions {
   path: string;
+  json?: boolean;
 }
 
 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`);
+    if (options.json) {
+      printJson(jsonOk("validate", {
+        files: suites.length,
+        suites: suites.length,
+        tests: totalSteps,
+        valid: true,
+      }));
+    } else {
+      printSuccess(`OK: ${suites.length} suite(s), ${totalSteps} test(s) validated successfully`);
+    }
     return 0;
   } catch (err) {
-    printError(err instanceof Error ? err.message : String(err));
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.json) {
+      printJson(jsonError("validate", [message]));
+    } else {
+      printError(message);
+    }
     return 2;
   }
 }