@jango-blockchained/hoox-cli 0.3.4

package/src/commands/init/types.ts

@@ -0,0 +1,185 @@
+/**
+ * Types for the `hoox init` interactive setup wizard.
+ */
+
+/** CLI flags for non-interactive mode. */
+export interface InitOptions {
+  /** --token: Cloudflare API token (non-interactive mode) */
+  token?: string;
+  /** --account: Cloudflare account ID (non-interactive mode) */
+  account?: string;
+  /** --secret-store: Secret Store ID (non-interactive mode) */
+  secretStore?: string;
+  /** --prefix: Subdomain prefix (non-interactive mode) */
+  prefix?: string;
+  /** --accept-risk: Skip the risk acknowledgment confirmation */
+  acceptRisk?: boolean;
+}
+
+/** Definition of an integration that can be enabled during setup. */
+export interface IntegrationConfig {
+  /** Unique key used for the multiselect value. */
+  key: string;
+  /** Display label shown in the multiselect prompt. */
+  label: string;
+  /** Which worker this integration maps to in wrangler.jsonc. */
+  workerName: string;
+  /** Secrets that must be collected for this integration (name → prompt label). */
+  secrets: Record<string, string>;
+  /** Extra non-secret environment variables for the worker. */
+  vars?: Record<string, string>;
+}
+
+/** Shape of a single worker entry in wrangler.jsonc. */
+export interface WorkerConfig {
+  enabled: boolean;
+  path: string;
+  vars: Record<string, string>;
+  secrets: string[];
+}
+
+/** Shape of the wrangler.jsonc file. */
+export interface WorkersJsonConfig {
+  global: {
+    cloudflare_api_token: string;
+    cloudflare_account_id: string;
+    cloudflare_secret_store_id: string;
+    subdomain_prefix: string;
+  };
+  workers: Record<string, WorkerConfig>;
+}
+
+/**
+ * All supported integrations.
+ * Exchanges (Binance, MEXC, Bybit) map to trade-worker.
+ * Wallet maps to web3-wallet-worker, email to email-worker,
+ * telegram to telegram-worker.
+ */
+export const INTEGRATIONS: IntegrationConfig[] = [
+  {
+    key: "binance",
+    label: "Binance Exchange",
+    workerName: "trade-worker",
+    secrets: {
+      BINANCE_API_KEY: "Binance API Key",
+      BINANCE_API_SECRET: "Binance API Secret",
+    },
+  },
+  {
+    key: "mexc",
+    label: "MEXC Exchange",
+    workerName: "trade-worker",
+    secrets: {
+      MEXC_API_KEY: "MEXC API Key",
+      MEXC_API_SECRET: "MEXC API Secret",
+    },
+  },
+  {
+    key: "bybit",
+    label: "Bybit Exchange",
+    workerName: "trade-worker",
+    secrets: {
+      BYBIT_API_KEY: "Bybit API Key",
+      BYBIT_API_SECRET: "Bybit API Secret",
+    },
+  },
+  {
+    key: "wallet",
+    label: "Web3 Wallet (on-chain execution)",
+    workerName: "web3-wallet-worker",
+    secrets: {
+      WALLET_MNEMONIC_SECRET: "Wallet Mnemonic Phrase",
+      WALLET_PK_SECRET: "Wallet Private Key",
+    },
+  },
+  {
+    key: "email",
+    label: "Email Signal Parsing",
+    workerName: "email-worker",
+    secrets: {
+      EMAIL_HOST: "Email Host (IMAP server)",
+      EMAIL_USER: "Email Username",
+      EMAIL_PASS: "Email Password",
+      INTERNAL_KEY: "Internal Auth Key",
+    },
+    vars: {
+      USE_IMAP: "false",
+    },
+  },
+  {
+    key: "telegram",
+    label: "Telegram Notifications",
+    workerName: "telegram-worker",
+    secrets: {
+      TELEGRAM_BOT_TOKEN: "Telegram Bot Token",
+    },
+  },
+  {
+    key: "openai",
+    label: "OpenAI (AI Agent)",
+    workerName: "agent-worker",
+    secrets: {
+      AGENT_OPENAI_KEY: "OpenAI API Key",
+    },
+  },
+  {
+    key: "anthropic",
+    label: "Anthropic (AI Agent)",
+    workerName: "agent-worker",
+    secrets: {
+      AGENT_ANTHROPIC_KEY: "Anthropic API Key",
+    },
+  },
+  {
+    key: "google-ai",
+    label: "Google AI (AI Agent)",
+    workerName: "agent-worker",
+    secrets: {
+      AGENT_GOOGLE_KEY: "Google AI API Key",
+    },
+  },
+  {
+    key: "home-assistant",
+    label: "Home Assistant (Smart Home)",
+    workerName: "hoox",
+    secrets: {
+      HA_TOKEN_BINDING: "Home Assistant Token",
+    },
+  },
+];
+
+/**
+ * Base workers that are always enabled regardless of integration selection.
+ */
+export const BASE_WORKERS: Record<string, Omit<WorkerConfig, "secrets">> = {
+  "d1-worker": {
+    enabled: true,
+    path: "workers/d1-worker",
+    vars: { database_name: "my-database" },
+  },
+  hoox: {
+    enabled: true,
+    path: "workers/hoox",
+    vars: {},
+  },
+  "agent-worker": {
+    enabled: true,
+    path: "workers/agent-worker",
+    vars: {},
+  },
+  "analytics-worker": {
+    enabled: true,
+    path: "workers/analytics-worker",
+    vars: {},
+  },
+};
+
+/**
+ * Base secrets for base workers (not integration-driven).
+ */
+export const BASE_SECRETS: Record<string, string[]> = {
+  hoox: ["WEBHOOK_API_KEY_BINDING"],
+  "agent-worker": ["AGENT_INTERNAL_KEY"],
+  "analytics-worker": ["CLOUDFLARE_API_TOKEN"],
+  "trade-worker": ["API_SERVICE_KEY"],
+};

package/src/commands/monitor/index.ts

@@ -0,0 +1,2 @@
+export { registerMonitorCommand } from "./monitor-command.js";
+export type { WorkerHealthResult, MonitorStatusResult } from "./types.js";

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

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

@@ -0,0 +1,245 @@
+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 } from "../../utils/formatters.js";
+import type { FormatOptions } from "../../utils/formatters.js";
+import { ExitCode } from "../../utils/errors.js";
+import { theme } from "../../utils/theme.js";
+
+function getFormatOptions(cmd: Command): FormatOptions {
+  const opts = cmd.optsWithGlobals();
+  return { json: Boolean(opts.json), quiet: Boolean(opts.quiet) };
+}
+
+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);
+    });
+}