@jango-blockchained/hoox-cli 0.3.4

package/src/commands/test/test-command.ts

@@ -0,0 +1,412 @@
+/**
+ * `hoox test` command group — run tests and CI pipeline.
+ *
+ * Subcommands:
+ *   all         — Run full CI pipeline (lint → typecheck → unit → integration)
+ *   unit        — Run bun test (unit tests)
+ *   integration — Run vitest integration tests
+ *   worker      — Run tests for a specific worker directory
+ *   live        — Run live Cloudflare service tests (no mocks)
+ */
+import { Command } from "commander";
+import { spinner } from "@clack/prompts";
+import { ConfigService } from "../../services/config/index.js";
+import { theme, icons } from "../../utils/theme.js";
+import {
+  formatSuccess,
+  formatError,
+  formatTable,
+  formatJson,
+} from "../../utils/formatters.js";
+import { CLIError, ExitCode } from "../../utils/errors.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Result of a single pipeline step or test run. */
+export interface TestStepResult {
+  /** Human-readable step name (e.g. "Lint", "Unit Tests"). */
+  step: string;
+  /** The raw command string that was executed. */
+  command: string;
+  /** Whether the step exited with code 0. */
+  success: boolean;
+  /** Process exit code (null if the process failed to spawn). */
+  exitCode: number | null;
+  /** Wall-clock duration in milliseconds. */
+  duration: number;
+  /** Captured stdout (trimmed). */
+  output?: string;
+  /** Captured stderr or exception message. */
+  error?: string;
+}
+
+/** Aggregated summary of a test pipeline run. */
+export interface TestSummary {
+  total: number;
+  passed: number;
+  failed: number;
+  results: TestStepResult[];
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getFormatOptions(cmd: Command) {
+  const opts = cmd.optsWithGlobals();
+  return { json: Boolean(opts.json), quiet: Boolean(opts.quiet) };
+}
+
+/**
+ * Spawn a command with stdout/stderr piped, capture output, and return a
+ * structured result. Does NOT print anything — the caller decides display.
+ */
+export async function runStep(
+  args: string[],
+  cwd?: string
+): Promise<TestStepResult> {
+  const command = args.join(" ");
+  const start = Date.now();
+
+  try {
+    const proc = Bun.spawn(args, {
+      cwd: cwd ?? process.cwd(),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const duration = Date.now() - start;
+
+    return {
+      step: command,
+      command,
+      success: exitCode === 0,
+      exitCode,
+      duration,
+      output: stdout.trim() || undefined,
+      error: stderr.trim() ? stderr.trim() : undefined,
+    };
+  } catch (err) {
+    return {
+      step: command,
+      command,
+      success: false,
+      exitCode: null,
+      duration: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Spawn a command with stdout/stderr inherited so the user sees live output.
+ * Returns a minimal result with exit code.
+ */
+async function runWithInherit(
+  args: string[],
+  cwd?: string
+): Promise<TestStepResult> {
+  const command = args.join(" ");
+  const start = Date.now();
+
+  try {
+    const proc = Bun.spawn(args, {
+      cwd: cwd ?? process.cwd(),
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const exitCode = await proc.exited;
+    const duration = Date.now() - start;
+
+    return {
+      step: command,
+      command,
+      success: exitCode === 0,
+      exitCode,
+      duration,
+    };
+  } catch (err) {
+    return {
+      step: command,
+      command,
+      success: false,
+      exitCode: null,
+      duration: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Print a pipeline summary table (or JSON if --json is set).
+ * Quiet mode suppresses all output.
+ */
+export function printSummary(
+  summary: TestSummary,
+  opts: { json?: boolean; quiet?: boolean }
+): void {
+  if (opts.quiet) return;
+
+  if (opts.json) {
+    formatJson(summary, opts);
+    return;
+  }
+
+  const rows = summary.results.map((r) => ({
+    Step: r.step,
+    Status: r.success ? "passed" : "failed",
+    Time: `${r.duration}ms`,
+  }));
+
+  formatTable(rows, opts);
+
+  // Final status line
+  if (summary.failed > 0) {
+    formatError(
+      new CLIError(
+        `${summary.passed}/${summary.total} passed — ${summary.failed} failed`,
+        ExitCode.ERROR
+      ),
+      opts
+    );
+  } else {
+    formatSuccess(`All ${summary.total} steps passed`, opts);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline step definitions for `all` subcommand
+// ---------------------------------------------------------------------------
+
+const PIPELINE_STEPS: { label: string; args: string[] }[] = [
+  { label: "Lint", args: ["bun", "run", "lint"] },
+  { label: "TypeCheck", args: ["bun", "run", "typecheck"] },
+  { label: "Unit Tests", args: ["bun", "test", "--coverage"] },
+  {
+    label: "Integration Tests",
+    args: ["vitest", "run", "--config", "vitest.config.ts"],
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the `hoox test` command group with subcommands:
+ * all, unit, integration, worker, live.
+ */
+export function registerTestCommand(program: Command): void {
+  const testCmd = program
+    .command("test")
+    .description("Run tests and CI pipeline");
+
+  // -- test all ----------------------------------------------------------
+  testCmd
+    .command("all")
+    .description(
+      "Run full CI pipeline: lint → typecheck → unit tests → integration tests"
+    )
+    .option("--json", "Output results as JSON")
+    .action(async (options: { json?: boolean }) => {
+      const fmt = getFormatOptions(program);
+      // Allow local --json to override global
+      const useJson = options.json || fmt.json;
+      const opts = { json: useJson, quiet: fmt.quiet };
+
+      const results: TestStepResult[] = [];
+      const s = spinner();
+      s.start("Running CI pipeline...");
+
+      try {
+        for (const step of PIPELINE_STEPS) {
+          s.message(`${theme.info(icons.info)} ${step.label}...`);
+          const result = await runStep(step.args, process.cwd());
+          results.push({ ...result, step: step.label });
+
+          if (result.success) {
+            s.message(
+              `  ${theme.success(icons.success)} ${step.label} passed (${result.duration}ms)`
+            );
+          } else {
+            s.message(
+              `  ${theme.error(icons.error)} ${step.label} failed (${result.duration}ms)`
+            );
+            if (result.error) {
+              s.message(theme.dim(result.error.slice(0, 500)));
+            }
+            // Stop on first failure
+            break;
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        formatError(message, opts);
+        process.exitCode = ExitCode.ERROR;
+        s.stop("Pipeline aborted with unexpected error");
+        return;
+      }
+
+      const summary: TestSummary = {
+        total: results.length,
+        passed: results.filter((r) => r.success).length,
+        failed: results.filter((r) => !r.success).length,
+        results,
+      };
+
+      s.stop(
+        summary.failed > 0
+          ? `Pipeline complete: ${summary.passed} passed, ${summary.failed} failed`
+          : "Pipeline complete"
+      );
+
+      printSummary(summary, opts);
+
+      if (summary.failed > 0) {
+        process.exitCode = ExitCode.ERROR;
+      }
+    });
+
+  // -- test unit ---------------------------------------------------------
+  testCmd
+    .command("unit")
+    .description("Run unit tests with bun test")
+    .option("--coverage", "Run with coverage reporting")
+    .action(async (options: { coverage?: boolean }) => {
+      const fmt = getFormatOptions(program);
+      const args = ["bun", "test"];
+      if (options.coverage) args.push("--coverage");
+
+      const result = await runWithInherit(args, process.cwd());
+
+      if (result.success) {
+        formatSuccess("Unit tests passed", fmt);
+      } else {
+        formatError(
+          new CLIError(
+            `Unit tests failed (exit code ${result.exitCode})`,
+            ExitCode.ERROR
+          ),
+          fmt
+        );
+        process.exitCode = ExitCode.ERROR;
+      }
+    });
+
+  // -- test integration --------------------------------------------------
+  testCmd
+    .command("integration")
+    .description("Run integration tests with vitest")
+    .option("--coverage", "Run with coverage reporting")
+    .action(async (options: { coverage?: boolean }) => {
+      const fmt = getFormatOptions(program);
+      const args = ["vitest", "run", "--config", "vitest.config.ts"];
+      if (options.coverage) args.push("--coverage");
+
+      const result = await runWithInherit(args, process.cwd());
+
+      if (result.success) {
+        formatSuccess("Integration tests passed", fmt);
+      } else {
+        formatError(
+          new CLIError(
+            `Integration tests failed (exit code ${result.exitCode})`,
+            ExitCode.ERROR
+          ),
+          fmt
+        );
+        process.exitCode = ExitCode.ERROR;
+      }
+    });
+
+  // -- test worker <name> ------------------------------------------------
+  testCmd
+    .command("worker <name>")
+    .description("Run tests for a specific worker by name")
+    .option("--coverage", "Run with coverage reporting")
+    .action(async (name: string, options: { coverage?: boolean }) => {
+      const fmt = getFormatOptions(program);
+
+      try {
+        const configService = new ConfigService();
+        await configService.load();
+        const workerConfig = configService.getWorker(name);
+
+        if (!workerConfig) {
+          formatError(
+            new CLIError(
+              `Worker "${name}" not found in wrangler.jsonc`,
+              ExitCode.INVALID_USAGE
+            ),
+            fmt
+          );
+          process.exitCode = ExitCode.INVALID_USAGE;
+          return;
+        }
+
+        const workerDir = `${process.cwd()}/${workerConfig.path}`;
+        const args = ["bun", "test"];
+        if (options.coverage) args.push("--coverage");
+
+        const result = await runWithInherit(args, workerDir);
+
+        if (result.success) {
+          formatSuccess(`Worker "${name}" tests passed`, fmt);
+        } else {
+          formatError(
+            new CLIError(
+              `Worker "${name}" tests failed (exit code ${result.exitCode})`,
+              ExitCode.ERROR
+            ),
+            fmt
+          );
+          process.exitCode = ExitCode.ERROR;
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        formatError(message, fmt);
+        process.exitCode = ExitCode.ERROR;
+      }
+    });
+
+  // -- test live ---------------------------------------------------------
+  testCmd
+    .command("live")
+    .description("Run live Cloudflare service integration tests (no mocks)")
+    .option(
+      "--service <name>",
+      "Test a specific service: d1, kv, r2, queues, ai, api, secrets, durable-objects"
+    )
+    .action(async (options: { service?: string }) => {
+      const fmt = getFormatOptions(program);
+      const s = spinner();
+
+      try {
+        let filePattern = options.service
+          ? `tests/live/${options.service}.test.ts`
+          : "tests/live/";
+
+        s.start(`Running live tests${options.service ? ` for ${options.service}` : ""}...`);
+
+        const args = ["bun", "test", filePattern, "--jobs", "1"];
+        const result = await runWithInherit(args, process.cwd());
+
+        if (result.success) {
+          s.stop("Live tests complete");
+        } else {
+          s.stop(`Live tests: some failures (exit code ${result.exitCode})`);
+          process.exitCode = ExitCode.ERROR;
+        }
+      } catch (err) {
+        s.stop("Live tests aborted");
+        const message = err instanceof Error ? err.message : String(err);
+        formatError(message, fmt);
+        process.exitCode = ExitCode.ERROR;
+      }
+    });
+}

package/src/commands/waf/index.ts

@@ -0,0 +1,2 @@
+export { registerWafCommand } from "./waf-command.js";
+export type { WafStatus, WafRule, WafMode, WafRuleInput } from "./types.js";

package/src/commands/waf/types.ts

@@ -0,0 +1,48 @@
+/**
+ * Waf command type definitions.
+ */
+
+/** WAF status summary returned by `hoox waf status`. */
+export interface WafStatus {
+  /** Whether WAF protection is enabled on the zone. */
+  enabled: boolean;
+  /** WAF mode (e.g. "on", "off", "simulate"). */
+  mode: string;
+  /** Number of active firewall rules on the zone. */
+  activeRulesCount: number;
+  /** Approximate count of recent blocked requests (last 24h). */
+  recentBlocks: number;
+  /** Cloudflare zone ID. */
+  zoneId: string;
+  /** Cloudflare zone name (domain). */
+  zoneName: string;
+}
+
+/** A Cloudflare WAF / firewall rule. */
+export interface WafRule {
+  /** Unique rule identifier. */
+  id: string;
+  /** Human-readable description of the rule. */
+  description: string;
+  /** Rule mode: "block", "challenge", "js_challenge", "allow", "log". */
+  mode: string;
+  /** Cloudflare Filters expression that triggers the rule. */
+  expression: string;
+  /** ISO 8601 creation timestamp. */
+  created_at: string;
+  /** ISO 8601 last-modified timestamp. */
+  updated_at: string;
+}
+
+/** WAF toggle mode. */
+export type WafMode = "on" | "off";
+
+/** Input for creating a new WAF rule. */
+export interface WafRuleInput {
+  /** Rule type: "ip-allowlist", "ip-blocklist", "rate-limit", "custom". */
+  type: "ip-allowlist" | "ip-blocklist" | "rate-limit" | "custom";
+  /** Value associated with the rule type (IP address, requests/period, etc.). */
+  value: string;
+  /** Optional human-readable description. */
+  description?: string;
+}