@kirrosh/zond 0.19.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirrosh/zond",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "API testing platform — define tests in YAML, run from CLI or WebUI, generate from OpenAPI specs",
   "license": "MIT",
   "module": "index.ts",
@@ -26,7 +26,7 @@
   "scripts": {
     "zond": "bun run src/cli/index.ts",
     "test": "bun run test:unit && bun run test:mocked",
-    "test:unit": "bun test tests/db/ tests/parser/ tests/runner/ tests/generator/ tests/core/ tests/diagnostics/ tests/cli/args.test.ts tests/cli/ci-init.test.ts tests/cli/commands.test.ts tests/cli/safe-run.test.ts tests/cli/json-envelope.test.ts tests/cli/describe.test.ts tests/cli/db.test.ts tests/cli/request.test.ts tests/cli/init.test.ts tests/cli/guide.test.ts tests/integration/ tests/web/ tests/reporter/ tests/version-sync.test.ts",
+    "test:unit": "bun test tests/db/ tests/parser/ tests/runner/ tests/generator/ tests/core/ tests/diagnostics/ tests/cli/args.test.ts tests/cli/ci-init.test.ts tests/cli/commands.test.ts tests/cli/safe-run.test.ts tests/cli/json-envelope.test.ts tests/cli/describe.test.ts tests/cli/catalog.test.ts tests/cli/db.test.ts tests/cli/request.test.ts tests/cli/init.test.ts tests/cli/guide.test.ts tests/integration/ tests/web/ tests/reporter/ tests/version-sync.test.ts",
     "test:mocked": "bun run scripts/run-mocked-tests.ts",
     "check": "tsc --noEmit --project tsconfig.json",
     "build": "bun build --compile src/cli/index.ts --outfile zond",

package/src/cli/commands/catalog.ts

@@ -0,0 +1,62 @@
+import { join } from "path";
+import { mkdir } from "fs/promises";
+import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../core/generator/index.ts";
+import { buildCatalog, serializeCatalog } from "../../core/generator/catalog-builder.ts";
+import { decycleSchema } from "../../core/generator/schema-utils.ts";
+import { hashSpec } from "../../core/meta/meta-store.ts";
+import { printError, printSuccess } from "../output.ts";
+import { jsonOk, jsonError, printJson } from "../json-envelope.ts";
+
+export interface CatalogOptions {
+  specPath: string;
+  output?: string;
+  json?: boolean;
+}
+
+export async function catalogCommand(options: CatalogOptions): Promise<number> {
+  try {
+    const doc = await readOpenApiSpec(options.specPath);
+    const endpoints = extractEndpoints(doc);
+    const securitySchemes = extractSecuritySchemes(doc);
+    const baseUrl = ((doc as any).servers?.[0]?.url) as string | undefined;
+    const apiName = (doc as any).info?.title as string | undefined;
+    const apiVersion = (doc as any).info?.version as string | undefined;
+    const specContent = JSON.stringify(decycleSchema(doc));
+
+    const catalog = buildCatalog({
+      endpoints,
+      securitySchemes,
+      specSource: options.specPath,
+      specHash: hashSpec(specContent),
+      apiName,
+      apiVersion,
+      baseUrl,
+    });
+
+    const outputDir = options.output ?? ".";
+    await mkdir(outputDir, { recursive: true });
+
+    const catalogPath = join(outputDir, ".api-catalog.yaml");
+    await Bun.write(catalogPath, serializeCatalog(catalog));
+
+    if (options.json) {
+      printJson(jsonOk("catalog", {
+        path: catalogPath,
+        endpointCount: catalog.endpointCount,
+        apiName: catalog.apiName,
+      }));
+    } else {
+      printSuccess(`Generated API catalog: ${catalogPath} (${catalog.endpointCount} endpoints)`);
+    }
+
+    return 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.json) {
+      printJson(jsonError("catalog", [message]));
+    } else {
+      printError(message);
+    }
+    return 2;
+  }
+}

package/src/cli/commands/generate.ts

@@ -7,6 +7,8 @@ import {
   scanCoveredEndpoints,
   filterUncoveredEndpoints,
   serializeSuite,
+  buildCatalog,
+  serializeCatalog,
 } from "../../core/generator/index.ts";
 import { generateSuites, findUnresolvedVars } from "../../core/generator/suite-generator.ts";
 import { filterByTag } from "../../core/generator/chunker.ts";
