@kirrosh/zond 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirrosh/zond",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "API testing platform — define tests in YAML, run from CLI or WebUI, generate from OpenAPI specs",
   "license": "MIT",
   "module": "index.ts",

package/src/cli/commands/generate.ts

@@ -11,6 +11,7 @@ import {
 import { generateSuites } from "../../core/generator/suite-generator.ts";
 import { filterByTag } from "../../core/generator/chunker.ts";
 import { parse } from "../../core/parser/yaml-parser.ts";
+import { decycleSchema } from "../../core/generator/schema-utils.ts";
 import { printError, printSuccess } from "../output.ts";
 import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
 import { readMeta, writeMeta, hashSpec, buildFileMeta } from "../../core/meta/meta-store.ts";
@@ -82,7 +83,7 @@ export async function generateCommand(options: GenerateOptions): Promise<number>
 
     // Write .zond-meta.json (merge with existing meta to preserve info about prior files)
     const existingMeta = await readMeta(options.output);
-    const specContent = typeof doc === "object" ? JSON.stringify(doc) : String(doc);
+    const specContent = typeof doc === "object" ? JSON.stringify(decycleSchema(doc)) : String(doc);
     await writeMeta(options.output, {
       zondVersion: ZOND_VERSION,
       lastSyncedAt: new Date().toISOString(),

package/src/cli/commands/sync.ts

@@ -10,6 +10,7 @@ import { generateSuites } from "../../core/generator/suite-generator.ts";
 import { filterByTag } from "../../core/generator/chunker.ts";
 import { readMeta, writeMeta, hashSpec, buildFileMeta } from "../../core/meta/meta-store.ts";
 import { diffEndpoints } from "../../core/sync/spec-differ.ts";
+import { decycleSchema } from "../../core/generator/schema-utils.ts";
 import { printError, printSuccess, printWarning } from "../output.ts";
 import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
 import { version as ZOND_VERSION } from "../../../package.json";
@@ -41,7 +42,7 @@ export async function syncCommand(options: SyncOptions): Promise<number> {
 
     // Load current spec
     const doc = await readOpenApiSpec(options.specPath);
-    const specContent = JSON.stringify(doc);
+    const specContent = JSON.stringify(decycleSchema(doc));
     const currentHash = hashSpec(specContent);
 
     if (currentHash === meta.specHash) {

package/src/cli/commands/update.ts

@@ -0,0 +1,174 @@
+import { VERSION } from "../index.ts";
+import { isCompiledBinary } from "../runtime.ts";
+import { printError, printSuccess, printWarning } from "../output.ts";
+import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
+
+export interface UpdateOptions {
+  json?: boolean;
+  check?: boolean;
+}
+
+const REPO = "kirrosh/zond";
+const GITHUB_API = `https://api.github.com/repos/${REPO}/releases/latest`;
+
+interface GitHubRelease {
+  tag_name: string;
+  assets: { name: string; browser_download_url: string }[];
+}
+
+function getTarget(): { target: string; ext: string } | null {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === "linux" && arch === "x64") return { target: "linux-x64", ext: "tar.gz" };
+  if (platform === "darwin" && arch === "arm64") return { target: "darwin-arm64", ext: "tar.gz" };
+  if (platform === "win32" && arch === "x64") return { target: "win-x64", ext: "zip" };
+  return null;
+}
+
+async function fetchLatestRelease(): Promise<GitHubRelease> {
+  const resp = await fetch(GITHUB_API, {
+    headers: { "User-Agent": `zond/${VERSION}` },
+  });
+  if (!resp.ok) {
+    throw new Error(`GitHub API returned ${resp.status}: ${resp.statusText}`);
+  }
+  return resp.json() as Promise<GitHubRelease>;
+}
+
+export async function updateCommand(options: UpdateOptions): Promise<number> {
+  try {
+    if (!isCompiledBinary()) {
+      const msg = "Self-update is only available for standalone binaries. Update via: npm update -g @kirrosh/zond  or  bun update -g @kirrosh/zond";
+      if (options.json) {
+        printJson(jsonOk("update", { action: "skip", reason: "not-standalone" }, [msg]));
+      } else {
+        printWarning(msg);
+      }
+      return 0;
+    }
+
+    const target = getTarget();
+    if (!target) {
+      const msg = `Unsupported platform: ${process.platform}-${process.arch}`;
+      if (options.json) {
+        printJson(jsonError("update", [msg]));
+      } else {
+        printError(msg);
+      }
+      return 2;
+    }
+
+    const release = await fetchLatestRelease();
+    const latest = release.tag_name.replace(/^v/, "");
+
+    if (latest === VERSION) {
+      const msg = `Already up to date (${VERSION})`;
+      if (options.json) {
+        printJson(jsonOk("update", { action: "none", currentVersion: VERSION, latestVersion: latest }));
+      } else {
+        console.log(msg);
+      }
+      return 0;
+    }
+
+    if (options.check) {
+      const msg = `Update available: ${VERSION} → ${latest}`;
+      if (options.json) {
+        printJson(jsonOk("update", { action: "available", currentVersion: VERSION, latestVersion: latest }));
+      } else {
+        console.log(msg);
+      }
+      return 0;
+    }
+
+    // Find the right asset
+    const assetName = `zond-${target.target}.${target.ext}`;
+    const asset = release.assets.find(a => a.name === assetName);
+    if (!asset) {
+      const msg = `Binary not found for ${target.target} in release ${release.tag_name}`;
+      if (options.json) {
+        printJson(jsonError("update", [msg]));
+      } else {
+        printError(msg);
+      }
+      return 2;
+    }
+
+    console.log(`Updating zond ${VERSION} → ${latest}...`);
+    console.log(`Downloading ${assetName}...`);
+
+    // Download the archive
+    const resp = await fetch(asset.browser_download_url, {
+      headers: { "User-Agent": `zond/${VERSION}` },
+    });
+    if (!resp.ok) {
+      throw new Error(`Download failed: ${resp.status} ${resp.statusText}`);
+    }
+    const archiveData = new Uint8Array(await resp.arrayBuffer());
+
+    const currentBinary = process.execPath;
+    const { join, dirname } = await import("path");
+    const tmpDir = join(dirname(currentBinary), `.zond-update-${Date.now()}`);
+    const { mkdir, rm, rename, chmod } = await import("fs/promises");
+    await mkdir(tmpDir, { recursive: true });
+
+    try {
+      const archivePath = join(tmpDir, assetName);
+      await Bun.write(archivePath, archiveData);
+
+      // Extract
+      if (target.ext === "tar.gz") {
+        const proc = Bun.spawn(["tar", "-xzf", archivePath, "-C", tmpDir]);
+        const exitCode = await proc.exited;
+        if (exitCode !== 0) throw new Error(`tar extraction failed (exit ${exitCode})`);
+      } else {
+        // Windows zip
+        const proc = Bun.spawn([
+          "powershell", "-NoProfile", "-Command",
+          `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpDir}' -Force`,
+        ]);
+        const exitCode = await proc.exited;
+        if (exitCode !== 0) throw new Error(`Zip extraction failed (exit ${exitCode})`);
+      }
+
+      // Find the extracted binary
+      const binaryName = process.platform === "win32" ? "zond.exe" : "zond";
+      const newBinary = join(tmpDir, binaryName);
+      const file = Bun.file(newBinary);
+      if (!await file.exists()) {
+        throw new Error(`Binary '${binaryName}' not found in archive`);
+      }
+
+      // Replace current binary
+      if (process.platform === "win32") {
+        // Windows: rename current to .old, move new, clean up
+        const oldBinary = currentBinary + ".old";
+        try { await rm(oldBinary, { force: true }); } catch {}
+        await rename(currentBinary, oldBinary);
+        await rename(newBinary, currentBinary);
+        try { await rm(oldBinary, { force: true }); } catch {}
+      } else {
+        await rename(newBinary, currentBinary);
+        await chmod(currentBinary, 0o755);
+      }
+
+      if (options.json) {
+        printJson(jsonOk("update", { action: "updated", previousVersion: VERSION, newVersion: latest }));
+      } else {
+        printSuccess(`Updated zond ${VERSION} → ${latest}`);
+      }
+      return 0;
+    } finally {
+      try { await rm(tmpDir, { recursive: true, force: true }); } catch {}
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.json) {
+      printJson(jsonError("update", [message]));
+    } else {
+      printError(message);
+    }
+    return 2;
+  }
+}

package/src/cli/index.ts

@@ -13,6 +13,7 @@ import { guideCommand } from "./commands/guide.ts";
 import { generateCommand } from "./commands/generate.ts";
 import { exportCommand } from "./commands/export.ts";
 import { syncCommand } from "./commands/sync.ts";
+import { updateCommand } from "./commands/update.ts";
 import { printError } from "./output.ts";
 import { getRuntimeInfo } from "./runtime.ts";
 import { getDb } from "../db/schema.ts";
@@ -107,6 +108,7 @@ Usage:
   zond ci init          Generate CI/CD workflow (GitHub Actions, GitLab CI)
   zond export postman <path>  Export YAML tests as Postman Collection v2.1
   zond sync <spec>      Detect new/removed endpoints and generate tests for new ones
+  zond update           Check for updates and self-update the binary
 
 Options for 'run':
   --dry-run            Show requests without sending them (exit code always 0)
@@ -186,6 +188,9 @@ Options for 'sync':
   --dry-run            Show what would be generated without writing files
   --tag <tag>          Limit sync to endpoints with this tag
 
+Options for 'update':
+  --check              Only check for updates, do not download
+
 General:
   --json               Output in JSON envelope format (available for all commands)
   --help, -h           Show this help
@@ -528,6 +533,14 @@ async function main(): Promise<number> {
       });
     }
 
+    case "update":
+    case "self-update": {
+      return updateCommand({
+        check: flags["check"] === true,
+        json: jsonFlag,
+      });
+    }
+
     case "sync": {
       const specPath = positional[0];
       if (!specPath) {

package/src/core/generator/data-factory.ts

@@ -7,7 +7,10 @@ import type { OpenAPIV3 } from "openapi-types";
 export function generateFromSchema(
   schema: OpenAPIV3.SchemaObject,
   propertyName?: string,
+  _depth = 0,
 ): unknown {
+  if (_depth > 5) return {};
+
   // allOf: merge all schemas
   if (schema.allOf) {
     const merged: OpenAPIV3.SchemaObject = { type: "object", properties: {} };
@@ -17,15 +20,15 @@ export function generateFromSchema(
         merged.properties = { ...merged.properties, ...s.properties };
       }
     }
-    return generateFromSchema(merged, propertyName);
+    return generateFromSchema(merged, propertyName, _depth + 1);
   }
 
   // oneOf / anyOf: use first variant
   if (schema.oneOf) {
-    return generateFromSchema(schema.oneOf[0] as OpenAPIV3.SchemaObject, propertyName);
+    return generateFromSchema(schema.oneOf[0] as OpenAPIV3.SchemaObject, propertyName, _depth + 1);
   }
   if (schema.anyOf) {
-    return generateFromSchema(schema.anyOf[0] as OpenAPIV3.SchemaObject, propertyName);
+    return generateFromSchema(schema.anyOf[0] as OpenAPIV3.SchemaObject, propertyName, _depth + 1);
   }
 
   // enum: first value
@@ -51,7 +54,7 @@ export function generateFromSchema(
 
     case "array": {
       if (schema.items) {
-        const item = generateFromSchema(schema.items as OpenAPIV3.SchemaObject);
+        const item = generateFromSchema(schema.items as OpenAPIV3.SchemaObject, undefined, _depth + 1);
         return [item];
       }
       return [];
@@ -63,14 +66,14 @@ export function generateFromSchema(
       if (schema.properties) {
         const obj: Record<string, unknown> = {};
         for (const [key, propSchema] of Object.entries(schema.properties)) {
-          obj[key] = generateFromSchema(propSchema as OpenAPIV3.SchemaObject, key);
+          obj[key] = generateFromSchema(propSchema as OpenAPIV3.SchemaObject, key, _depth + 1);
         }
         return obj;
       }
       // Record type: additionalProperties defines value schema
       if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
         const valSchema = schema.additionalProperties as OpenAPIV3.SchemaObject;
-        return { key1: generateFromSchema(valSchema, "key1"), key2: generateFromSchema(valSchema, "key2") };
+        return { key1: generateFromSchema(valSchema, "key1", _depth + 1), key2: generateFromSchema(valSchema, "key2", _depth + 1) };
       }
       if (schema.additionalProperties === true) {
         return { key1: "value1", key2: "value2" };

package/src/web/server.ts

@@ -4,7 +4,7 @@ import dashboard from "./routes/dashboard.ts";
 import runs from "./routes/runs.ts";
 import api from "./routes/api.ts";
 import styleCssPath from "./static/style.css" with { type: "file" };
-import htmxJsPath from "./static/htmx.min.js" with { type: "file" };
+import htmxJsPath from "./static/htmx.min.cjs" with { type: "file" };
 
 export interface ServerOptions {
   port?: number;