@jango-blockchained/hoox-cli 0.5.2 → 0.5.7

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

@@ -1,243 +0,0 @@
-/**
- * Unit tests for the repair command.
- *
- * Stubs RepairService, CloudflareService, DbService, KvSyncService, and
- * SecretsService prototypes to verify repair command logic in isolation.
- * Uses Commander's exitOverride to suppress process exits during tests.
- */
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import { Command } from "commander";
-import { RepairService } from "./repair-service.js";
-import { CloudflareService } from "../../services/cloudflare/cloudflare-service.js";
-import { DbService } from "../../services/db/db-service.js";
-import { KvSyncService } from "../../services/kv/kv-sync-service.js";
-
-// Stubs
-let runSystemCheckMock: ReturnType<typeof mock>;
-let deployMock: ReturnType<typeof mock>;
-
-// Preserve originals
-const origRunSystemCheck = RepairService.prototype.runSystemCheck;
-const origDeploy = CloudflareService.prototype.deploy;
-const origD1List = CloudflareService.prototype.d1List;
-const origKvList = CloudflareService.prototype.kvList;
-const origR2List = CloudflareService.prototype.r2List;
-const origQueueList = CloudflareService.prototype.queueList;
-const origResolveDbName = DbService.prototype.resolveDbName;
-const origApply = DbService.prototype.apply;
-const origMigrate = DbService.prototype.migrate;
-const origExport = DbService.prototype.export;
-const origReset = DbService.prototype.reset;
-const origResolveNs = KvSyncService.prototype.resolveNamespaceId;
-const origKvSet = KvSyncService.prototype.set;
-
-beforeEach(() => {
-  mock.restore();
-  process.exitCode = 0;
-
-  // Restore originals
-  (
-    RepairService.prototype as unknown as Record<string, unknown>
-  ).runSystemCheck = origRunSystemCheck;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
-    origDeploy;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).d1List =
-    origD1List;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).kvList =
-    origKvList;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).r2List =
-    origR2List;
-  (
-    CloudflareService.prototype as unknown as Record<string, unknown>
-  ).queueList = origQueueList;
-  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
-    origResolveDbName;
-  (DbService.prototype as unknown as Record<string, unknown>).apply = origApply;
-  (DbService.prototype as unknown as Record<string, unknown>).migrate =
-    origMigrate;
-  (DbService.prototype as unknown as Record<string, unknown>).export =
-    origExport;
-  (DbService.prototype as unknown as Record<string, unknown>).reset = origReset;
-  (
-    KvSyncService.prototype as unknown as Record<string, unknown>
-  ).resolveNamespaceId = origResolveNs;
-  (KvSyncService.prototype as unknown as Record<string, unknown>).set =
-    origKvSet;
-
-  // Fresh mocks
-  runSystemCheckMock = mock(async () => ({
-    steps: [
-      { step: "Worker submodules", success: true, message: "All present" },
-      { step: "Dependencies", success: true, message: "Installed" },
-      { step: "TypeScript", success: true, message: "No errors" },
-      { step: "Infrastructure", success: true, message: "All ok" },
-      { step: "Secrets", success: true, message: "All present" },
-    ],
-    allPassed: true,
-    passedCount: 5,
-    failedCount: 0,
-  }));
-
-  deployMock = mock(async (_path: string, _env?: string) => ({
-    ok: true as const,
-    data: { url: "https://test-worker.cryptolinx.workers.dev" },
-  }));
-
-  (
-    RepairService.prototype as unknown as Record<string, unknown>
-  ).runSystemCheck = runSystemCheckMock;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
-    deployMock;
-});
-
-afterEach(() => {
-  mock.restore();
-  (
-    RepairService.prototype as unknown as Record<string, unknown>
-  ).runSystemCheck = origRunSystemCheck;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
-    origDeploy;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).d1List =
-    origD1List;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).kvList =
-    origKvList;
-  (CloudflareService.prototype as unknown as Record<string, unknown>).r2List =
-    origR2List;
-  (
-    CloudflareService.prototype as unknown as Record<string, unknown>
-  ).queueList = origQueueList;
-  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
-    origResolveDbName;
-  (DbService.prototype as unknown as Record<string, unknown>).apply = origApply;
-  (DbService.prototype as unknown as Record<string, unknown>).migrate =
-    origMigrate;
-  (DbService.prototype as unknown as Record<string, unknown>).export =
-    origExport;
-  (DbService.prototype as unknown as Record<string, unknown>).reset = origReset;
-  (
-    KvSyncService.prototype as unknown as Record<string, unknown>
-  ).resolveNamespaceId = origResolveNs;
-  (KvSyncService.prototype as unknown as Record<string, unknown>).set =
-    origKvSet;
-});
-
-async function importRepairCommand(): Promise<{
-  registerRepairCommand: typeof import("./repair-command.js").registerRepairCommand;
-}> {
-  return import("./repair-command.js");
-}
-
-async function createProgram(): Promise<Command> {
-  const { registerRepairCommand } = await importRepairCommand();
-  const program = new Command().name("hoox-test").exitOverride(() => {});
-  registerRepairCommand(program);
-  return program;
-}
-
-describe("registerRepairCommand", () => {
-  // -- Command registration -------------------------------------------------
-
-  it("registers 'repair' as a command on the program", async () => {
-    const program = await createProgram();
-    const cmd = program.commands.find((c) => c.name() === "repair");
-    expect(cmd).toBeDefined();
-  });
-
-  it("registers 'repair check' subcommand", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    expect(repairCmd.commands.find((c) => c.name() === "check")).toBeDefined();
-  });
-
-  it("registers 'repair worker <name>' with argument", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    const workerCmd = repairCmd.commands.find((c) => c.name() === "worker");
-    expect(workerCmd).toBeDefined();
-    expect(
-      workerCmd!.registeredArguments.some((a) => a.name() === "name")
-    ).toBe(true);
-  });
-
-  it("registers 'repair infra' subcommand", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    expect(repairCmd.commands.find((c) => c.name() === "infra")).toBeDefined();
-  });
-
-  it("registers 'repair secrets' subcommand", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    expect(
-      repairCmd.commands.find((c) => c.name() === "secrets")
-    ).toBeDefined();
-  });
-
-  it("registers 'repair kv' subcommand", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    expect(repairCmd.commands.find((c) => c.name() === "kv")).toBeDefined();
-  });
-
-  it("registers 'repair db' subcommand", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    expect(repairCmd.commands.find((c) => c.name() === "db")).toBeDefined();
-  });
-
-  it("registers 'repair rebuild' subcommand", async () => {
-    const program = await createProgram();
-    const repairCmd = program.commands.find((c) => c.name() === "repair")!;
-    expect(
-      repairCmd.commands.find((c) => c.name() === "rebuild")
-    ).toBeDefined();
-  });
-
-  // -- repair check ---------------------------------------------------------
-
-  describe("repair check", () => {
-    it("calls runSystemCheck", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["repair", "check"], { from: "user" });
-      expect(runSystemCheckMock).toHaveBeenCalled();
-    });
-
-    it("exits cleanly on all passed", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["repair", "check"], { from: "user" });
-      expect(process.exitCode).toBe(0);
-    });
-
-    it("sets exitCode on failure", async () => {
-      runSystemCheckMock = mock(async () => {
-        throw new Error("Check failed");
-      });
-      (
-        RepairService.prototype as unknown as Record<string, unknown>
-      ).runSystemCheck = runSystemCheckMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["repair", "check"], { from: "user" });
-      expect(process.exitCode).toBe(1);
-    });
-  });
-
-  // -- repair worker <name> --------------------------------------------------
-
-  describe("repair worker <name>", () => {
-    it("calls deploy for the specified worker", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["repair", "worker", "hoox"], { from: "user" });
-      expect(deployMock).toHaveBeenCalled();
-    });
-
-    it("handles unknown worker name", async () => {
-      // Mock getWorker to return undefined
-      const program = await createProgram();
-      await program.parseAsync(["repair", "worker", "nonexistent"], {
-        from: "user",
-      });
-      expect(process.exitCode).toBe(1);
-    });
-  });
-});

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

