@jango-blockchained/hoox-cli 0.5.2 → 0.5.6

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

@@ -1,406 +0,0 @@
-/**
- * `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,
-  getFormatOptions,
-} 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[];
-}
-
-/**
- * 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/tui/index.ts

@@ -1 +0,0 @@
-export { registerTUICommand } from "./tui-command.js";

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

@@ -1,87 +0,0 @@
-/**
- * `hoox tui` command — launch the OpenTUI terminal operations center.
- *
- * Spawns the TUI as a child Bun process so it can take over the terminal
- * with alternate screen mode. When the TUI exits, control returns to the CLI.
- */
-import { Command } from "commander";
-import { spawn } from "node:child_process";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
-import { theme } from "../../utils/theme.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-/** Resolve the TUI entry point relative to the monorepo root */
-function resolveTUIEntry(): string {
-  // Try monorepo-relative paths first
-  const candidates = [
-    resolve(__dirname, "../../../../tui/src/main.tsx"), // packages/cli → packages/tui
-    resolve(process.cwd(), "packages/tui/src/main.tsx"), // CWD = repo root
-    resolve(process.cwd(), "../tui/src/main.tsx"), // CWD = packages/cli
-  ];
-
-  for (const path of candidates) {
-    if (existsSync(path)) return path;
-  }
-
-  throw new CLIError(
-    "Could not find TUI entry point. Ensure packages/tui/src/main.tsx exists.",
-    ExitCode.ERROR
-  );
-}
-
-export function registerTUICommand(program: Command): void {
-  program
-    .command("tui")
-    .description("Launch the OpenTUI terminal operations center")
-    .option("--fps <number>", "Target frames per second", "30")
-    .option("--no-mouse", "Disable mouse support")
-    .action(async (options) => {
-      const tuiEntry = resolveTUIEntry();
-
-      console.log(
-        theme.heading("\nLaunching HOOX Terminal Operations Center...\n")
-      );
-      console.log(theme.dim(`  Entry: ${tuiEntry}`));
-      console.log(theme.dim(`  FPS:   ${options.fps}`));
-      console.log(
-        theme.dim(`  Mouse: ${options.mouse ? "enabled" : "disabled"}\n`)
-      );
-
-      // Spawn the TUI as a child process — it takes over the terminal
-      const child = spawn("bun", ["run", tuiEntry], {
-        stdio: "inherit", // TUI gets full terminal control
-        env: {
-          ...process.env,
-          TUI_FPS: options.fps,
-          TUI_MOUSE: options.mouse ? "1" : "0",
-        },
-      });
-
-      // Wait for TUI to exit
-      await new Promise<void>((resolveChild, reject) => {
-        child.on("close", (code) => {
-          if (code === 0) {
-            console.log(theme.dim("\nTUI session ended.\n"));
-            resolveChild();
-          } else if (code !== null) {
-            console.log(theme.dim(`\nTUI exited with code ${code}\n`));
-            resolveChild();
-          } else {
-            reject(
-              new CLIError("TUI process terminated abnormally", ExitCode.ERROR)
-            );
-          }
-        });
-
-        child.on("error", (err) => {
-          reject(
-            new CLIError(`Failed to launch TUI: ${err.message}`, ExitCode.ERROR)
-          );
-        });
-      });
-    });
-}

package/src/commands/update/index.ts

@@ -1 +0,0 @@
-export { registerUpdateCommand } from "./update-command.js";

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

@@ -1,109 +0,0 @@
-import { Command } from "commander";
-import { spinner } from "@clack/prompts";
-import { ConfigService } from "../../services/config/index.js";
-import { UpdateService } from "../../services/update/index.js";
-import { formatError, getFormatOptions } from "../../utils/formatters.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
-import { theme } from "../../utils/theme.js";
-import {
-  gitPull,
-  gitSubmoduleUpdate,
-  isGitRepo,
-  isSubmodule,
-} from "../../utils/git.js";
-
-export function registerUpdateCommand(program: Command): void {
-  program
-    .command("update")
-    .summary("Sync repo from GitHub or update wrangler")
-    .description(
-      `Update your local project from GitHub or update wrangler.
-
-Without arguments, pulls latest changes for the main repo.
-With a worker name, updates that worker's submodule from its remote.
-With "wrangler", updates wrangler to the latest version.
-
-EXAMPLES:
-  hoox update              Pull latest for main repo
-  hoox update d1-worker    Update the d1-worker submodule
-  hoox update wrangler     Update wrangler to latest version`
-    )
-    .argument(
-      "[target]",
-      'What to update: worker name (e.g. d1-worker) or "wrangler"'
-    )
-    .action(async (target?: string) => {
-      const fmt = getFormatOptions(program);
-      const cwd = process.cwd();
-
-      try {
-        if (target === "wrangler") {
-          const service = new UpdateService();
-          const result = await service.updateWrangler();
-
-          if (result.error) {
-            formatError(
-              new CLIError(`Update failed: ${result.error}`, ExitCode.ERROR),
-              fmt
-            );
-            process.exitCode = ExitCode.ERROR;
-          }
-          return;
-        }
-
-        if (!(await isGitRepo(cwd))) {
-          throw new CLIError(
-            "Not a git repository — run this command from the project root",
-            ExitCode.INVALID_USAGE
-          );
-        }
-
-        if (target) {
-          const configService = new ConfigService();
-          await configService.load();
-          const worker = configService.getWorker(target);
-
-          if (!worker) {
-            throw new CLIError(
-              `Unknown worker "${target}" — not found in wrangler.jsonc`,
-              ExitCode.INVALID_USAGE
-            );
-          }
-
-          const submodulePath = worker.path;
-          if (!(await isSubmodule(cwd, submodulePath))) {
-            throw new CLIError(
-              `"${submodulePath}" is not a git submodule — nothing to update`,
-              ExitCode.INVALID_USAGE
-            );
-          }
-
-          const s = spinner();
-          s.start(`Updating ${target}...`);
-
-          const output = await gitSubmoduleUpdate(cwd, submodulePath);
-
-          s.stop(
-            output
-              ? theme.success(`Updated ${target}`)
-              : theme.muted(`${target} already up to date`)
-          );
-        } else {
-          const s = spinner();
-          s.start("Pulling latest from remote...");
-
-          const output = await gitPull(cwd);
-
-          s.stop(
-            output
-              ? theme.success("Repository up to date")
-              : theme.muted("Already up to date")
-          );
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        formatError(message, fmt);
-        process.exitCode = ExitCode.ERROR;
-      }
-    });
-}

package/src/commands/waf/index.ts

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

package/src/commands/waf/types.ts

@@ -1,48 +0,0 @@
-/**
- * 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;
-}