@jango-blockchained/hoox-cli 0.3.4

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

@@ -0,0 +1,50 @@
+import { ConfigService } from "../../services/config/index.js";
+import type { WorkerHealthResult } from "./types.js";
+
+export class MonitorService {
+  private configService: ConfigService;
+
+  constructor(configService?: ConfigService) {
+    this.configService = configService ?? new ConfigService();
+  }
+
+  async checkAllWorkerHealth(): Promise<{
+    workers: WorkerHealthResult[];
+    healthyCount: number;
+    degradedCount: number;
+    unreachableCount: number;
+  }> {
+    await this.configService.load();
+    const global = this.configService.getGlobal();
+    const prefix = global.subdomain_prefix ?? "hoox";
+    const enabled = this.configService.listEnabledWorkers();
+
+    const results: WorkerHealthResult[] = [];
+    let healthy = 0;
+    let degraded = 0;
+    let unreachable = 0;
+
+    for (const name of enabled) {
+      const url = `https://${name}.${prefix}.workers.dev/health`;
+      try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+        if (response.ok) {
+          results.push({ worker: name, status: "healthy", statusCode: response.status });
+          healthy++;
+        } else {
+          results.push({ worker: name, status: "degraded", statusCode: response.status });
+          degraded++;
+        }
+      } catch (err) {
+        results.push({
+          worker: name,
+          status: "unreachable",
+          error: err instanceof Error ? err.message : String(err),
+        });
+        unreachable++;
+      }
+    }
+
+    return { workers: results, healthyCount: healthy, degradedCount: degraded, unreachableCount: unreachable };
+  }
+}

package/src/commands/monitor/types.ts

@@ -0,0 +1,13 @@
+export interface WorkerHealthResult {
+  worker: string;
+  status: "healthy" | "degraded" | "unreachable";
+  statusCode?: number;
+  error?: string;
+}
+
+export interface MonitorStatusResult {
+  workers: WorkerHealthResult[];
+  healthyCount: number;
+  degradedCount: number;
+  unreachableCount: number;
+}

package/src/commands/repair/index.ts

@@ -0,0 +1,2 @@
+export { registerRepairCommand } from "./repair-command.js";
+export type { RepairStepResult, RepairCheckResult } from "./types.js";

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

@@ -0,0 +1,204 @@
+// @ts-nocheck
+/**
+ * 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";
+import { SecretsService } from "../../services/secrets/secrets-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;
+const origGetWorker = CloudflareService.prototype.deploy; // placeholder
+const origListWorkers = CloudflareService.prototype.deploy; // placeholder
+
+beforeEach(() => {
+  mock.restore();
+  process.exitCode = 0;
+
+  // Restore originals
+  (RepairService.prototype as Record<string, unknown>).runSystemCheck = origRunSystemCheck;
+  (CloudflareService.prototype as Record<string, unknown>).deploy = origDeploy;
+  (CloudflareService.prototype as Record<string, unknown>).d1List = origD1List;
+  (CloudflareService.prototype as Record<string, unknown>).kvList = origKvList;
+  (CloudflareService.prototype as Record<string, unknown>).r2List = origR2List;
+  (CloudflareService.prototype as Record<string, unknown>).queueList = origQueueList;
+  (DbService.prototype as Record<string, unknown>).resolveDbName = origResolveDbName;
+  (DbService.prototype as Record<string, unknown>).apply = origApply;
+  (DbService.prototype as Record<string, unknown>).migrate = origMigrate;
+  (DbService.prototype as Record<string, unknown>).export = origExport;
+  (DbService.prototype as Record<string, unknown>).reset = origReset;
+  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId = origResolveNs;
+  (KvSyncService.prototype 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 Record<string, unknown>).runSystemCheck = runSystemCheckMock;
+  (CloudflareService.prototype as Record<string, unknown>).deploy = deployMock;
+});
+
+afterEach(() => {
+  mock.restore();
+  (RepairService.prototype as Record<string, unknown>).runSystemCheck = origRunSystemCheck;
+  (CloudflareService.prototype as Record<string, unknown>).deploy = origDeploy;
+  (CloudflareService.prototype as Record<string, unknown>).d1List = origD1List;
+  (CloudflareService.prototype as Record<string, unknown>).kvList = origKvList;
+  (CloudflareService.prototype as Record<string, unknown>).r2List = origR2List;
+  (CloudflareService.prototype as Record<string, unknown>).queueList = origQueueList;
+  (DbService.prototype as Record<string, unknown>).resolveDbName = origResolveDbName;
+  (DbService.prototype as Record<string, unknown>).apply = origApply;
+  (DbService.prototype as Record<string, unknown>).migrate = origMigrate;
+  (DbService.prototype as Record<string, unknown>).export = origExport;
+  (DbService.prototype as Record<string, unknown>).reset = origReset;
+  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId = origResolveNs;
+  (KvSyncService.prototype 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 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

@@ -0,0 +1,199 @@
+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 } from "../../utils/formatters.js";
+import { CLIError, ExitCode } from "../../utils/errors.js";
+
+function getFormatOptions(cmd: Command): FormatOptions {
+  const rootCmd = cmd.parent?.parent as Command | undefined;
+  return {
+    json: Boolean(rootCmd?.optsWithGlobals()?.json),
+    quiet: Boolean(rootCmd?.optsWithGlobals()?.quiet),
+  };
+}
+
+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.data.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

@@ -0,0 +1,102 @@
+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) });
+    }
+
+    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

@@ -0,0 +1,13 @@
+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/test/index.ts

@@ -0,0 +1,2 @@
+export { registerTestCommand } from "./test-command.js";
+export type { TestStepResult, TestSummary } from "./test-command.js";