@jango-blockchained/hoox-cli 0.5.1 → 0.5.6

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

@@ -1,263 +0,0 @@
-// @ts-nocheck
-/**
- * Unit tests for the monitor command.
- *
- * Stubs MonitorService, DbService, and KvSyncService prototypes to verify
- * the monitor command logic in isolation. Uses Commander's exitOverride to
- * suppress process exits during test runs.
- */
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import { Command } from "commander";
-import { MonitorService } from "./monitor-service.js";
-import { DbService } from "../../services/db/db-service.js";
-import { KvSyncService } from "../../services/kv/kv-sync-service.js";
-
-// Stub variables
-let checkAllWorkerHealthMock: ReturnType<typeof mock>;
-let resolveDbNameMock: ReturnType<typeof mock>;
-let queryMock: ReturnType<typeof mock>;
-let exportMock: ReturnType<typeof mock>;
-let resolveNamespaceIdMock: ReturnType<typeof mock>;
-let getMock: ReturnType<typeof mock>;
-let setMock: ReturnType<typeof mock>;
-
-// Preserve originals
-const origCheckAll = MonitorService.prototype.checkAllWorkerHealth;
-const origResolveDbName = DbService.prototype.resolveDbName;
-const origQuery = DbService.prototype.query;
-const origExport = DbService.prototype.export;
-const origResolveNs = KvSyncService.prototype.resolveNamespaceId;
-const origGet = KvSyncService.prototype.get;
-const origSet = KvSyncService.prototype.set;
-
-beforeEach(() => {
-  mock.restore();
-  process.exitCode = 0;
-
-  // Restore originals
-  (MonitorService.prototype as Record<string, unknown>).checkAllWorkerHealth =
-    origCheckAll;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
-    origResolveDbName;
-  (DbService.prototype as Record<string, unknown>).query = origQuery;
-  (DbService.prototype as Record<string, unknown>).export = origExport;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    origResolveNs;
-  (KvSyncService.prototype as Record<string, unknown>).get = origGet;
-  (KvSyncService.prototype as Record<string, unknown>).set = origSet;
-
-  // Fresh mocks
-  checkAllWorkerHealthMock = mock(async () => ({
-    workers: [
-      { worker: "hoox", status: "healthy", statusCode: 200 },
-      { worker: "trade-worker", status: "healthy", statusCode: 200 },
-    ],
-    healthyCount: 2,
-    degradedCount: 0,
-    unreachableCount: 0,
-  }));
-
-  resolveDbNameMock = mock(async () => "trade-data-db");
-  queryMock = mock(
-    async (_dbName: string, _sql: string, _remote: boolean) =>
-      "[mock query result]"
-  );
-  exportMock = mock(async (_dbName: string) => "backup-2026-05-13.sql");
-  resolveNamespaceIdMock = mock(async () => "ns-id-123");
-  getMock = mock(async (_nsId: string, _key: string) => "false");
-  setMock = mock(async (_nsId: string, _key: string, _value: string) => {});
-
-  // Install mocks on prototypes
-  (MonitorService.prototype as Record<string, unknown>).checkAllWorkerHealth =
-    checkAllWorkerHealthMock;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
-    resolveDbNameMock;
-  (DbService.prototype as Record<string, unknown>).query = queryMock;
-  (DbService.prototype as Record<string, unknown>).export = exportMock;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    resolveNamespaceIdMock;
-  (KvSyncService.prototype as Record<string, unknown>).get = getMock;
-  (KvSyncService.prototype as Record<string, unknown>).set = setMock;
-});
-
-afterEach(() => {
-  mock.restore();
-  (MonitorService.prototype as Record<string, unknown>).checkAllWorkerHealth =
-    origCheckAll;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
-    origResolveDbName;
-  (DbService.prototype as Record<string, unknown>).query = origQuery;
-  (DbService.prototype as Record<string, unknown>).export = origExport;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    origResolveNs;
-  (KvSyncService.prototype as Record<string, unknown>).get = origGet;
-  (KvSyncService.prototype as Record<string, unknown>).set = origSet;
-});
-
-async function importMonitorCommand(): Promise<{
-  registerMonitorCommand: typeof import("./monitor-command.js").registerMonitorCommand;
-}> {
-  return import("./monitor-command.js");
-}
-
-async function createProgram(): Promise<Command> {
-  const { registerMonitorCommand } = await importMonitorCommand();
-  const program = new Command().name("hoox-test").exitOverride(() => {});
-  registerMonitorCommand(program);
-  return program;
-}
-
-describe("registerMonitorCommand", () => {
-  // -- Command registration -------------------------------------------------
-
-  it("registers 'monitor' as a command on the program", async () => {
-    const program = await createProgram();
-    const cmd = program.commands.find((c) => c.name() === "monitor");
-    expect(cmd).toBeDefined();
-  });
-
-  it("registers 'monitor status' subcommand", async () => {
-    const program = await createProgram();
-    const monitorCmd = program.commands.find((c) => c.name() === "monitor")!;
-    const statusCmd = monitorCmd.commands.find((c) => c.name() === "status");
-    expect(statusCmd).toBeDefined();
-  });
-
-  it("registers 'monitor trades' subcommand with argument", async () => {
-    const program = await createProgram();
-    const monitorCmd = program.commands.find((c) => c.name() === "monitor")!;
-    const tradesCmd = monitorCmd.commands.find((c) => c.name() === "trades");
-    expect(tradesCmd).toBeDefined();
-    const args = tradesCmd!.registeredArguments;
-    expect(args.some((a) => a.name() === "limit")).toBe(true);
-  });
-
-  it("registers 'monitor logs' subcommand with optional argument", async () => {
-    const program = await createProgram();
-    const monitorCmd = program.commands.find((c) => c.name() === "monitor")!;
-    const logsCmd = monitorCmd.commands.find((c) => c.name() === "logs");
-    expect(logsCmd).toBeDefined();
-  });
-
-  it("registers 'monitor kill-switch' with show/on/off subcommands", async () => {
-    const program = await createProgram();
-    const monitorCmd = program.commands.find((c) => c.name() === "monitor")!;
-    const ksCmd = monitorCmd.commands.find((c) => c.name() === "kill-switch");
-    expect(ksCmd).toBeDefined();
-    expect(ksCmd!.commands.find((c) => c.name() === "show")).toBeDefined();
-    expect(ksCmd!.commands.find((c) => c.name() === "on")).toBeDefined();
-    expect(ksCmd!.commands.find((c) => c.name() === "off")).toBeDefined();
-  });
-
-  it("registers 'monitor queue-depth' subcommand", async () => {
-    const program = await createProgram();
-    const monitorCmd = program.commands.find((c) => c.name() === "monitor")!;
-    const qCmd = monitorCmd.commands.find((c) => c.name() === "queue-depth");
-    expect(qCmd).toBeDefined();
-  });
-
-  it("registers 'monitor backup' subcommand", async () => {
-    const program = await createProgram();
-    const monitorCmd = program.commands.find((c) => c.name() === "monitor")!;
-    const backupCmd = monitorCmd.commands.find((c) => c.name() === "backup");
-    expect(backupCmd).toBeDefined();
-  });
-
-  // -- monitor status -------------------------------------------------------
-
-  describe("monitor status", () => {
-    it("calls checkAllWorkerHealth", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "status"], { from: "user" });
-      expect(checkAllWorkerHealthMock).toHaveBeenCalled();
-    });
-
-    it("exits cleanly on success", async () => {
-      process.exitCode = 0;
-      const program = await createProgram();
-      process.exitCode = 0;
-      await program.parseAsync(["monitor", "status"], { from: "user" });
-      expect(process.exitCode).toBe(0);
-    });
-
-    it("sets exitCode on service failure", async () => {
-      checkAllWorkerHealthMock = mock(async () => {
-        throw new Error("Connection failed");
-      });
-      (
-        MonitorService.prototype as Record<string, unknown>
-      ).checkAllWorkerHealth = checkAllWorkerHealthMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "status"], { from: "user" });
-      expect(process.exitCode).toBe(1);
-    });
-  });
-
-  // -- monitor trades -------------------------------------------------------
-
-  describe("monitor trades", () => {
-    it("calls db.query with trades table", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "trades"], { from: "user" });
-      expect(resolveDbNameMock).toHaveBeenCalled();
-      expect(queryMock).toHaveBeenCalled();
-      const sql = queryMock.mock.calls[0][1] as string;
-      expect(sql).toContain("trades");
-      expect(sql).toContain("ORDER BY timestamp DESC");
-    });
-
-    it("accepts custom limit", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "trades", "25"], { from: "user" });
-      const sql = queryMock.mock.calls[0][1] as string;
-      expect(sql).toContain("LIMIT 25");
-    });
-  });
-
-  // -- monitor kill-switch --------------------------------------------------
-
-  describe("monitor kill-switch", () => {
-    it("shows kill switch status", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "kill-switch", "show"], {
-        from: "user",
-      });
-      expect(getMock).toHaveBeenCalledWith("ns-id-123", "trade:kill_switch");
-    });
-
-    it("turns kill switch on", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "kill-switch", "on"], {
-        from: "user",
-      });
-      expect(setMock).toHaveBeenCalledWith(
-        "ns-id-123",
-        "trade:kill_switch",
-        "true"
-      );
-    });
-
-    it("turns kill switch off", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "kill-switch", "off"], {
-        from: "user",
-      });
-      expect(setMock).toHaveBeenCalledWith(
-        "ns-id-123",
-        "trade:kill_switch",
-        "false"
-      );
-    });
-  });
-
-  // -- monitor backup -------------------------------------------------------
-
-  describe("monitor backup", () => {
-    it("calls db.export", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["monitor", "backup"], { from: "user" });
-      expect(exportMock).toHaveBeenCalled();
-    });
-  });
-});

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