@@ -30,9 +32,12 @@ export interface GenerateOptions {
 export async function generateCommand(options: GenerateOptions): Promise<number> {
   try {
     const doc = await readOpenApiSpec(options.specPath);
-    let endpoints = extractEndpoints(doc);
+    const allEndpoints = extractEndpoints(doc);
+    let endpoints = allEndpoints;
     const securitySchemes = extractSecuritySchemes(doc);
     const baseUrl = ((doc as any).servers?.[0]?.url) as string | undefined;
+    const apiName = (doc as any).info?.title as string | undefined;
+    const apiVersion = (doc as any).info?.version as string | undefined;
     const warnings: string[] = [];
 
     // Filter to uncovered only
@@ -92,6 +97,18 @@ export async function generateCommand(options: GenerateOptions): Promise<number>
       files: { ...(existingMeta?.files ?? {}), ...metaFiles },
     });
 
+    // Generate .api-catalog.yaml (always uses full unfiltered endpoint list)
+    const catalog = buildCatalog({
+      endpoints: allEndpoints,
+      securitySchemes,
+      specSource: options.specPath,
+      specHash: hashSpec(specContent),
+      apiName,
+      apiVersion,
+      baseUrl,
+    });
+    await Bun.write(join(options.output, ".api-catalog.yaml"), serializeCatalog(catalog));
+
     // Sync DB collection spec reference if one is registered for this output directory
     try {
       getDb();

package/src/cli/commands/sync.ts

@@ -5,6 +5,8 @@ import {
   extractEndpoints,
   extractSecuritySchemes,
   serializeSuite,
+  buildCatalog,
+  serializeCatalog,
 } from "../../core/generator/index.ts";
 import { generateSuites } from "../../core/generator/suite-generator.ts";
 import { filterByTag } from "../../core/generator/chunker.ts";
@@ -78,6 +80,19 @@ export async function syncCommand(options: SyncOptions): Promise<number> {
     }
 
     if (newEndpoints.length === 0) {
+      // Update catalog even when no new endpoints — spec schema may have changed
+      const allEndpoints = extractEndpoints(doc);
+      const catalog = buildCatalog({
+        endpoints: allEndpoints,
+        securitySchemes,
+        specSource: options.specPath,
+        specHash: currentHash,
+        apiName: (doc as any).info?.title,
+        apiVersion: (doc as any).info?.version,
+        baseUrl: (doc as any).servers?.[0]?.url,
+      });
+      await Bun.write(join(options.testsDir, ".api-catalog.yaml"), serializeCatalog(catalog));
+
       const msg = "Spec changed (hash differs) but no new endpoints detected. Existing tests may need manual review.";
       warnings.push(msg);
       if (options.json) {
@@ -168,6 +183,19 @@ export async function syncCommand(options: SyncOptions): Promise<number> {
       files: { ...meta.files, ...updatedMetaFiles },
     });
 
+    // Update .api-catalog.yaml with current spec state
+    const allEndpoints = extractEndpoints(doc);
+    const catalog = buildCatalog({
+      endpoints: allEndpoints,
+      securitySchemes,
+      specSource: options.specPath,
+      specHash: currentHash,
+      apiName: (doc as any).info?.title,
+      apiVersion: (doc as any).info?.version,
+      baseUrl: (doc as any).servers?.[0]?.url,
+    });
+    await Bun.write(join(options.testsDir, ".api-catalog.yaml"), serializeCatalog(catalog));
+
     // Sync DB collection if one is registered for this tests directory
     try {
       getDb();

package/src/cli/index.ts

@@ -14,6 +14,7 @@ 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 { catalogCommand } from "./commands/catalog.ts";
 import { printError } from "./output.ts";
 import { getRuntimeInfo } from "./runtime.ts";
 import { getDb } from "../db/schema.ts";
@@ -107,6 +108,7 @@ Usage:
   zond ui               Alias for 'serve --open' (start dashboard & open browser)
   zond ci init          Generate CI/CD workflow (GitHub Actions, GitLab CI)
   zond export postman <path>  Export YAML tests as Postman Collection v2.1
+  zond catalog <spec>   Generate API catalog (compact endpoint reference)
   zond sync <spec>      Detect new/removed endpoints and generate tests for new ones
   zond update           Check for updates and self-update the binary
 
@@ -186,6 +188,9 @@ Options for 'export postman':
   --env <file>         Also export .env.yaml as Postman environment
   --collection-name <name>  Collection name (default: derived from path)
 
+Options for 'catalog':
+  --output <dir>       Output directory (default: current directory)
+
 Options for 'sync':
   --tests <dir>        Path to test files directory (required)
   --dry-run            Show what would be generated without writing files
@@ -521,6 +526,19 @@ async function main(): Promise<number> {
       });
     }
 
+    case "catalog": {
+      const specPath = positional[0];
+      if (!specPath) {
+        printError("Missing spec path. Usage: zond catalog <spec> [--output <dir>]");
+        return 2;
+      }
+      return catalogCommand({
+        specPath,
+        output: typeof flags["output"] === "string" ? flags["output"] : undefined,
+        json: jsonFlag,
+      });
+    }
+
     case "guide": {
       const specPath = positional[0];
       if (!specPath) {

package/src/core/generator/catalog-builder.ts

@@ -0,0 +1,179 @@
+import type { EndpointInfo, SecuritySchemeInfo } from "./types.ts";
+import { compressSchema, formatParam, isAnySchema } from "./schema-utils.ts";
+
+export interface CatalogEndpoint {
+  method: string;
+  path: string;
+  summary?: string;
+  tags: string[];
+  deprecated?: boolean;
+  parameters?: string[];
+  requestBody?: string;
+  responses: Array<{
+    status: number;
+    schema?: string;
+  }>;
+}
+
+export interface ApiCatalog {
+  generatedAt: string;
+  specSource: string;
+  specHash: string;
+  apiName?: string;
+  apiVersion?: string;
+  baseUrl?: string;
+  auth: string[];
+  endpointCount: number;
+  endpoints: CatalogEndpoint[];
+}
+
+export interface BuildCatalogParams {
+  endpoints: EndpointInfo[];
+  securitySchemes: SecuritySchemeInfo[];
+  specSource: string;
+  specHash: string;
+  apiName?: string;
+  apiVersion?: string;
+  baseUrl?: string;
+}
+
+function formatSecurityScheme(s: SecuritySchemeInfo): string {
+  let desc = `${s.name}: ${s.type}`;
+  if (s.scheme) desc += `/${s.scheme}`;
+  if (s.bearerFormat) desc += ` (${s.bearerFormat})`;
+  if (s.in && s.apiKeyName) desc += ` (${s.apiKeyName} in ${s.in})`;
+  return desc;
+}
+
+function formatParamWithLocation(p: import("openapi-types").OpenAPIV3.ParameterObject): string {
+  const base = formatParam(p);
+  // Insert location before (req) or at the end
+  const reqSuffix = " (req)";
+  if (base.endsWith(reqSuffix)) {
+    return `${base.slice(0, -reqSuffix.length)} (${p.in}, req)`;
+  }
+  return `${base} (${p.in})`;
+}
+
+function buildCatalogEndpoint(ep: EndpointInfo): CatalogEndpoint {
+  const result: CatalogEndpoint = {
+    method: ep.method.toUpperCase(),
+    path: ep.path,
+    tags: ep.tags,
+    responses: [],
+  };
+
+  if (ep.summary) result.summary = ep.summary;
+  if (ep.deprecated) result.deprecated = true;
+
+  if (ep.parameters.length > 0) {
+    result.parameters = ep.parameters.map(formatParamWithLocation);
+  }
+
+  if (ep.requestBodySchema) {
+    result.requestBody = isAnySchema(ep.requestBodySchema)
+      ? "any"
+      : compressSchema(ep.requestBodySchema);
+  }
+
+  for (const resp of ep.responses) {
+    const entry: { status: number; schema?: string } = { status: resp.statusCode };
+    if (resp.schema && !isAnySchema(resp.schema)) {
+      entry.schema = compressSchema(resp.schema);
+    }
+    result.responses.push(entry);
+  }
+
+  return result;
+}
+
+export function buildCatalog(params: BuildCatalogParams): ApiCatalog {
+  return {
+    generatedAt: new Date().toISOString(),
+    specSource: params.specSource,
+    specHash: params.specHash,
+    ...(params.apiName ? { apiName: params.apiName } : {}),
+    ...(params.apiVersion ? { apiVersion: params.apiVersion } : {}),
+    ...(params.baseUrl ? { baseUrl: params.baseUrl } : {}),
+    auth: params.securitySchemes.map(formatSecurityScheme),
+    endpointCount: params.endpoints.length,
+    endpoints: params.endpoints.map(buildCatalogEndpoint),
+  };
+}
+
+// --- YAML serialization ---
+
+function yamlEscape(value: string): string {
+  if (/[:{}\[\],&*#?|<>=!%@`"']/.test(value) || value.includes("\n")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+
+function yamlScalar(value: unknown): string {
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return yamlEscape(String(value));
+}
+
+export function serializeCatalog(catalog: ApiCatalog): string {
+  const lines: string[] = [];
+  lines.push("# Auto-generated by zond. Regenerate with: zond catalog <spec>");
+  lines.push(`generatedAt: ${yamlScalar(catalog.generatedAt)}`);
+  lines.push(`specSource: ${yamlScalar(catalog.specSource)}`);
+  lines.push(`specHash: ${yamlScalar(catalog.specHash)}`);
+  if (catalog.apiName) lines.push(`apiName: ${yamlScalar(catalog.apiName)}`);
+  if (catalog.apiVersion) lines.push(`apiVersion: ${yamlScalar(catalog.apiVersion)}`);
+  if (catalog.baseUrl) lines.push(`baseUrl: ${yamlScalar(catalog.baseUrl)}`);
+  lines.push(`endpointCount: ${catalog.endpointCount}`);
+
+  // Auth
+  if (catalog.auth.length > 0) {
+    lines.push("auth:");
+    for (const a of catalog.auth) {
+      lines.push(`  - ${yamlScalar(a)}`);
+    }
+  } else {
+    lines.push("auth: []");
+  }
+
+  // Endpoints
+  if (catalog.endpoints.length === 0) {
+    lines.push("endpoints: []");
+    return lines.join("\n") + "\n";
+  }
+  lines.push("endpoints:");
+  for (const ep of catalog.endpoints) {
+    lines.push(`  - method: ${ep.method}`);
+    lines.push(`    path: ${yamlScalar(ep.path)}`);
+    if (ep.summary) lines.push(`    summary: ${yamlScalar(ep.summary)}`);
+    if (ep.tags.length > 0) {
+      lines.push(`    tags: [${ep.tags.map(yamlScalar).join(", ")}]`);
+    }
+    if (ep.deprecated) lines.push(`    deprecated: true`);
+
+    if (ep.parameters && ep.parameters.length > 0) {
+      lines.push(`    parameters:`);
+      for (const p of ep.parameters) {
+        lines.push(`      - ${yamlScalar(p)}`);
+      }
+    }
+
+    if (ep.requestBody) {
+      lines.push(`    requestBody: ${yamlScalar(ep.requestBody)}`);
+    }
+
+    if (ep.responses.length > 0) {
+      lines.push(`    responses:`);
+      for (const r of ep.responses) {
+        if (r.schema) {
+          lines.push(`      - status: ${r.status}`);
+          lines.push(`        schema: ${yamlScalar(r.schema)}`);
+        } else {
+          lines.push(`      - status: ${r.status}`);
+        }
+      }
+    }
+  }
+
+  return lines.join("\n") + "\n";
+}

package/src/core/generator/index.ts

@@ -10,3 +10,5 @@ export type { GuideOptions } from "./guide-builder.ts";
 export type { EndpointWarning, WarningCode } from "./endpoint-warnings.ts";
 export type { EndpointInfo, ResponseInfo, GenerateOptions, SecuritySchemeInfo, CrudGroup } from "./types.ts";
 export { generateSuites, generateStep, detectCrudGroups, generateCrudSuite, generateSanitySuite, findUnresolvedVars } from "./suite-generator.ts";
+export { buildCatalog, serializeCatalog } from "./catalog-builder.ts";
+export type { ApiCatalog, CatalogEndpoint } from "./catalog-builder.ts";

package/src/db/queries.ts

@@ -255,7 +255,9 @@ export function saveResults(runId: number, suiteResults: TestRunResult[]): void
   db.transaction(() => {
     for (const suite of suiteResults) {
       for (const step of suite.steps) {
-        const keepBody = step.status === "fail" || step.status === "error";
+        const maxBodySize = 50_000;
+        const truncBody = (s: string | null | undefined) =>
+          s && s.length > maxBodySize ? s.slice(0, maxBodySize) + "\n...[truncated]" : (s ?? null);
         stmt.run({
           $run_id: runId,
           $suite_name: suite.suite_name,
@@ -264,10 +266,10 @@ export function saveResults(runId: number, suiteResults: TestRunResult[]): void
           $duration_ms: step.duration_ms,
           $request_method: step.request.method,
           $request_url: step.request.url,
-          $request_body: step.request.body ?? null,
+          $request_body: truncBody(step.request.body),
           $response_status: step.response?.status ?? null,
-          $response_body: keepBody ? (step.response?.body ?? null) : null,
-          $response_headers: keepBody && step.response?.headers
+          $response_body: truncBody(step.response?.body),
+          $response_headers: step.response?.headers
             ? JSON.stringify(step.response.headers)
             : null,
           $error_message: step.error ?? null,

package/src/web/data/collection-state.ts

@@ -40,6 +40,7 @@ export interface StepViewState {
   durationMs?: number;
   requestMethod?: string;
   requestUrl?: string;
+  requestBody?: string;
   responseStatus?: number;
   responseBody?: string;
   assertions?: { field: string; rule: string; passed: boolean; actual?: unknown; expected?: unknown }[];
@@ -281,6 +282,7 @@ export async function buildCollectionState(collection: CollectionRecord): Promis
           durationMs: r.duration_ms ?? undefined,
           requestMethod: r.request_method ?? undefined,
           requestUrl: r.request_url ?? undefined,
+          requestBody: r.request_body ?? undefined,
           responseStatus: r.response_status ?? undefined,
           responseBody: r.response_body ?? undefined,
           assertions: Array.isArray(r.assertions) ? r.assertions : undefined,

package/src/web/routes/api.ts

@@ -12,6 +12,7 @@ import {
   RunDetailSchema,
   RunIdParam,
 } from "../schemas.ts";
+import { renderProxyResponse, renderProxyError } from "../views/explorer-tab.ts";
 
 const api = new OpenAPIHono();
 
@@ -114,6 +115,85 @@ api.openapi(runRoute, async (c) => {
   }
 });
 
+// ──────────────────────────────────────────────
+// POST /api/proxy — Explorer proxy for HTTP requests
+// ──────────────────────────────────────────────
+
+api.post("/api/proxy", async (c) => {
+  const form = await c.req.parseBody();
+  const baseUrl = (form["base_url"] as string) ?? "";
+  const method = ((form["method"] as string) ?? "GET").toUpperCase();
+  let path = (form["path"] as string) ?? "/";
+  const body = (form["body"] as string) || undefined;
+  const contentType = (form["content_type"] as string) || undefined;
+
+  if (!baseUrl) {
+    return c.html(renderProxyError("Base URL is required", 0));
+  }
+
+  // Substitute path parameters
+  for (const [key, value] of Object.entries(form)) {
+    if (typeof key === "string" && key.startsWith("param_path_") && value) {
+      const paramName = key.slice("param_path_".length);
+      path = path.replace(`{${paramName}}`, encodeURIComponent(value as string));
+    }
+  }
+
+  // Build query string
+  const queryParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(form)) {
+    if (typeof key === "string" && key.startsWith("param_query_") && value) {
+      queryParams.set(key.slice("param_query_".length), value as string);
+    }
+  }
+
+  // Build headers
+  const headers: Record<string, string> = {};
+  for (const [key, value] of Object.entries(form)) {
+    if (typeof key === "string" && key.startsWith("param_header_") && value) {
+      headers[key.slice("param_header_".length)] = value as string;
+    }
+  }
+  // Custom headers
+  for (let i = 0; i < 50; i++) {
+    const k = form[`custom_header_key_${i}`] as string | undefined;
+    const v = form[`custom_header_value_${i}`] as string | undefined;
+    if (!k && !v) break;
+    if (k && v) headers[k] = v;
+  }
+
+  if (contentType && body) {
+    headers["Content-Type"] = contentType;
+  }
+
+  // Build URL
+  let url: URL;
+  try {
+    url = new URL(path, baseUrl.endsWith("/") ? baseUrl : baseUrl + "/");
+    queryParams.forEach((v, k) => url.searchParams.set(k, v));
+  } catch (err) {
+    return c.html(renderProxyError(`Invalid URL: ${baseUrl}${path} — ${(err as Error).message}`, 0));
+  }
+
+  const startTime = performance.now();
+  try {
+    const resp = await fetch(url.toString(), {
+      method,
+      headers,
+      body: ["GET", "HEAD"].includes(method) ? undefined : (body || undefined),
+    });
+    const elapsed = Math.round(performance.now() - startTime);
+    const respBody = await resp.text();
+    const respHeaders: Record<string, string> = {};
+    resp.headers.forEach((v, k) => { respHeaders[k] = v; });
+
+    return c.html(renderProxyResponse(resp.status, respHeaders, respBody, elapsed));
+  } catch (err) {
+    const elapsed = Math.round(performance.now() - startTime);
+    return c.html(renderProxyError((err as Error).message, elapsed));
+  }
+});
+
 // ──────────────────────────────────────────────
 // Export helpers
 // ──────────────────────────────────────────────

package/src/web/routes/dashboard.ts

@@ -5,6 +5,7 @@ import { renderHealthStrip } from "../views/health-strip.ts";
 import { renderEndpointsTab } from "../views/endpoints-tab.ts";
 import { renderSuitesTab } from "../views/suites-tab.ts";
 import { renderRunsTab, renderRunDetail } from "../views/runs-tab.ts";
+import { renderExplorerTab } from "../views/explorer-tab.ts";
 import { buildCollectionState, invalidateCollectionCache } from "../data/collection-state.ts";
 import {
   listCollections,
@@ -81,6 +82,16 @@ dashboard.get("/panels/endpoints", async (c) => {
   return c.html(renderEndpointsTab(state, filters));
 });
 
+dashboard.get("/panels/explorer", async (c) => {
+  const collectionId = parseInt(c.req.query("collection_id") ?? "", 10);
+  if (isNaN(collectionId)) return c.html("");
+
+  const collection = getCollectionById(collectionId);
+  if (!collection) return c.html("");
+
+  return c.html(await renderExplorerTab(collection));
+});
+
 dashboard.get("/panels/suites", async (c) => {
   const collectionId = parseInt(c.req.query("collection_id") ?? "", 10);
   if (isNaN(collectionId)) return c.html("");
@@ -243,6 +254,10 @@ async function renderCollectionContent(collection: CollectionRecord): Promise<st
         hx-get="/panels/runs-tab?collection_id=${collection.id}"
         hx-target="#tab-content" hx-swap="innerHTML"
         onclick="activateTab(this)">Runs <span class="tab-count">${runCount}</span></button>
+      <button class="tab-btn" data-tab="explorer"
+        hx-get="/panels/explorer?collection_id=${collection.id}"
+        hx-target="#tab-content" hx-swap="innerHTML"
+        onclick="activateTab(this)">Explorer</button>
     </div>`;
 
   // Default tab content (endpoints)
@@ -253,6 +268,28 @@ async function renderCollectionContent(collection: CollectionRecord): Promise<st
       document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('tab-active'));
       el.classList.add('tab-active');
     }
+    function switchToSuite(suiteName) {
+      var suitesBtn = document.querySelector('[data-tab="suites"]');
+      if (!suitesBtn) return;
+      suitesBtn.click();
+      document.addEventListener('htmx:afterSwap', function handler(e) {
+        if (e.detail.target && e.detail.target.id === 'tab-content') {
+          document.removeEventListener('htmx:afterSwap', handler);
+          setTimeout(function() {
+            var rows = document.querySelectorAll('.suite-row[data-suite-name]');
+            for (var i = 0; i < rows.length; i++) {
+              if (rows[i].dataset.suiteName === suiteName) {
+                rows[i].scrollIntoView({ behavior: 'smooth', block: 'center' });
+                rows[i].click();
+                rows[i].classList.add('suite-highlight');
+                setTimeout(function() { rows[i].classList.remove('suite-highlight'); }, 2000);
+                break;
+              }
+            }
+          }, 50);
+        }
+      });
+    }
   </script>`;
 
   return `