@jango-blockchained/hoox-cli 0.5.1 → 0.5.2

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

@@ -1,13 +1,10 @@
 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 { formatSuccess, formatTable } from "../../utils/formatters.js";
+import { withErrorHandling } from "../../utils/error-handler.js";
 import type { FormatOptions } from "../../utils/formatters.js";
-import { theme, icons } from "../../utils/theme.js";
+import { theme } from "../../utils/theme.js";
 import * as jsonc from "jsonc-parser";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
@@ -101,28 +98,33 @@ export function registerDashboardCommand(program: Command): void {
     .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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (options: { dryRun?: boolean }) => {
+          const opts: FormatOptions = {
+            json: program.opts<{ json?: boolean }>().json,
+            quiet: program.opts<{ quiet?: boolean }>().quiet,
+          };
+
+          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
+          );
+        },
+        { service: "dashboard" }
+      )
+    );
 }

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

@@ -15,12 +15,11 @@ import * as p from "@clack/prompts";
 import { DbService } from "../../services/db/index.js";
 import {
   formatSuccess,
-  formatError,
   formatTable,
   formatJson,
   getFormatOptions,
 } from "../../utils/formatters.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
+import { withErrorHandling } from "../../utils/error-handler.js";
 import type { FormatOptions } from "../../utils/formatters.js";
 
 /**
@@ -204,109 +203,109 @@ EXAMPLES:
     .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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (options: { file?: string }, cmd: Command) => {
+          const opts = getFormatOptions(cmd);
+          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);
+        },
+        { service: "db" }
+      )
+    );
 
   // -- 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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (_, cmd: Command) => {
+          const opts = getFormatOptions(cmd);
+          const svc = new DbService();
+          const dbName = await resolveDb(cmd, svc);
+          const remote = Boolean(
+            cmd.optsWithGlobals<{ remote?: boolean }>().remote
+          );
+          await handleMigrate(opts, dbName, remote);
+        },
+        { service: "db" }
+      )
+    );
 
   // -- 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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (_, cmd: Command) => {
+          const opts = getFormatOptions(cmd);
+          const svc = new DbService();
+          const dbName = await resolveDb(cmd, svc);
+          const remote = Boolean(
+            cmd.optsWithGlobals<{ remote?: boolean }>().remote
+          );
+          await handleList(opts, dbName, remote);
+        },
+        { service: "db" }
+      )
+    );
 
   // -- 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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (sql: string, _, cmd: Command) => {
+          const opts = getFormatOptions(cmd);
+          const svc = new DbService();
+          const dbName = await resolveDb(cmd, svc);
+          const remote = Boolean(
+            cmd.optsWithGlobals<{ remote?: boolean }>().remote
+          );
+          await handleQuery(opts, dbName, sql, remote);
+        },
+        { service: "db" }
+      )
+    );
 
   // -- 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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (options: { output?: string }, cmd: Command) => {
+          const opts = getFormatOptions(cmd);
+          const svc = new DbService();
+          const dbName = await resolveDb(cmd, svc);
+          await handleExport(opts, dbName, options.output);
+        },
+        { service: "db" }
+      )
+    );
 
   // -- 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);
-      }
-    });
+    .action(
+      withErrorHandling(
+        async (options: { confirm?: boolean }, cmd: Command) => {
+          const opts = getFormatOptions(cmd);
+          const svc = new DbService();
+          const dbName = await resolveDb(cmd, svc);
+          await handleReset(opts, dbName, Boolean(options.confirm));
+        },
+        { service: "db" }
+      )
+    );
 }

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Unit tests for the deploy command.
  *
@@ -43,17 +42,20 @@ beforeEach(() => {
   process.exitCode = undefined;
 
   // Reset prototypes to originals (in case a previous test didn't restore)
-  (ConfigService.prototype as Record<string, unknown>).load = origLoad;
-  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-    origListEnabled;
-  (ConfigService.prototype as Record<string, unknown>).getWorker =
+  (ConfigService.prototype as unknown as Record<string, unknown>).load =
+    origLoad;
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).listEnabledWorkers = origListEnabled;
+  (ConfigService.prototype as unknown as Record<string, unknown>).getWorker =
     origGetWorker;
-  (CloudflareService.prototype as Record<string, unknown>).deploy = origDeploy;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    origDeploy;
 
   // Fresh mocks
   deployMock = mock(async (_path: string, _env?: string) => ({
     ok: true as const,
-    data: { url: "https://test-worker.cryptolinx.workers.dev" },
+    value: { url: "https://test-worker.cryptolinx.workers.dev", rawOutput: "" },
   }));
 
   loadMock = mock(async () => ({}));
@@ -64,24 +66,30 @@ beforeEach(() => {
   }));
 
   // Install mocks on prototypes
-  (ConfigService.prototype as Record<string, unknown>).load = loadMock;
-  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-    listEnabledWorkersMock;
-  (ConfigService.prototype as Record<string, unknown>).getWorker =
+  (ConfigService.prototype as unknown as Record<string, unknown>).load =
+    loadMock;
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).listEnabledWorkers = listEnabledWorkersMock;
+  (ConfigService.prototype as unknown as Record<string, unknown>).getWorker =
     getWorkerMock;
-  (CloudflareService.prototype as Record<string, unknown>).deploy = deployMock;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    deployMock;
 });
 
 afterEach(() => {
   mock.restore();
 
   // Restore originals
-  (ConfigService.prototype as Record<string, unknown>).load = origLoad;
-  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-    origListEnabled;
-  (ConfigService.prototype as Record<string, unknown>).getWorker =
+  (ConfigService.prototype as unknown as Record<string, unknown>).load =
+    origLoad;
+  (
+    ConfigService.prototype as unknown as Record<string, unknown>
+  ).listEnabledWorkers = origListEnabled;
+  (ConfigService.prototype as unknown as Record<string, unknown>).getWorker =
     origGetWorker;
-  (CloudflareService.prototype as Record<string, unknown>).deploy = origDeploy;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    origDeploy;
 });
 
 // ---------------------------------------------------------------------------
@@ -109,7 +117,8 @@ async function createProgram(): Promise<Command> {
 /** Make deployMock return a failure for all subsequent calls. */
 function makeDeployFail(error: string): void {
   deployMock = mock(async () => ({ ok: false as const, error }));
-  (CloudflareService.prototype as Record<string, unknown>).deploy = deployMock;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    deployMock;
 }
 
 // ---------------------------------------------------------------------------