@@ -1,269 +0,0 @@
-import { Command } from "commander";
-import { DbService } from "../../services/db/index.js";
-import { MonitorService } from "./monitor-service.js";
-import { KvSyncService } from "../../services/kv/kv-sync-service.js";
-import {
-  formatSuccess,
-  formatError,
-  formatTable,
-  getFormatOptions,
-} from "../../utils/formatters.js";
-import type { FormatOptions } from "../../utils/formatters.js";
-import { ExitCode } from "../../utils/errors.js";
-import { theme } from "../../utils/theme.js";
-
-async function doMonitorStatus(fmt: FormatOptions): Promise<void> {
-  try {
-    const monitor = new MonitorService();
-    const result = await monitor.checkAllWorkerHealth();
-
-    if (fmt.json) {
-      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
-      return;
-    }
-
-    const rows = result.workers.map((w) => ({
-      Worker: w.worker,
-      Status: w.status,
-      "Status Code": String(w.statusCode ?? "-"),
-      Error: w.error ?? "-",
-    }));
-    formatTable(rows, fmt);
-
-    process.stdout.write(
-      `\n${theme.heading("Summary:")} ${result.healthyCount} healthy, ${result.degradedCount} degraded, ${result.unreachableCount} unreachable\n`
-    );
-  } catch (err) {
-    formatError(err instanceof Error ? err.message : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function doMonitorTrades(
-  limit: number,
-  fmt: FormatOptions
-): Promise<void> {
-  try {
-    const db = new DbService();
-    const dbName = await db.resolveDbName();
-    const sql = `SELECT * FROM trades ORDER BY timestamp DESC LIMIT ${Math.min(limit, 100)}`;
-    const output = await db.query(dbName, sql, true);
-    process.stdout.write(output + "\n");
-  } catch (err) {
-    formatError(err instanceof Error ? err.message : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function doMonitorLogs(
-  workerName: string | undefined,
-  fmt: FormatOptions
-): Promise<void> {
-  try {
-    const db = new DbService();
-    const dbName = await db.resolveDbName();
-    let sql: string;
-    if (workerName) {
-      sql = `SELECT * FROM system_logs WHERE worker = '${workerName.replace(/'/g, "''")}' ORDER BY timestamp DESC LIMIT 20`;
-    } else {
-      sql = "SELECT * FROM system_logs ORDER BY timestamp DESC LIMIT 20";
-    }
-    const output = await db.query(dbName, sql, true);
-    process.stdout.write(output + "\n");
-  } catch (err) {
-    formatError(err instanceof Error ? err.message : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function doMonitorKillSwitch(
-  action: "show" | "on" | "off",
-  fmt: FormatOptions
-): Promise<void> {
-  try {
-    const kv = new KvSyncService();
-    const namespaceId = await kv.resolveNamespaceId();
-    const key = "trade:kill_switch";
-
-    if (action === "show") {
-      const value = await kv.get(namespaceId, key);
-      const status =
-        value === "true"
-          ? "KILL SWITCH IS ON (trading halted)"
-          : value === "false"
-            ? "Kill switch is off (trading active)"
-            : `Kill switch value: ${value ?? "(not set)"}`;
-      process.stdout.write(`${theme.info(status)}\n`);
-    } else {
-      const newValue = action === "on" ? "true" : "false";
-      await kv.set(namespaceId, key, newValue);
-      formatSuccess(
-        `Kill switch turned ${action === "on" ? "ON" : "OFF"}`,
-        fmt
-      );
-    }
-  } catch (err) {
-    formatError(err instanceof Error ? err.message : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function doMonitorQueueDepth(fmt: FormatOptions): Promise<void> {
-  try {
-    const proc = Bun.spawn(["wrangler", "queues", "list"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-
-    if (exitCode !== 0) {
-      throw new Error(stderr.trim() || `wrangler exited with code ${exitCode}`);
-    }
-
-    process.stdout.write(stdout + "\n");
-  } catch (err) {
-    formatError(err instanceof Error ? err.message : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-async function doMonitorBackup(fmt: FormatOptions): Promise<void> {
-  try {
-    const db = new DbService();
-    const dbName = await db.resolveDbName();
-    const outputPath = await db.export(dbName);
-    formatSuccess(`Database exported to ${outputPath}`, fmt);
-  } catch (err) {
-    formatError(err instanceof Error ? err.message : String(err), fmt);
-    process.exitCode = ExitCode.ERROR;
-  }
-}
-
-export function registerMonitorCommand(program: Command): void {
-  const monitorCmd = program
-    .command("monitor")
-    .summary("Monitor and operate the trading system")
-    .description(
-      `Monitor worker health, trades, logs, and perform operational tasks.
-
-SUBCOMMANDS:
-  status          Check health of all workers
-  trades [N]      Show N most recent trades (default: 10)
-  logs [worker]   Show recent system logs from D1
-  kill-switch     Emergency stop/resume trading
-  queue-depth     List queues and pending messages
-  backup          Export D1 database to timestamped .sql file
-
-EXAMPLES:
-  hoox monitor status             Check all workers health
-  hoox monitor trades 20          Show 20 recent trades
-  hoox monitor logs hoox          Show logs for hoox worker
-  hoox monitor kill-switch show   Check kill switch status
-  hoox monitor kill-switch on     Halt all trading
-  hoox monitor kill-switch off    Resume trading
-  hoox monitor queue-depth        Show queue info
-  hoox monitor backup             Export D1 database`
-    );
-
-  monitorCmd
-    .command("status")
-    .summary("Check health of all workers")
-    .description("Probe each worker's /health endpoint and report status.")
-    .action(async function (this: Command) {
-      const fmt = getFormatOptions(this);
-      await doMonitorStatus(fmt);
-    });
-
-  monitorCmd
-    .command("trades")
-    .summary("Show recent trades from D1")
-    .description("Query the trades table for the most recent entries.")
-    .argument(
-      "[limit]",
-      "Number of trades to show (default: 10, max: 100)",
-      "10"
-    )
-    .action(async function (this: Command, limit: string) {
-      const fmt = getFormatOptions(this);
-      await doMonitorTrades(parseInt(limit, 10) || 10, fmt);
-    });
-
-  monitorCmd
-    .command("logs")
-    .summary("Show recent system logs from D1")
-    .description(
-      "Query the system_logs table. Optionally filter by worker name."
-    )
-    .argument("[worker]", "Worker name to filter (optional)")
-    .action(async function (this: Command, worker?: string) {
-      const fmt = getFormatOptions(this);
-      await doMonitorLogs(worker, fmt);
-    });
-
-  const ksCmd = monitorCmd
-    .command("kill-switch")
-    .summary("Emergency stop or resume trading")
-    .description(
-      `Control the trade:kill_switch KV key.
-
-Commands:
-  show   Display current kill switch status
-  on     Halt all trading (set kill_switch=true)
-  off    Resume trading (set kill_switch=false)`
-    );
-
-  ksCmd
-    .command("show")
-    .summary("Show kill switch status")
-    .description("Display whether trading is halted or active.")
-    .action(async function (this: Command) {
-      const fmt = getFormatOptions(this);
-      await doMonitorKillSwitch("show", fmt);
-    });
-
-  ksCmd
-    .command("on")
-    .summary("Halt all trading")
-    .description(
-      "Set trade:kill_switch=true to stop all trading operations. WARNING: This halts ALL trading activity immediately."
-    )
-    .action(async function (this: Command) {
-      const fmt = getFormatOptions(this);
-      await doMonitorKillSwitch("on", fmt);
-    });
-
-  ksCmd
-    .command("off")
-    .summary("Resume trading")
-    .description(
-      "Set trade:kill_switch=false to resume normal trading operations."
-    )
-    .action(async function (this: Command) {
-      const fmt = getFormatOptions(this);
-      await doMonitorKillSwitch("off", fmt);
-    });
-
-  monitorCmd
-    .command("queue-depth")
-    .summary("Show queue details")
-    .description(
-      "List queues via wrangler queues list to show configured queues."
-    )
-    .action(async function (this: Command) {
-      const fmt = getFormatOptions(this);
-      await doMonitorQueueDepth(fmt);
-    });
-
-  monitorCmd
-    .command("backup")
-    .summary("Export D1 database to .sql file")
-    .description(
-      "Export the D1 database to a timestamped .sql backup file via wrangler d1 export."
-    )
-    .action(async function (this: Command) {
-      const fmt = getFormatOptions(this);
-      await doMonitorBackup(fmt);
-    });
-}

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

@@ -1,65 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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