@@ -1,220 +0,0 @@
-import { Command } from "commander";
-import { RepairService } from "./repair-service.js";
-import { CloudflareService } from "../../services/cloudflare/index.js";
-import { DbService } from "../../services/db/index.js";
-import { KvSyncService } from "../../services/kv/kv-sync-service.js";
-import { SecretsService } from "../../services/secrets/index.js";
-import {
-  formatError,
-  formatSuccess,
-  type FormatOptions,
-  getFormatOptions,
-} from "../../utils/formatters.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
-
-async function handleCheck(fmt: FormatOptions): Promise<void> {
-  try {
-    const svc = new RepairService();
-    const result = await svc.runSystemCheck();
-    if (result.allPassed) {
-      formatSuccess("All checks passed", fmt);
-    } else {
-      formatError(
-        new CLIError(`${result.failedCount} check(s) failed`, ExitCode.ERROR),
-        fmt
-      );
-      process.exitCode = ExitCode.ERROR;
-    }
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function handleWorker(name: string, fmt: FormatOptions): Promise<void> {
-  try {
-    const { ConfigService } = await import("../../services/config/index.js");
-    const config = new ConfigService();
-    await config.load();
-    const workerConfig = config.getWorker(name);
-    if (!workerConfig) {
-      formatError(
-        new CLIError(`Worker "${name}" not found`, ExitCode.ERROR),
-        fmt
-      );
-      process.exitCode = ExitCode.ERROR;
-      return;
-    }
-    const cf = new CloudflareService();
-    const result = await cf.deploy(workerConfig.path);
-    if (result.ok) {
-      formatSuccess(`Worker "${name}" deployed — ${result.value.url}`, fmt);
-    } else {
-      formatError(
-        new CLIError(
-          `Failed to deploy "${name}": ${result.error}`,
-          ExitCode.ERROR
-        ),
-        fmt
-      );
-      process.exitCode = ExitCode.ERROR;
-    }
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function handleInfra(fmt: FormatOptions): Promise<void> {
-  try {
-    const cf = new CloudflareService();
-    const d1 = await cf.d1List();
-    const kv = await cf.kvList();
-    const r2 = await cf.r2List();
-    const q = await cf.queueList();
-    formatSuccess(
-      `D1: ${d1.ok ? "ok" : "fail"}, KV: ${kv.ok ? "ok" : "fail"}, R2: ${r2.ok ? "ok" : "fail"}, Queues: ${q.ok ? "ok" : "fail"}`,
-      fmt
-    );
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function handleSecrets(fmt: FormatOptions): Promise<void> {
-  try {
-    const secrets = await SecretsService.create();
-    const allSecrets = secrets.listAllSecrets();
-    let missing = 0;
-    for (const name of Object.keys(allSecrets)) {
-      const check = await secrets.checkLocalSecrets(name);
-      missing += check.missing.length;
-    }
-    if (missing > 0) {
-      formatError(
-        new CLIError(`${missing} secret(s) missing`, ExitCode.ERROR),
-        fmt
-      );
-      process.exitCode = ExitCode.ERROR;
-    } else {
-      formatSuccess("All secrets present", fmt);
-    }
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function handleKv(fmt: FormatOptions): Promise<void> {
-  try {
-    const kv = new KvSyncService();
-    const nsId = await kv.resolveNamespaceId();
-    formatSuccess(`KV namespace resolved: ${nsId}`, fmt);
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function handleDb(fmt: FormatOptions): Promise<void> {
-  try {
-    const svc = new DbService();
-    const dbName = await svc.resolveDbName();
-    await svc.apply(dbName, false);
-    formatSuccess(`DB "${dbName}" re-applied`, fmt);
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function handleRebuild(fmt: FormatOptions): Promise<void> {
-  try {
-    const repair = new RepairService();
-    await repair.runSystemCheck();
-    const cf = new CloudflareService();
-    const { ConfigService } = await import("../../services/config/index.js");
-    const config = new ConfigService();
-    await config.load();
-    for (const worker of config.listEnabledWorkers()) {
-      const cfg = config.getWorker(worker);
-      if (cfg) {
-        await cf.deploy(cfg.path);
-      }
-    }
-    formatSuccess("Rebuild complete", fmt);
-  } catch (err) {
-    formatError(err instanceof Error ? err : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-export function registerRepairCommand(program: Command): void {
-  const repairCmd = program
-    .command("repair")
-    .summary("Diagnose and repair the Hoox system")
-    .description(
-      "Run checks, deploy workers, or fix infrastructure, secrets, KV, and DB issues."
-    );
-
-  repairCmd
-    .command("check")
-    .description(
-      "Run system diagnostics (workers, deps, types, infra, secrets)"
-    )
-    .action(async () => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleCheck(fmt);
-    });
-
-  repairCmd
-    .command("worker <name>")
-    .description("Deploy a specific worker to fix it")
-    .action(async (name: string) => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleWorker(name, fmt);
-    });
-
-  repairCmd
-    .command("infra")
-    .description("Provision missing infrastructure (D1, KV, R2, Queues)")
-    .action(async () => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleInfra(fmt);
-    });
-
-  repairCmd
-    .command("secrets")
-    .description("Upload missing secrets to Cloudflare")
-    .action(async () => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleSecrets(fmt);
-    });
-
-  repairCmd
-    .command("kv")
-    .description("Re-sync KV namespace entries")
-    .action(async () => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleKv(fmt);
-    });
-
-  repairCmd
-    .command("db")
-    .description("Re-apply database schema")
-    .action(async () => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleDb(fmt);
-    });
-
-  repairCmd
-    .command("rebuild")
-    .description(
-      "Full rebuild: check, deploy all workers, fix infra/secrets/db"
-    )
-    .action(async () => {
-      const fmt = getFormatOptions(repairCmd);
-      await handleRebuild(fmt);
-    });
-}

package/src/commands/repair/repair-service.ts

@@ -1,164 +0,0 @@
-import { CloudflareService } from "../../services/cloudflare/index.js";
-import { SecretsService } from "../../services/secrets/index.js";
-import type { RepairStepResult, RepairCheckResult } from "./types.js";
-
-export class RepairService {
-  async runSystemCheck(): Promise<RepairCheckResult> {
-    const steps: RepairStepResult[] = [];
-
-    // Step 1: Repository integrity (worker submodules)
-    try {
-      const proc = Bun.spawn(["bun", "run", "check:worker-submodules"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const exit = await proc.exited;
-      steps.push({
-        step: "Worker submodules",
-        success: exit === 0,
-        message: exit === 0 ? "All submodules present" : "Missing submodules",
-      });
-    } catch (err) {
-      steps.push({
-        step: "Worker submodules",
-        success: false,
-        error: String(err),
-      });
-    }
-
-    // Step 2: Dependencies
-    try {
-      const proc = Bun.spawn(["bun", "install"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const exit = await proc.exited;
-      steps.push({
-        step: "Dependencies",
-        success: exit === 0,
-        message:
-          exit === 0 ? "All dependencies installed" : "bun install failed",
-      });
-    } catch (err) {
-      steps.push({ step: "Dependencies", success: false, error: String(err) });
-    }
-
-    // Step 3: TypeScript
-    try {
-      const proc = Bun.spawn(["bun", "run", "typecheck"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const exit = await proc.exited;
-      steps.push({
-        step: "TypeScript",
-        success: exit === 0,
-        message: exit === 0 ? "No type errors" : "TypeScript errors found",
-      });
-    } catch (err) {
-      steps.push({ step: "TypeScript", success: false, error: String(err) });
-    }
-
-    // Step 4: Infrastructure
-    try {
-      const cf = new CloudflareService();
-      const d1Result = await cf.d1List();
-      const kvResult = await cf.kvList();
-      const r2Result = await cf.r2List();
-      const queueResult = await cf.queueList();
-
-      let infraOk = true;
-      const details: string[] = [];
-      if (d1Result.ok) details.push("D1: ✓");
-      else {
-        infraOk = false;
-        details.push("D1: ✗");
-      }
-      if (kvResult.ok) details.push("KV: ✓");
-      else {
-        infraOk = false;
-        details.push("KV: ✗");
-      }
-      if (r2Result.ok) details.push("R2: ✓");
-      else {
-        infraOk = false;
-        details.push("R2: ✗");
-      }
-      if (queueResult.ok) details.push("Queues: ✓");
-      else {
-        infraOk = false;
-        details.push("Queues: ✗");
-      }
-
-      steps.push({
-        step: "Infrastructure",
-        success: infraOk,
-        message: details.join(", "),
-      });
-    } catch (err) {
-      steps.push({
-        step: "Infrastructure",
-        success: false,
-        error: String(err),
-      });
-    }
-
-    // Step 5: Secrets
-    try {
-      const secrets = await SecretsService.create();
-      const allSecrets = secrets.listAllSecrets();
-      let missingCount = 0;
-      let totalSecrets = 0;
-      for (const workerName of Object.keys(allSecrets)) {
-        const check = await secrets.checkLocalSecrets(workerName);
-        totalSecrets += check.secrets.length;
-        missingCount += check.missing.length;
-      }
-      steps.push({
-        step: "Secrets",
-        success: missingCount === 0,
-        message:
-          missingCount === 0
-            ? `All ${totalSecrets} secrets present`
-            : `${missingCount}/${totalSecrets} missing`,
-      });
-    } catch (err) {
-      steps.push({ step: "Secrets", success: false, error: String(err) });
-    }
-
-    // Step 6: Worker config schema validation
-    try {
-      const { SchemaService } =
-        await import("../../services/schema/schema-service.js");
-      const svc = new SchemaService();
-      const results = svc.validateAll();
-      const totalErrors = results.reduce(
-        (sum, r) => sum + r.errors.filter((e) => e.severity === "error").length,
-        0
-      );
-      steps.push({
-        step: "Worker config schema",
-        success: totalErrors === 0,
-        message:
-          totalErrors === 0
-            ? "All workers match manifest"
-            : `${totalErrors} schema issue(s) found`,
-      });
-    } catch (err) {
-      steps.push({
-        step: "Worker config schema",
-        success: false,
-        error: String(err),
-      });
-    }
-
-    const passed = steps.filter((s) => s.success).length;
-    const failed = steps.filter((s) => !s.success).length;
-    return {
-      steps,
-      allPassed: failed === 0,
-      passedCount: passed,
-      failedCount: failed,
-    };
-  }
-}

package/src/commands/repair/types.ts

@@ -1,13 +0,0 @@
-export interface RepairStepResult {
-  step: string;
-  success: boolean;
-  message?: string;
-  error?: string;
-}
-
-export interface RepairCheckResult {
-  steps: RepairStepResult[];
-  allPassed: boolean;
-  passedCount: number;
-  failedCount: number;
-}

package/src/commands/schema/index.ts

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