@jango-blockchained/hoox-cli 0.3.4

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

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "bun:test";
+import type { Command } from "commander";
+
+const { registerDashboardCommand } = await import("./dashboard-command.js");
+
+describe("registerDashboardCommand", () => {
+  it("registers dashboard command group on program", () => {
+    const commands: { name: string; description: string }[] = [];
+    const subcommands: { parent: string; name: string; description: string }[] =
+      [];
+
+    const mockProgram = {
+      command: (name: string) => {
+        commands.push({ name, description: "" });
+        const desc = (d: string) => {
+          commands[commands.length - 1].description = d;
+          return {
+            command: (subName: string) => {
+              subcommands.push({
+                parent: name,
+                name: subName,
+                description: "",
+              });
+              return {
+                description: (d2: string) => {
+                  subcommands[subcommands.length - 1].description = d2;
+                  return {
+                    option: () => ({ action: () => {} }),
+                  };
+                },
+              };
+            },
+          };
+        };
+        return { description: desc };
+      },
+      opts: () => ({ json: false, quiet: false }),
+    } as unknown as Command;
+
+    registerDashboardCommand(mockProgram);
+
+    expect(commands.length).toBe(1);
+    expect(commands[0].name).toBe("dashboard");
+    expect(subcommands.length).toBe(1);
+    expect(subcommands[0].name).toBe("update-urls");
+  });
+});

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