@@ -169,8 +178,9 @@ describe("registerDeployCommand", () => {
         "hoox",
         "trade-worker",
       ]);
-      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-        listEnabledWorkersMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).listEnabledWorkers = listEnabledWorkersMock;
 
       const program = await createProgram();
       await program.parseAsync(["deploy", "workers"], { from: "user" });
@@ -181,8 +191,9 @@ describe("registerDeployCommand", () => {
 
     it("handles no enabled workers gracefully", async () => {
       listEnabledWorkersMock = mock(() => []);
-      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-        listEnabledWorkersMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).listEnabledWorkers = listEnabledWorkersMock;
 
       const program = await createProgram();
       await program.parseAsync(["deploy", "workers"], { from: "user" });
@@ -192,8 +203,9 @@ describe("registerDeployCommand", () => {
 
     it("continues deploying remaining workers on partial failure", async () => {
       listEnabledWorkersMock = mock(() => ["a", "b", "c"]);
-      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-        listEnabledWorkersMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).listEnabledWorkers = listEnabledWorkersMock;
 
       let calls = 0;
       deployMock = mock(async () => {
@@ -201,10 +213,14 @@ describe("registerDeployCommand", () => {
         if (calls === 2) {
           return { ok: false as const, error: "deploy error" };
         }
-        return { ok: true as const, data: { url: "https://x.workers.dev" } };
+        return {
+          ok: true as const,
+          value: { url: "https://x.workers.dev", rawOutput: "" },
+        };
       });
-      (CloudflareService.prototype as Record<string, unknown>).deploy =
-        deployMock;
+      (
+        CloudflareService.prototype as unknown as Record<string, unknown>
+      ).deploy = deployMock;
 
       const program = await createProgram();
       await program.parseAsync(["deploy", "workers"], { from: "user" });
@@ -215,8 +231,9 @@ describe("registerDeployCommand", () => {
 
     it("passes --env to deploy", async () => {
       listEnabledWorkersMock = mock(() => ["single-worker"]);
-      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
-        listEnabledWorkersMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).listEnabledWorkers = listEnabledWorkersMock;
 
       const program = await createProgram();
       await program.parseAsync(["deploy", "workers", "--env", "staging"], {
@@ -264,8 +281,9 @@ describe("registerDeployCommand", () => {
         enabled: true,
         path: "workers/hoox",
       }));
-      (ConfigService.prototype as Record<string, unknown>).getWorker =
-        getWorkerMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).getWorker = getWorkerMock;
 
       const program = await createProgram();
       await program.parseAsync(["deploy", "worker", "hoox"], { from: "user" });
@@ -275,8 +293,9 @@ describe("registerDeployCommand", () => {
 
     it("handles unknown worker name without calling deploy", async () => {
       getWorkerMock = mock(() => undefined);
-      (ConfigService.prototype as Record<string, unknown>).getWorker =
-        getWorkerMock;
+      (
+        ConfigService.prototype as unknown as Record<string, unknown>
+      ).getWorker = getWorkerMock;
 
       const program = await createProgram();
       await program.parseAsync(["deploy", "worker", "nonexistent"], {
@@ -294,7 +313,8 @@ describe("registerDeployCommand", () => {
     loadMock = mock(async () => {
       throw new Error("Config file not found");
     });
-    (ConfigService.prototype as Record<string, unknown>).load = loadMock;
+    (ConfigService.prototype as unknown as Record<string, unknown>).load =
+      loadMock;
 
     const program = await createProgram();
     await program.parseAsync(["deploy", "workers"], { from: "user" });

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

@@ -324,7 +324,7 @@ async function deployDashboard(
 
     if (action === "rebuild") {
       // Build + Deploy: bun run deploy (runs opennext:build && opennext:deploy)
-      const buildProc = Bun.spawn(["bun", "run", "opennext:deploy"], {
+      const buildProc = Bun.spawn(["bun", "run", "deploy"], {
         cwd: dashboardPath,
         stdout: "pipe",
         stderr: "pipe",
@@ -440,87 +440,6 @@ async function deployDashboard(
   }
 }
 
-/**
- * Print a summary table of deploy results.
- * Excluded in quiet mode; uses JSON or box-drawn table depending on --json.
- */
-function printSummary(
-  results: DeployResult[],
-  opts: { json?: boolean; quiet?: boolean }
-): void {
-  if (opts.quiet) return;
-
-  // Separate workers from dashboard for different formatting
-  const workerResults = results.filter((r) => r.worker !== "dashboard");
-  const dashboardResult = results.find((r) => r.worker === "dashboard");
-
-  // Print worker deployments with verbose info
-  if (workerResults.length > 0) {
-    process.stdout.write(`\n${theme.heading("Workers Deployed")}\n`);
-    for (const r of workerResults) {
-      const icon = r.success
-        ? theme.success(icons.success)
-        : theme.error(icons.error);
-      const status = r.success ? "deployed" : "failed";
-      process.stdout.write(`${icon} ${r.worker}: ${status}\n`);
-
-      if (r.success && r.url) {
-        process.stdout.write(`   ${theme.dim("URL:")} ${r.url}\n`);
-      }
-      if (r.success && r.size) {
-        process.stdout.write(`   ${theme.dim("Size:")} ${r.size}\n`);
-      }
-      if (r.success && r.startupTime) {
-        process.stdout.write(`   ${theme.dim("Startup:")} ${r.startupTime}\n`);
-      }
-      if (r.success && r.versionId) {
-        process.stdout.write(
-          `   ${theme.dim("Version:")} ${r.versionId.slice(0, 8)}...\n`
-        );
-      }
-      if (!r.success && r.error) {
-        process.stdout.write(`   ${theme.error("Error:")} ${r.error}\n`);
-      }
-    }
-  }
-
-  // Print dashboard deployment
-  if (dashboardResult) {
-    process.stdout.write(`\n${theme.heading("Dashboard Deployed")}\n`);
-    const icon = dashboardResult.success
-      ? theme.success(icons.success)
-      : theme.error(icons.error);
-    const status = dashboardResult.success ? "deployed" : "failed";
-    process.stdout.write(`${icon} dashboard: ${status}\n`);
-
-    if (dashboardResult.success && dashboardResult.url) {
-      process.stdout.write(`   ${theme.dim("URL:")} ${dashboardResult.url}\n`);
-    }
-    if (dashboardResult.success && dashboardResult.size) {
-      process.stdout.write(
-        `   ${theme.dim("Size:")} ${dashboardResult.size}\n`
-      );
-    }
-    if (dashboardResult.success && dashboardResult.startupTime) {
-      process.stdout.write(
-        `   ${theme.dim("Startup:")} ${dashboardResult.startupTime}\n`
-      );
-    }
-    if (!dashboardResult.success && dashboardResult.error) {
-      process.stdout.write(
-        `   ${theme.error("Error:")} ${dashboardResult.error}\n`
-      );
-    }
-  }
-
-  // Summary line
-  const succeeded = results.filter((r) => r.success).length;
-  const failed = results.filter((r) => !r.success).length;
-  process.stdout.write(
-    `\n${theme.heading("Summary:")} ${succeeded} succeeded, ${failed} failed\n`
-  );
-}
-
 // ---------------------------------------------------------------------------
 // Telegram webhook handler
 // ---------------------------------------------------------------------------
@@ -545,12 +464,12 @@ async function doTelegramWebhook(
     let botToken = token;
     if (!botToken) {
       const envVars = await EnvService.loadDotEnvAsync(".env.local");
-      botToken = envVars["TELEGRAM_BOT_TOKEN"];
+      botToken = envVars["TG_BOT_TOKEN_BINDING"];
     }
     if (!botToken) {
       formatError(
         new CLIError(
-          "Telegram bot token not found. Provide --token or set TELEGRAM_BOT_TOKEN in .env.local",
+          "Telegram bot token not found. Provide --token or set TG_BOT_TOKEN_BINDING in .env.local",
           ExitCode.ERROR
         ),
         fmt