@runa-ai/runa-cli 0.5.71 → 0.6.0

package/dist/test-QYXE5UVW.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { emitJsonSuccess } from './chunk-UU55OH7P.js';
+import './chunk-RRGQCUKT.js';
+import './chunk-JT5SUTWE.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { runTest, TestRunOutputSchema, CLIError, runTestService, TestServiceOutputSchema, runTestIntegration, TestIntegrationOutputSchema, runTestStatic, TestStaticOutputSchema, createCLILogger, generateOwaspTop10Tests, TestOwaspGenerateOutputSchema } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+
+createRequire(import.meta.url);
+
+// src/commands/test/index.ts
+init_esm_shims();
+
+// src/commands/test/commands/test.ts
+init_esm_shims();
+function resolveEffectiveRequireManifest(options) {
+  if (options.requireManifest && options.allowManifestFallback) {
+    throw new CLIError(
+      "--require-manifest and --allow-manifest-fallback are mutually exclusive",
+      "TEST_MANIFEST_FLAGS_EXCLUSIVE",
+      ["Use strict mode (default) OR explicitly allow fallback, but not both"]
+    );
+  }
+  if (options.allowManifestFallback) return false;
+  return options.requireManifest;
+}
+var testCommand = new Command("test").description("Run tests (compat). Prefer: test:layer0..4 or test:static/service/integration.").option("--layer <number>", "Run specific layer (0-4)").option("--from <number>", "Run from layer N to 4").option("--to <number>", "Run from layer 0 to N").option("--ci", "CI mode (fail fast, no interactive)").option("--verbose", "Verbose output").option("--record", "Record test results to database", true).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--generate", "Generate tests from XState before running (integration)").option("--advanced", "Generate advanced tests (integration)").option("--auto", "Zero-config auto-generation (integration)").option("--base-url <url>", "Override base URL (integration)").option("--changed", "Run only impacted layers based on git diff (service)").option("--base <ref>", "Base ref for --changed (service)").option("--skip-missing", "Skip layers with missing dependencies instead of failing").option(
+  "--require-manifest",
+  "Require manifest to be present and valid for Layer 3/4 tests (strict behavior)"
+).option(
+  "--allow-manifest-fallback",
+  "Allow fallback behavior when manifest is missing/invalid (disables Layer 4 strict default)"
+).action(async (options) => {
+  try {
+    const effectiveRequireManifest = resolveEffectiveRequireManifest(options);
+    const output = await runTest({
+      layer: options.layer !== void 0 ? Number.parseInt(options.layer, 10) : void 0,
+      from: options.from !== void 0 ? Number.parseInt(options.from, 10) : void 0,
+      to: options.to !== void 0 ? Number.parseInt(options.to, 10) : void 0,
+      ci: options.ci ?? false,
+      verbose: options.verbose,
+      record: options.record,
+      reportJson: options.reportJson,
+      generate: options.generate,
+      advanced: options.advanced,
+      auto: options.auto,
+      baseUrl: options.baseUrl,
+      changed: options.changed,
+      base: options.base,
+      skipMissing: options.skipMissing,
+      requireManifest: effectiveRequireManifest
+    });
+    emitJsonSuccess(testCommand, TestRunOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      "Test execution failed",
+      "TEST_EXECUTION_FAILED",
+      [
+        "Check error details above",
+        "Prefer new commands: runa test:layer0..4 or runa test:static/service/integration",
+        "Verify environment: runa check"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-db.ts
+init_esm_shims();
+var testDbCommand = new Command("test:db").description("Run Layer 2-3: Database tests (schema + api) - Requires PostgreSQL").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--verbose", "Verbose output (full error details, environment info)").option("--changed", "Run only impacted layers based on git diff").option(
+  "--base <ref>",
+  "Base ref for --changed (default: $RUNA_TEST_BASE_REF or $GITHUB_BASE_REF)"
+).option("--layer <layer>", "Run specific layer: 2/schema, 3/api, or all (default: all)").action(async (options) => {
+  try {
+    const layers = options.layer === "2" || options.layer === "schema" ? [2] : options.layer === "3" || options.layer === "api" ? [3] : [2, 3];
+    const output = await runTestService({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      changed: options.changed,
+      base: options.base,
+      layers
+    });
+    emitJsonSuccess(testDbCommand, TestServiceOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Database test execution failed",
+      "TEST_DB_EXECUTION_FAILED",
+      ["Check error details above", "Verify environment: runa check"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var testSchemaCommand = new Command("test:schema").description("Run Layer 2: Schema tests (Drizzle, RLS, pgTAP) - Alias for test:layer2").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option("--report-json <path>", "Export test report as JSON").option("--verbose", "Verbose output").action(async (options) => {
+  try {
+    const output = await runTestService({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      layers: [2]
+    });
+    emitJsonSuccess(testSchemaCommand, TestServiceOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Schema test execution failed",
+      "TEST_SCHEMA_EXECUTION_FAILED",
+      ["Check error details above", "Verify environment: runa check"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var testApiCommand = new Command("test:api").description("Run Layer 3: API tests (Hono RPC, Contract, Integration) - Alias for test:layer3").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option("--report-json <path>", "Export test report as JSON").option("--verbose", "Verbose output").action(async (options) => {
+  try {
+    const output = await runTestService({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      layers: [3]
+    });
+    emitJsonSuccess(testApiCommand, TestServiceOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "API test execution failed",
+      "TEST_API_EXECUTION_FAILED",
+      ["Check error details above", "Verify environment: runa check"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-e2e.ts
+init_esm_shims();
+function resolveEffectiveRequireManifest2(options) {
+  if (options.requireManifest && options.allowManifestFallback) {
+    throw new CLIError(
+      "--require-manifest and --allow-manifest-fallback are mutually exclusive",
+      "TEST_E2E_MANIFEST_FLAGS_EXCLUSIVE",
+      ["Use strict mode (default) OR explicitly allow fallback, but not both"]
+    );
+  }
+  if (options.allowManifestFallback) return false;
+  return options.requireManifest;
+}
+var testE2ECommand = new Command("test:e2e").description("Run Layer 4: E2E tests (Playwright) - Requires browser").option("--generate", "Generate tests from XState before running").option("--advanced", "Generate advanced tests (context-aware, guards, invariants, etc.)").option("--auto", "Zero-config auto-generation (implementation-driven)").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option("--base-url <url>", "Explicit base URL for E2E (disables auto dev server start)").option(
+  "--require-manifest",
+  "Require manifest to be present and valid (strict behavior; enabled by default for Layer 4)"
+).option(
+  "--allow-manifest-fallback",
+  "Allow fallback behavior when manifest is missing/invalid (disables Layer 4 strict default)"
+).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--verbose", "Verbose output (full error details, environment info)").action(async (options) => {
+  try {
+    const effectiveRequireManifest = resolveEffectiveRequireManifest2(options);
+    const output = await runTestIntegration({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      generate: options.generate,
+      advanced: options.advanced,
+      auto: options.auto,
+      baseUrl: options.baseUrl,
+      requireManifest: effectiveRequireManifest,
+      invokedAs: "runa test:e2e"
+    });
+    emitJsonSuccess(testE2ECommand, TestIntegrationOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "E2E test execution failed",
+      "TEST_E2E_EXECUTION_FAILED",
+      [
+        "Check error details above",
+        "Verify environment: runa check",
+        "Verify browser is available: npx playwright install",
+        "Verify environment: runa check"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var testBrowserCommand = new Command("test:browser").description("Run Layer 4: Browser tests (Playwright E2E) - Alias for test:e2e").option("--generate", "Generate tests from XState before running").option("--advanced", "Generate advanced tests").option("--auto", "Zero-config auto-generation").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option("--base-url <url>", "Explicit base URL for E2E").option(
+  "--require-manifest",
+  "Require manifest to be present and valid (strict behavior; enabled by default for Layer 4)"
+).option(
+  "--allow-manifest-fallback",
+  "Allow fallback behavior when manifest is missing/invalid (disables Layer 4 strict default)"
+).option("--report-json <path>", "Export test report as JSON").option("--verbose", "Verbose output").action(async (options) => {
+  try {
+    const effectiveRequireManifest = resolveEffectiveRequireManifest2(options);
+    const output = await runTestIntegration({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      generate: options.generate,
+      advanced: options.advanced,
+      auto: options.auto,
+      baseUrl: options.baseUrl,
+      requireManifest: effectiveRequireManifest,
+      invokedAs: "runa test:browser"
+    });
+    emitJsonSuccess(testBrowserCommand, TestIntegrationOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Browser test execution failed",
+      "TEST_BROWSER_EXECUTION_FAILED",
+      ["Check error details above", "Verify browser is available: npx playwright install"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-fast.ts
+init_esm_shims();
+var testFastCommand = new Command("test:fast").description("Run Layer 0-1: Fast tests (lint + logic) - No DB required").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--verbose", "Verbose output (full error details, environment info)").option("--security", "Force security checks (pnpm audit) in local mode").option("--layer <layer>", "Run specific layer: 0/lint, 1/logic, or all (default: all)").action(async (options) => {
+  try {
+    const output = await runTestStatic({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      security: options.security
+    });
+    emitJsonSuccess(testFastCommand, TestStaticOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Fast test execution failed",
+      "TEST_FAST_EXECUTION_FAILED",
+      [
+        "Check error details above",
+        "Verify environment: runa check",
+        "Review test configuration"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var testLintCommand = new Command("test:lint").description("Run Layer 0: Lint (type-check, biome, build) - Alias for test:layer0").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option("--report-json <path>", "Export test report as JSON").option("--verbose", "Verbose output").option("--security", "Force security checks (pnpm audit)").action(async (options) => {
+  try {
+    const output = await runTestStatic({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      security: options.security
+    });
+    emitJsonSuccess(testLintCommand, TestStaticOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Lint test execution failed",
+      "TEST_LINT_EXECUTION_FAILED",
+      ["Check error details above", "Verify environment: runa check"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-integration.ts
+init_esm_shims();
+function resolveEffectiveRequireManifest3(options) {
+  if (options.requireManifest && options.allowManifestFallback) {
+    throw new CLIError(
+      "--require-manifest and --allow-manifest-fallback are mutually exclusive",
+      "TEST_INTEGRATION_MANIFEST_FLAGS_EXCLUSIVE",
+      ["Use strict mode (default) OR explicitly allow fallback, but not both"]
+    );
+  }
+  if (options.allowManifestFallback) return false;
+  return options.requireManifest;
+}
+var testIntegrationCommand = new Command("test:integration").description("Run Layer 4: Integration tests (E2E) with auto-generation").option("--generate", "Generate tests from XState before running").option("--advanced", "Generate advanced tests (context-aware, guards, invariants, etc.)").option("--auto", "Zero-config auto-generation (implementation-driven)").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option("--base-url <url>", "Explicit base URL for E2E/Security (disables auto dev server start)").option(
+  "--require-manifest",
+  "Require manifest to be present and valid (strict behavior; enabled by default for Layer 4)"
+).option(
+  "--allow-manifest-fallback",
+  "Allow fallback behavior when manifest is missing/invalid (disables Layer 4 strict default)"
+).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--verbose", "Verbose output (full error details, environment info)").action(async (options) => {
+  try {
+    const effectiveRequireManifest = resolveEffectiveRequireManifest3(options);
+    const output = await runTestIntegration({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      generate: options.generate,
+      advanced: options.advanced,
+      auto: options.auto,
+      baseUrl: options.baseUrl,
+      requireManifest: effectiveRequireManifest,
+      invokedAs: "runa test:integration"
+    });
+    emitJsonSuccess(testIntegrationCommand, TestIntegrationOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Integration test execution failed",
+      "TEST_INTEGRATION_EXECUTION_FAILED",
+      [
+        "Check error details above",
+        "Verify environment: runa check",
+        "Verify environment: runa check"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-layer.ts
+init_esm_shims();
+function injectTestAttrsIfLayer4(layer, options) {
+  if (layer !== 4) return;
+  const { verbose, requireManifest } = options ?? {};
+  try {
+    if (verbose) {
+      console.log("[Layer 4] Auto-injecting XState test attributes...");
+    }
+    execSync("pnpm exec runa inject-test-attrs", {
+      cwd: process.cwd(),
+      stdio: verbose ? "inherit" : "pipe"
+    });
+    if (verbose) {
+      console.log("[Layer 4] Test attributes injected successfully");
+    }
+  } catch (error) {
+    if (requireManifest) {
+      throw new CLIError(
+        "XState test attribute injection failed",
+        "INJECT_TEST_ATTRS_FAILED",
+        [
+          "Run `runa inject-test-attrs` manually to see detailed errors",
+          "Ensure XState machines exist in your project",
+          "Check that machines have valid meta.e2e definitions",
+          "Or pass --allow-manifest-fallback to continue with fallback behavior"
+        ],
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (verbose) {
+      console.warn("[Layer 4] Test attribute injection failed, continuing with tests");
+    }
+  }
+}
+function resolveEffectiveRequireManifest4(layer, options) {
+  if (options.allowManifestFallback) return false;
+  if (options.requireManifest !== void 0) return options.requireManifest;
+  if (layer === 4 && process.env.RUNA_LAYER4_ALLOW_MANIFEST_FALLBACK !== "true") return true;
+  return void 0;
+}
+async function runSingleLayer(params) {
+  const effectiveRequireManifest = resolveEffectiveRequireManifest4(params.layer, params.options);
+  injectTestAttrsIfLayer4(params.layer, {
+    verbose: params.options.verbose,
+    requireManifest: effectiveRequireManifest
+  });
+  try {
+    const output = await runTest({
+      layer: params.layer,
+      ci: params.options.ci ?? false,
+      verbose: params.options.verbose,
+      reportJson: params.options.reportJson,
+      baseUrl: params.options.baseUrl,
+      generate: params.options.generate,
+      advanced: params.options.advanced,
+      auto: params.options.auto,
+      updateSnapshots: params.options.updateSnapshots,
+      filter: params.options.filter,
+      reviewSnapshots: params.options.reviewSnapshots,
+      forceRegenerate: params.options.force,
+      skipGeneration: params.options.skipGeneration,
+      requireManifest: effectiveRequireManifest,
+      invokedAs: `runa test:layer${params.layer}`
+    });
+    emitJsonSuccess(params.cmd, TestRunOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      `Layer ${params.layer} failed`,
+      "TEST_LAYER_FAILED",
+      ["Check error details above", "Verify environment: runa check"],
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function validateGenerationFlags(layer, opts) {
+  if (layer < 4 && (opts.generate || opts.advanced || opts.auto)) {
+    throw new CLIError(
+      "--generate/--advanced/--auto are only supported for Layer 4",
+      "TEST_LAYER_GENERATION_UNSUPPORTED",
+      ["Remove generation flags, or run: runa test:layer4 --generate/--auto"]
+    );
+  }
+  if (opts.advanced && !opts.generate) {
+    throw new CLIError("--advanced requires --generate", "TEST_LAYER_ADVANCED_REQUIRES_GENERATE", [
+      "Add --generate, or remove --advanced"
+    ]);
+  }
+  if (opts.auto && (opts.generate || opts.advanced)) {
+    throw new CLIError(
+      "--auto is mutually exclusive with --generate/--advanced",
+      "TEST_LAYER_AUTO_MUTUALLY_EXCLUSIVE",
+      ["Use --auto (implementation-driven) OR --generate/--advanced (XState-driven)"]
+    );
+  }
+  if (layer === 4 && opts.requireManifest && opts.allowManifestFallback) {
+    throw new CLIError(
+      "--require-manifest and --allow-manifest-fallback are mutually exclusive",
+      "TEST_LAYER_MANIFEST_FLAGS_EXCLUSIVE",
+      ["Use strict mode (default) OR explicitly allow fallback, but not both"]
+    );
+  }
+}
+function validateSnapshotFlags(opts) {
+  if (opts.reviewSnapshots && opts.ci) {
+    throw new CLIError(
+      "--review-snapshots requires interactive mode (cannot use with --ci)",
+      "TEST_LAYER_REVIEW_REQUIRES_INTERACTIVE",
+      ["Remove --ci flag to use interactive snapshot review"]
+    );
+  }
+  if (opts.reviewSnapshots && opts.updateSnapshots) {
+    throw new CLIError(
+      "--review-snapshots and --update-snapshots are mutually exclusive",
+      "TEST_LAYER_REVIEW_UPDATE_EXCLUSIVE",
+      ["Use --review-snapshots for selective approval, or --update-snapshots for bulk update"]
+    );
+  }
+}
+function createLayerCommand(layer) {
+  const cmd = new Command(`test:layer${layer}`).description(`Run Layer ${layer} only (canonical CLI notation)`).option("--ci", "CI mode (fail fast, no interactive)").option("--verbose", "Verbose output (full tool logs, environment info)").option("--base-url <url>", "Explicit base URL for E2E (Layer 4)").hook("preAction", (_thisCommand, actionCommand) => {
+    const opts = actionCommand.opts();
+    validateGenerationFlags(layer, opts);
+    validateSnapshotFlags(opts);
+  }).option(
+    "--report-json <path>",
+    "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+  ).action(async (options) => {
+    await runSingleLayer({ cmd, layer, options });
+  });
+  if (layer === 3) {
+    cmd.option("--skip-generation", "Skip auto-generation of API tests (run manual tests only)").option(
+      "--require-manifest",
+      "Require manifest to be present and valid (fail if missing or stale)"
+    );
+  }
+  if (layer >= 4) {
+    cmd.option("--generate", "Generate tests from XState before running (Layer 4)").option("--advanced", "Generate advanced tests (requires --generate)").option("--auto", "Zero-config auto-generation (implementation-driven)").option("--update-snapshots", "Update visual baselines (Layer 4)").option("--filter <pattern>", 'Filter tests by pattern (e.g., "checkout-*")').option("--review-snapshots", "Interactive review of changed visual snapshots (Layer 4)").option("--force", "Force regenerate all tests, bypassing cache").option(
+      "--require-manifest",
+      "Require manifest to be present and valid (fail if missing or stale)"
+    ).option(
+      "--allow-manifest-fallback",
+      "Allow fallback behavior when manifest is missing/invalid (disables Layer 4 strict default)"
+    );
+  }
+  return cmd;
+}
+var testLayer0Command = createLayerCommand(0);
+var testLayer1Command = createLayerCommand(1);
+var testLayer2Command = createLayerCommand(2);
+var testLayer3Command = createLayerCommand(3);
+var testLayer4Command = createLayerCommand(4);
+function createAliasCommand(alias, layer, description) {
+  const cmd = new Command(`test:${alias}`).description(`${description} - Alias for test:layer${layer}`).option("--ci", "CI mode (fail fast, no interactive)").option("--verbose", "Verbose output (full tool logs, environment info)").option(
+    "--report-json <path>",
+    "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+  ).action(async (options) => {
+    await runSingleLayer({ cmd, layer, options });
+  });
+  return cmd;
+}
+var testLogicCommand = createAliasCommand(
+  "logic",
+  1,
+  "Run Layer 1: Logic tests (XState, pure functions)"
+);
+
+// src/commands/test/commands/test-owasp-generate.ts
+init_esm_shims();
+var testOWASPGenerateCommand = new Command("test:owasp:generate").description("Generate OWASP Top 10 security tests (zero-config, auto-detect)").option("--verbose", "Verbose output").action(async (options) => {
+  const logger = createCLILogger("test:owasp:generate");
+  try {
+    logger.section("OWASP Top 10 Test Generation (Zero-Config)");
+    logger.info("Auto-detecting API routes from your project...");
+    const result = await generateOwaspTop10Tests({ verbose: options.verbose });
+    if (result.success) {
+      logger.section("Generation Complete");
+      logger.success(`Generated ${result.totalFiles} OWASP test files`);
+      if (result.errors.length > 0) {
+        logger.warn(`
+\u26A0\uFE0F  ${result.errors.length} warnings:`);
+        for (const error of result.errors) {
+          logger.warn(`   ${error}`);
+        }
+      }
+    } else {
+      logger.error("Generation failed");
+      throw new CLIError(
+        "Failed to generate OWASP tests",
+        "OWASP_GENERATION_FAILED",
+        result.errors
+      );
+    }
+    emitJsonSuccess(testOWASPGenerateCommand, TestOwaspGenerateOutputSchema, result);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      "OWASP test generation failed",
+      "OWASP_GENERATION_ERROR",
+      ["Check project structure", "Ensure API routes exist"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-service.ts
+init_esm_shims();
+var testServiceCommand = new Command("test:service").description("Run Layer 1-3: Service tests (XState, DB, API Contracts)").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--verbose", "Verbose output (full error details, environment info)").option("--changed", "Run only impacted layers based on git diff").option(
+  "--base <ref>",
+  "Base ref for --changed (default: $RUNA_TEST_BASE_REF or $GITHUB_BASE_REF)"
+).action(async (options) => {
+  try {
+    const output = await runTestService({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      changed: options.changed,
+      base: options.base
+    });
+    emitJsonSuccess(testServiceCommand, TestServiceOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Service test execution failed",
+      "TEST_SERVICE_EXECUTION_FAILED",
+      [
+        "Check error details above",
+        "Verify environment: runa check",
+        "Verify environment: runa check"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/test/commands/test-static.ts
+init_esm_shims();
+var testStaticCommand = new Command("test:static").description("Run Layer 0: Static analysis (type-check, lint, build, package quality)").option("--ci", "CI mode (fail fast, no interactive)").option("--record", "Record test results to database", true).option(
+  "--report-json <path>",
+  "Export test report as JSON. If <path> is a bare filename, it will be written under .runa/tmp/."
+).option("--verbose", "Verbose output (full error details, environment info)").option("--security", "Force security checks (pnpm audit) in local mode").action(async (options) => {
+  try {
+    const output = await runTestStatic({
+      ci: options.ci ?? false,
+      record: options.record,
+      reportJson: options.reportJson,
+      verbose: options.verbose,
+      security: options.security
+    });
+    emitJsonSuccess(testStaticCommand, TestStaticOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Static test execution failed",
+      "TEST_STATIC_EXECUTION_FAILED",
+      [
+        "Check error details above",
+        "Verify environment: runa check",
+        "Review test configuration"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+export { testApiCommand, testBrowserCommand, testCommand, testDbCommand, testE2ECommand, testFastCommand, testIntegrationCommand, testLayer0Command, testLayer1Command, testLayer2Command, testLayer3Command, testLayer4Command, testLintCommand, testLogicCommand, testOWASPGenerateCommand, testSchemaCommand, testServiceCommand, testStaticCommand };