@@ -0,0 +1,127 @@
+import type { Command } from "commander";
+import { ConfigService } from "../../services/config/index.js";
+import { CLIError, ExitCode } from "../../utils/errors.js";
+import {
+  formatSuccess,
+  formatError,
+  formatTable,
+} from "../../utils/formatters.js";
+import type { FormatOptions } from "../../utils/formatters.js";
+import { theme, icons } from "../../utils/theme.js";
+import * as jsonc from "jsonc-parser";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+interface ServiceUrl {
+  worker: string;
+  url: string;
+}
+
+function getServiceUrls(config: ConfigService): ServiceUrl[] {
+  const global = config.getGlobal();
+  const prefix = global.subdomain_prefix ?? "hoox";
+  const workers = config.listEnabledWorkers();
+
+  return workers.map((name) => ({
+    worker: name,
+    url: `https://${name}.${prefix}.workers.dev`,
+  }));
+}
+
+function updateWranglerVars(
+  filePath: string,
+  urls: ServiceUrl[],
+  dryRun: boolean,
+  opts: FormatOptions
+): void {
+  if (!existsSync(filePath)) {
+    throw new CLIError(
+      `Dashboard wrangler.jsonc not found at ${filePath}`,
+      ExitCode.ERROR
+    );
+  }
+
+  const content = readFileSync(filePath, "utf-8");
+  const errors: jsonc.ParseError[] = [];
+  const parsed = jsonc.parse(content, errors) as Record<string, unknown>;
+
+  if (errors.length > 0) {
+    throw new CLIError(`Invalid JSONC in ${filePath}`, ExitCode.ERROR);
+  }
+
+  const vars = (parsed.vars as Record<string, string>) ?? {};
+  const changes: { key: string; oldValue: string; newValue: string }[] = [];
+
+  for (const { worker, url } of urls) {
+    const key = `${worker.toUpperCase().replace(/-/g, "_")}_URL`;
+    const oldValue = vars[key] ?? "(not set)";
+    changes.push({ key, oldValue, newValue: url });
+    vars[key] = url;
+  }
+
+  if (changes.length === 0) {
+    formatSuccess("No service URLs to update.", opts);
+    return;
+  }
+
+  if (!opts.quiet) {
+    const rows = changes.map((c) => ({
+      Key: c.key,
+      Old: c.oldValue,
+      New: theme.success(c.newValue),
+    }));
+    console.log(theme.heading("\nService URL changes:"));
+    formatTable(rows, opts);
+  }
+
+  if (dryRun) {
+    formatSuccess("Dry run — no changes written.", opts);
+    return;
+  }
+
+  const edits = jsonc.modify(content, ["vars"], vars, {
+    formattingOptions: { tabSize: 2, insertSpaces: true },
+  });
+  const updated = jsonc.applyEdits(content, edits);
+  writeFileSync(filePath, updated, "utf-8");
+
+  formatSuccess(
+    `Updated ${changes.length} service URL(s) in dashboard wrangler.jsonc`,
+    opts
+  );
+}
+
+export function registerDashboardCommand(program: Command): void {
+  const dashboardCmd = program
+    .command("dashboard")
+    .description("Dashboard-specific operations");
+
+  dashboardCmd
+    .command("update-urls")
+    .description("Update dashboard wrangler.jsonc with current service URLs")
+    .option("--dry-run", "Show changes without applying")
+    .action(async (options: { dryRun?: boolean }) => {
+      const opts: FormatOptions = {
+        json: program.opts<{ json?: boolean }>().json,
+        quiet: program.opts<{ quiet?: boolean }>().quiet,
+      };
+
+      try {
+        const config = new ConfigService();
+        await config.load();
+
+        const urls = getServiceUrls(config);
+        const dashboardPath = resolve(
+          process.cwd(),
+          "pages",
+          "dashboard",
+          "wrangler.jsonc"
+        );
+
+        updateWranglerVars(dashboardPath, urls, options.dryRun === true, opts);
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+}

package/src/commands/dashboard/index.ts

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

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

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "bun:test";
+import { DbService } from "../../services/db/index.js";
+
+describe("db command", () => {
+  describe("DbService integration", () => {
+    it("resolves database name from explicit arg", async () => {
+      const svc = new DbService();
+      const name = await svc.resolveDbName("my-test-db");
+      expect(name).toBe("my-test-db");
+    });
+
+    it("parses table names from wrangler output", () => {
+      const output = JSON.stringify([
+        { results: [{ name: "trades" }, { name: "signals" }] },
+      ]);
+      const tables = DbService.parseTableNames(output);
+      expect(tables).toContain("trades");
+      expect(tables).toContain("signals");
+    });
+  });
+});

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

@@ -0,0 +1,314 @@
+/**
+ * `hoox db` command group — database management.
+ *
+ * Subcommands:
+ *   apply [--remote] [--file <path>]   — Apply schema.sql to D1
+ *   migrate [--remote]                  — Run tracking migrations
+ *   list [--remote]                     — List database tables
+ *   query <sql> [--remote]              — Execute a SQL query
+ *   export [--output <path>]            — Export database
+ *   reset [--confirm]                   — Drop and recreate (DESTRUCTIVE)
+ */
+
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { DbService } from "../../services/db/index.js";
+import {
+  formatSuccess,
+  formatError,
+  formatTable,
+  formatJson,
+} from "../../utils/formatters.js";
+import { CLIError, ExitCode } from "../../utils/errors.js";
+import type { FormatOptions } from "../../utils/formatters.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),
+  };
+}
+
+/**
+ * Resolve database name from config or --database flag.
+ */
+async function resolveDb(
+  cmd: Command,
+  svc: DbService,
+): Promise<string> {
+  const opts = cmd.optsWithGlobals<{ database?: string }>();
+  return await svc.resolveDbName(opts.database);
+}
+
+// ---------------------------------------------------------------------------
+// db apply
+// ---------------------------------------------------------------------------
+
+async function handleApply(
+  opts: FormatOptions,
+  dbName: string,
+  remote: boolean,
+  file?: string,
+): Promise<void> {
+  const svc = new DbService();
+  const output = await svc.apply(dbName, remote, file);
+  formatSuccess(
+    `Schema applied to ${dbName}${remote ? " (remote)" : " (local)"}`,
+    opts,
+  );
+  if (!opts.quiet && output) {
+    process.stdout.write(`${output}\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// db migrate
+// ---------------------------------------------------------------------------
+
+async function handleMigrate(
+  opts: FormatOptions,
+  dbName: string,
+  remote: boolean,
+): Promise<void> {
+  const svc = new DbService();
+  const output = await svc.migrate(dbName, remote);
+  formatSuccess(
+    `Migrations applied to ${dbName}${remote ? " (remote)" : " (local)"}`,
+    opts,
+  );
+  if (!opts.quiet && output) {
+    process.stdout.write(`${output}\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// db list
+// ---------------------------------------------------------------------------
+
+async function handleList(
+  opts: FormatOptions,
+  dbName: string,
+  remote: boolean,
+): Promise<void> {
+  const svc = new DbService();
+  const tables = await svc.listTables(dbName, remote);
+
+  if (opts.json) {
+    formatJson(tables, opts);
+  } else if (!opts.quiet) {
+    if (tables.length === 0) {
+      process.stdout.write("No tables found.\n");
+      return;
+    }
+    const rows = tables.map((t) => ({ Table: t }));
+    formatTable(rows, opts);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// db query
+// ---------------------------------------------------------------------------
+
+async function handleQuery(
+  opts: FormatOptions,
+  dbName: string,
+  sql: string,
+  remote: boolean,
+): Promise<void> {
+  const svc = new DbService();
+  const output = await svc.query(dbName, sql, remote);
+
+  if (opts.json) {
+    // Already JSON from wrangler — try to parse for cleaner output
+    try {
+      const parsed = JSON.parse(output);
+      formatJson(parsed, opts);
+    } catch {
+      process.stdout.write(`${output}\n`);
+    }
+  } else {
+    process.stdout.write(`${output}\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// db export
+// ---------------------------------------------------------------------------
+
+async function handleExport(
+  opts: FormatOptions,
+  dbName: string,
+  outputPath?: string,
+): Promise<void> {
+  const svc = new DbService();
+  const path = await svc.export(dbName, outputPath);
+  formatSuccess(`Database exported to ${path}`, opts);
+}
+
+// ---------------------------------------------------------------------------
+// db reset
+// ---------------------------------------------------------------------------
+
+async function handleReset(
+  opts: FormatOptions,
+  dbName: string,
+  confirmed: boolean,
+): Promise<void> {
+  if (!confirmed) {
+    const answer = await p.confirm({
+      message: `WARNING: This will DELETE and recreate the "${dbName}" database. ALL DATA WILL BE LOST. Continue?`,
+      initialValue: false,
+    });
+    if (p.isCancel(answer) || !answer) {
+      p.cancel("Reset cancelled.");
+      return;
+    }
+  }
+
+  const svc = new DbService();
+  const output = await svc.reset(dbName);
+  formatSuccess(`Database "${dbName}" has been recreated`, opts);
+  if (!opts.quiet && output) {
+    process.stdout.write(`${output}\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+export function registerDbCommand(program: Command): void {
+  const dbCmd = program
+    .command("db")
+    .summary("Manage D1 databases")
+    .description(
+      `Manage Cloudflare D1 databases — schema, queries, migrations, backup.
+
+SUBCOMMANDS:
+  apply               Apply schema.sql to D1
+  migrate             Run tracking migrations
+  list                List database tables
+  query <sql>         Execute a SQL query
+  export              Export database to .sql file
+  reset               Drop and recreate database (DESTRUCTIVE)
+
+OPTIONS:
+  --database <name>   Database name (auto-detected from config if omitted)
+  --remote            Operate on production (remote) database
+
+EXAMPLES:
+  hoox db apply
+  hoox db apply --remote
+  hoox db migrate
+  hoox db list
+  hoox db query "SELECT * FROM trade_signals LIMIT 5"
+  hoox db export
+  hoox db reset`,
+    )
+    .option("--database <name>", "Database name (auto-detected if omitted)")
+    .option("--remote", "Operate on production (remote) database");
+
+  // -- apply
+  dbCmd
+    .command("apply")
+    .description("Apply schema.sql to the database")
+    .option("--file <path>", "Path to schema.sql file")
+    .action(async (options: { file?: string }, cmd: Command) => {
+      const opts = getFormatOptions(cmd);
+      try {
+        const svc = new DbService();
+        const dbName = await resolveDb(cmd, svc);
+        const remote = Boolean(cmd.optsWithGlobals<{ remote?: boolean }>().remote);
+        await handleApply(opts, dbName, remote, options.file);
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+
+  // -- migrate
+  dbCmd
+    .command("migrate")
+    .description("Run tracking migrations")
+    .action(async (_, cmd: Command) => {
+      const opts = getFormatOptions(cmd);
+      try {
+        const svc = new DbService();
+        const dbName = await resolveDb(cmd, svc);
+        const remote = Boolean(cmd.optsWithGlobals<{ remote?: boolean }>().remote);
+        await handleMigrate(opts, dbName, remote);
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+
+  // -- list
+  dbCmd
+    .command("list")
+    .description("List database tables")
+    .action(async (_, cmd: Command) => {
+      const opts = getFormatOptions(cmd);
+      try {
+        const svc = new DbService();
+        const dbName = await resolveDb(cmd, svc);
+        const remote = Boolean(cmd.optsWithGlobals<{ remote?: boolean }>().remote);
+        await handleList(opts, dbName, remote);
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+
+  // -- query
+  dbCmd
+    .command("query <sql>")
+    .description("Execute a SQL query")
+    .action(async (sql: string, _, cmd: Command) => {
+      const opts = getFormatOptions(cmd);
+      try {
+        const svc = new DbService();
+        const dbName = await resolveDb(cmd, svc);
+        const remote = Boolean(cmd.optsWithGlobals<{ remote?: boolean }>().remote);
+        await handleQuery(opts, dbName, sql, remote);
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+
+  // -- export
+  dbCmd
+    .command("export")
+    .description("Export database to .sql file")
+    .option("--output <path>", "Output file path")
+    .action(async (options: { output?: string }, cmd: Command) => {
+      const opts = getFormatOptions(cmd);
+      try {
+        const svc = new DbService();
+        const dbName = await resolveDb(cmd, svc);
+        await handleExport(opts, dbName, options.output);
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+
+  // -- reset
+  dbCmd
+    .command("reset")
+    .description("Drop and recreate the database (DESTRUCTIVE)")
+    .option("--confirm", "Skip confirmation prompt")
+    .action(async (options: { confirm?: boolean }, cmd: Command) => {
+      const opts = getFormatOptions(cmd);
+      try {
+        const svc = new DbService();
+        const dbName = await resolveDb(cmd, svc);
+        await handleReset(opts, dbName, Boolean(options.confirm));
+      } catch (err) {
+        formatError(err instanceof Error ? err : String(err), opts);
+        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
+      }
+    });
+}

package/src/commands/db/index.ts

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