@jango-blockchained/hoox-cli 0.3.4

package/src/commands/deploy/index.ts

@@ -0,0 +1,2 @@
+export { registerDeployCommand } from "./deploy-command.js";
+export type { DeployOptions, DeployResult } from "./types.js";

package/src/commands/deploy/telegram-service.ts

@@ -0,0 +1,61 @@
+/**
+ * Service for interacting with the Telegram Bot API.
+ * Used by `hoox deploy telegram-webhook`.
+ */
+
+export class TelegramService {
+  /**
+   * Set the webhook for a Telegram bot.
+   * POST https://api.telegram.org/bot{TOKEN}/setWebhook
+   */
+  async setWebhook(
+    botToken: string,
+    webhookUrl: string,
+    secretToken: string,
+  ): Promise<{ ok: boolean; description?: string; error?: string }> {
+    try {
+      const url = `https://api.telegram.org/bot${botToken}/setWebhook`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ url: webhookUrl, secret_token: secretToken }),
+      });
+      const data = (await response.json()) as { ok: boolean; description?: string };
+      return { ok: data.ok, description: data.description };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  /**
+   * Get the current webhook status.
+   * GET https://api.telegram.org/bot{TOKEN}/getWebhookInfo
+   */
+  async getWebhookInfo(botToken: string): Promise<{
+    ok: boolean;
+    url?: string;
+    has_custom_certificate?: boolean;
+    pending_update_count?: number;
+    error?: string;
+  }> {
+    try {
+      const response = await fetch(`https://api.telegram.org/bot${botToken}/getWebhookInfo`);
+      const data = (await response.json()) as {
+        ok: boolean;
+        result?: { url: string; has_custom_certificate: boolean; pending_update_count: number };
+        description?: string;
+      };
+      if (data.ok && data.result) {
+        return {
+          ok: true,
+          url: data.result.url,
+          has_custom_certificate: data.result.has_custom_certificate,
+          pending_update_count: data.result.pending_update_count,
+        };
+      }
+      return { ok: false, error: data.description };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+}

package/src/commands/deploy/types.ts

@@ -0,0 +1,34 @@
+/**
+ * Deploy command types — options and result interfaces for the deploy
+ * command group (all, workers, worker, dashboard).
+ */
+
+/**
+ * Options for a single worker deployment.
+ */
+export interface DeployOptions {
+  /** Cloudflare environment (e.g. "production", "staging"). */
+  env?: string;
+}
+
+/**
+ * Result of deploying a single worker.
+ */
+export interface DeployResult {
+  /** Worker name as defined in wrangler.jsonc. */
+  worker: string;
+  /** Deployed URL extracted from wrangler output, if available. */
+  url?: string;
+  /** Whether the deployment succeeded. */
+  success: boolean;
+  /** Error message when success is false. */
+  error?: string;
+  /** Bundle size (e.g., "7102.32 KiB") */
+  size?: string;
+  /** Worker startup time (e.g., "37 ms") */
+  startupTime?: string;
+  /** Version ID */
+  versionId?: string;
+  /** Raw wrangler output (first non-empty line, for debugging) */
+  rawOutput?: string;
+}

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

@@ -0,0 +1,383 @@
+// @ts-nocheck
+/**
+ * Unit tests for the dev command.
+ *
+ * Stubs ConfigService and CloudflareService prototypes to verify the dev
+ * command logic in isolation. Uses Commander's exitOverride to suppress
+ * process exits during test runs.
+ *
+ * Subcommand actions are async — we use parseAsync() and then inspect mocks
+ * to confirm correct service calls.
+ */
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import { Command } from "commander";
+import { ConfigService } from "../../services/config/config-service.js";
+import { CloudflareService } from "../../services/cloudflare/cloudflare-service.js";
+import { PrerequisitesService } from "../../services/prerequisites/index.js";
+import { DockerService } from "../../services/docker/index.js";
+
+// ---------------------------------------------------------------------------
+// Stub variables — reassigned in beforeEach
+// ---------------------------------------------------------------------------
+
+let devMock: ReturnType<typeof mock>;
+let loadMock: ReturnType<typeof mock>;
+let listWorkersMock: ReturnType<typeof mock>;
+let listEnabledWorkersMock: ReturnType<typeof mock>;
+let getWorkerMock: ReturnType<typeof mock>;
+let validateMock: ReturnType<typeof mock>;
+let getDevRuntimeMock: ReturnType<typeof mock>;
+let checkWranglerMock: ReturnType<typeof mock>;
+let dockerCheckMock: ReturnType<typeof mock>;
+let composeExistsMock: ReturnType<typeof mock>;
+
+// Preserve originals so we can restore them after tests
+const origLoad = ConfigService.prototype
+  .load as typeof ConfigService.prototype.load;
+const origListWorkers = ConfigService.prototype
+  .listWorkers as typeof ConfigService.prototype.listWorkers;
+const origListEnabled = ConfigService.prototype
+  .listEnabledWorkers as typeof ConfigService.prototype.listEnabledWorkers;
+const origGetWorker = ConfigService.prototype
+  .getWorker as typeof ConfigService.prototype.getWorker;
+const origValidate = ConfigService.prototype
+  .validate as typeof ConfigService.prototype.validate;
+const origGetDevRuntime = ConfigService.prototype
+  .getDevRuntime as typeof ConfigService.prototype.getDevRuntime;
+const origDev = CloudflareService.prototype
+  .dev as typeof CloudflareService.prototype.dev;
+const origCheckWrangler = PrerequisitesService.prototype
+  .checkWranglerVersion as typeof PrerequisitesService.prototype.checkWranglerVersion;
+const origDockerCheck = DockerService.prototype
+  .checkAvailability as typeof DockerService.prototype.checkAvailability;
+const origComposeExists = DockerService.prototype
+  .composeFileExists as typeof DockerService.prototype.composeFileExists;
+
+// Preserve original Bun globals
+const origBunSpawn = Bun.spawn;
+const origBunFile = Bun.file;
+
+beforeEach(() => {
+  mock.restore();
+
+  // Reset process.exitCode between tests
+  process.exitCode = undefined;
+
+  // Restore prototypes to originals
+  (ConfigService.prototype as Record<string, unknown>).load = origLoad;
+  (ConfigService.prototype as Record<string, unknown>).listWorkers =
+    origListWorkers;
+  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
+    origListEnabled;
+  (ConfigService.prototype as Record<string, unknown>).getWorker =
+    origGetWorker;
+  (ConfigService.prototype as Record<string, unknown>).validate = origValidate;
+  (CloudflareService.prototype as Record<string, unknown>).dev = origDev;
+
+  // Stub Bun.spawn to prevent actual process spawning during tests.
+  // Uses individual property assignment (not globalThis.Bun = {...}) to
+  // avoid "readonly property" errors in Bun 1.3.x.
+  (Bun as unknown as Record<string, unknown>).spawn = mock(() => ({
+    stdout: new Blob([]),
+    stderr: new Blob([]),
+    exited: Promise.resolve(0),
+    stdin: { write: mock(() => {}), end: mock(() => {}) },
+    kill: mock(() => {}),
+  }));
+  (Bun as unknown as Record<string, unknown>).file = mock((_path: string) => ({
+    exists: mock(async () => true),
+  }));
+
+  // Fresh mocks
+  devMock = mock(async (_path: string, _port?: number) => ({
+    ok: true as const,
+    data: { port: _port ?? 8787 },
+  }));
+
+  loadMock = mock(async function () {
+    // Use a regular function so `this` refers to the ConfigService instance
+    (this as Record<string, unknown>).config = {};
+    return {} as Record<string, unknown>;
+  });
+  listWorkersMock = mock(() => ["hoox", "trade-worker", "d1-worker"]);
+  listEnabledWorkersMock = mock(() => ["hoox", "trade-worker", "d1-worker"]);
+  getWorkerMock = mock((_name: string) => ({
+    enabled: true,
+    path: "workers/test-worker",
+  }));
+  validateMock = mock(() => ({ valid: true, errors: [] }));
+  getDevRuntimeMock = mock(() => "native");
+  checkWranglerMock = mock(async () => ({
+    outdated: false,
+  }));
+  dockerCheckMock = mock(async () => ({ docker: false, compose: false }));
+  composeExistsMock = mock(async () => false);
+
+  // Install mocks on prototypes
+  (ConfigService.prototype as Record<string, unknown>).load = loadMock;
+  (ConfigService.prototype as Record<string, unknown>).listWorkers =
+    listWorkersMock;
+  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
+    listEnabledWorkersMock;
+  (ConfigService.prototype as Record<string, unknown>).getWorker =
+    getWorkerMock;
+  (ConfigService.prototype as Record<string, unknown>).validate = validateMock;
+  (ConfigService.prototype as Record<string, unknown>).getDevRuntime =
+    getDevRuntimeMock;
+  (CloudflareService.prototype as Record<string, unknown>).dev = devMock;
+  (
+    PrerequisitesService.prototype as Record<string, unknown>
+  ).checkWranglerVersion = checkWranglerMock;
+  (DockerService.prototype as Record<string, unknown>).checkAvailability =
+    dockerCheckMock;
+  (DockerService.prototype as Record<string, unknown>).composeFileExists =
+    composeExistsMock;
+});
+
+afterEach(() => {
+  mock.restore();
+
+  // Restore originals
+  (ConfigService.prototype as Record<string, unknown>).load = origLoad;
+  (ConfigService.prototype as Record<string, unknown>).listWorkers =
+    origListWorkers;
+  (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
+    origListEnabled;
+  (ConfigService.prototype as Record<string, unknown>).getWorker =
+    origGetWorker;
+  (ConfigService.prototype as Record<string, unknown>).validate = origValidate;
+  (ConfigService.prototype as Record<string, unknown>).getDevRuntime =
+    origGetDevRuntime;
+  (CloudflareService.prototype as Record<string, unknown>).dev = origDev;
+  (
+    PrerequisitesService.prototype as Record<string, unknown>
+  ).checkWranglerVersion = origCheckWrangler;
+  (DockerService.prototype as Record<string, unknown>).checkAvailability =
+    origDockerCheck;
+  (DockerService.prototype as Record<string, unknown>).composeFileExists =
+    origComposeExists;
+
+  // Restore Bun globals (individual property restore)
+  (Bun as unknown as Record<string, unknown>).spawn = origBunSpawn;
+  (Bun as unknown as Record<string, unknown>).file = origBunFile;
+});
+
+// ---------------------------------------------------------------------------
+// Dynamic import — load the dev command after stubs are in place
+// ---------------------------------------------------------------------------
+
+async function importDevCommand(): Promise<{
+  registerDevCommand: typeof import("./dev-command.js").registerDevCommand;
+}> {
+  return import("./dev-command.js");
+}
+
+/**
+ * Create a fresh Commander program with the dev command registered.
+ */
+async function createProgram(): Promise<Command> {
+  const { registerDevCommand } = await importDevCommand();
+  const program = new Command().name("hoox-test").exitOverride(() => {
+    // Suppress Commander's own exit during tests
+  });
+  registerDevCommand(program);
+  return program;
+}
+
+/** Make devMock return a failure for all subsequent calls. */
+function makeDevFail(error: string): void {
+  devMock = mock(async () => ({ ok: false as const, error }));
+  (CloudflareService.prototype as Record<string, unknown>).dev = devMock;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("registerDevCommand", () => {
+  // -- Command registration --------------------------------------------------
+
+  it("registers 'dev' as a command on the program", async () => {
+    const program = await createProgram();
+    const devCmd = program.commands.find((c) => c.name() === "dev");
+    expect(devCmd).toBeDefined();
+  });
+
+  it("registers 'dev start' subcommand", async () => {
+    const program = await createProgram();
+    const devCmd = program.commands.find((c) => c.name() === "dev")!;
+    const startCmd = devCmd.commands.find((c) => c.name() === "start");
+    expect(startCmd).toBeDefined();
+    expect(startCmd!.description()).toContain("wrangler dev");
+  });
+
+  it("registers 'dev worker <name>' subcommand with argument", async () => {
+    const program = await createProgram();
+    const devCmd = program.commands.find((c) => c.name() === "dev")!;
+    const workerCmd = devCmd.commands.find((c) => c.name() === "worker");
+    expect(workerCmd).toBeDefined();
+    expect(workerCmd!.description()).toContain("wrangler dev");
+    const args = workerCmd!.registeredArguments;
+    expect(args.some((a) => a.name() === "name")).toBe(true);
+  });
+
+  it("registers 'dev dashboard' subcommand", async () => {
+    const program = await createProgram();
+    const devCmd = program.commands.find((c) => c.name() === "dev")!;
+    const dashboardCmd = devCmd.commands.find((c) => c.name() === "dashboard");
+    expect(dashboardCmd).toBeDefined();
+    expect(dashboardCmd!.description()).toContain("dashboard");
+  });
+
+  // -- dev start -------------------------------------------------------------
+
+  describe("dev start", () => {
+    it("handles config validation failure gracefully", async () => {
+      validateMock = mock(() => ({
+        valid: false,
+        errors: ["global.cloudflare_account_id is required"],
+      }));
+      (ConfigService.prototype as Record<string, unknown>).validate =
+        validateMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "start"], { from: "user" });
+
+      expect(process.exitCode).toBe(2); // INVALID_USAGE
+    });
+
+    it("handles no enabled workers gracefully", async () => {
+      listEnabledWorkersMock = mock(() => []);
+      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
+        listEnabledWorkersMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "start"], { from: "user" });
+
+      expect(process.exitCode).toBe(2); // INVALID_USAGE
+    });
+
+    it("starts all enabled workers on assigned ports", async () => {
+      listEnabledWorkersMock = mock(() => ["hoox", "trade-worker"]);
+      (ConfigService.prototype as Record<string, unknown>).listEnabledWorkers =
+        listEnabledWorkersMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "start"], { from: "user" });
+
+      // Both workers should be started via CloudflareService.dev()
+      expect(devMock).toHaveBeenCalledTimes(2);
+      const calls = (
+        devMock as unknown as { mock: { calls: Array<unknown[]> } }
+      ).mock.calls;
+      // hoox → port 8787, trade-worker → port 8788
+      expect(calls[0][1]).toBe(8787);
+      expect(calls[1][1]).toBe(8788);
+      // exitCode remains unset since the action ran successfully
+    });
+  });
+
+  // -- dev worker <name> -----------------------------------------------------
+
+  describe("dev worker <name>", () => {
+    it("starts the specified worker with default port", async () => {
+      const program = await createProgram();
+      await program.parseAsync(["dev", "worker", "hoox"], { from: "user" });
+
+      expect(devMock).toHaveBeenCalledTimes(1);
+      const calls = (
+        devMock as unknown as { mock: { calls: Array<unknown[]> } }
+      ).mock.calls;
+      expect(calls[0][0]).toContain("test-worker");
+      expect(calls[0][1]).toBe(8787);
+    });
+
+    it("passes --port to dev service", async () => {
+      const program = await createProgram();
+      await program.parseAsync(["dev", "worker", "hoox", "--port", "3000"], {
+        from: "user",
+      });
+
+      const calls = (
+        devMock as unknown as { mock: { calls: Array<unknown[]> } }
+      ).mock.calls;
+      expect(calls[0][1]).toBe(3000);
+    });
+
+    it("handles unknown worker name", async () => {
+      getWorkerMock = mock(() => undefined);
+      (ConfigService.prototype as Record<string, unknown>).getWorker =
+        getWorkerMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "worker", "nonexistent"], {
+        from: "user",
+      });
+
+      expect(devMock).toHaveBeenCalledTimes(0);
+      expect(process.exitCode).toBe(2); // INVALID_USAGE
+    });
+
+    it("handles disabled worker", async () => {
+      getWorkerMock = mock(() => ({
+        enabled: false,
+        path: "workers/disabled-worker",
+      }));
+      (ConfigService.prototype as Record<string, unknown>).getWorker =
+        getWorkerMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "worker", "disabled-worker"], {
+        from: "user",
+      });
+
+      expect(devMock).toHaveBeenCalledTimes(0);
+      expect(process.exitCode).toBe(2); // INVALID_USAGE
+    });
+
+    it("handles dev failure (sets exitCode to 1)", async () => {
+      makeDevFail("wrangler not found");
+      getWorkerMock = mock(() => ({
+        enabled: true,
+        path: "workers/hoox",
+      }));
+      (ConfigService.prototype as Record<string, unknown>).getWorker =
+        getWorkerMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "worker", "hoox"], { from: "user" });
+
+      expect(process.exitCode).toBe(1); // ERROR
+    });
+  });
+
+  // -- dev dashboard ---------------------------------------------------------
+
+  describe("dev dashboard", () => {
+    it("handles missing dashboard directory", async () => {
+      // Override Bun.file for this test to say dashboard doesn't exist
+      (Bun as unknown as Record<string, unknown>).file = mock((_p: string) => ({
+        exists: mock(async () => false),
+      }));
+
+      const program = await createProgram();
+      await program.parseAsync(["dev", "dashboard"], { from: "user" });
+
+      expect(process.exitCode).toBe(2); // INVALID_USAGE
+    });
+  });
+
+  // -- config loading errors ------------------------------------------------
+
+  it("handles config load failure gracefully", async () => {
+    loadMock = mock(async () => {
+      throw new Error("Config file not found");
+    });
+    (ConfigService.prototype as Record<string, unknown>).load = loadMock;
+
+    const program = await createProgram();
+    await program.parseAsync(["dev", "start"], { from: "user" });
+
+    expect(process.exitCode).toBe(1);
+  });
+});