@jango-blockchained/hoox-cli 0.5.1 → 0.5.6

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "@jango-blockchained/hoox-cli",
-  "version": "0.5.1",
+  "version": "0.5.6",
   "description": "Hoox CLI — manage Cloudflare Workers, infrastructure, secrets, and deployments (@jango-blockchained/hoox-cli)",
   "type": "module",
-  "main": "./bin/hoox.js",
-  "types": "./src/index.ts",
-  "exports": {
-    ".": "./bin/hoox.js"
-  },
   "bin": {
-    "hoox": "./bin/hoox.js",
-    "hx": "./bin/hoox.js"
+    "hoox": "bin/hoox.js",
+    "hx": "bin/hoox.js"
   },
   "scripts": {
     "test": "bun test",
@@ -22,23 +17,23 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.3.0",
-    "@jango-blockchained/hoox-shared": "workspace:*",
     "ansis": "^4.2.0",
     "commander": "^14.0.3",
     "jsonc-parser": "^3.3.1",
-    "wrangler": "^4.92.0"
+    "wrangler": "^4.95.0"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "bun-types": "^1.3.13",
-    "typescript": "^5.9.3"
+    "@jango-blockchained/hoox-shared": "^1.0.8",
+    "@types/node": "^25.8.0",
+    "bun-types": "^1.3.14",
+    "typescript": "^6.0.3"
   },
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jango-blockchained/hoox-setup.git"
+    "url": "git+https://github.com/jango-blockchained/hoox-setup.git"
   },
   "keywords": [
     "cloudflare",
@@ -56,7 +51,7 @@
   },
   "files": [
     "bin",
-    "src",
+    "dist",
     "README.md"
   ]
 }

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

@@ -1,476 +0,0 @@
-/**
- * Unit tests for the check command.
- *
- * Uses prototype mocking on ConfigService, CloudflareService, and SecretsService
- * to verify the command logic in isolation. @clack/prompts spinner is not
- * mocked — it degrades gracefully in non-TTY test environments.
- */
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Stub service prototypes
-// ---------------------------------------------------------------------------
-
-import { ConfigService } from "../../services/config/config-service.js";
-import { CloudflareService } from "../../services/cloudflare/cloudflare-service.js";
-import { SecretsService } from "../../services/secrets/secrets-service.js";
-
-// ---------------------------------------------------------------------------
-// Stub variables — reassigned in beforeEach
-// ---------------------------------------------------------------------------
-
-let loadMock: ReturnType<typeof mock>;
-let validateMock: ReturnType<typeof mock>;
-let getGlobalMock: ReturnType<typeof mock>;
-let listWorkersMock: ReturnType<typeof mock>;
-let listEnabledWorkersMock: ReturnType<typeof mock>;
-let getWorkerMock: ReturnType<typeof mock>;
-
-let d1ListMock: ReturnType<typeof mock>;
-let kvListMock: ReturnType<typeof mock>;
-let r2ListMock: ReturnType<typeof mock>;
-let queueListMock: ReturnType<typeof mock>;
-let tailMock: ReturnType<typeof mock>;
-let secretListMock: ReturnType<typeof mock>;
-
-let secretsCreateMock: ReturnType<typeof mock>;
-let checkLocalSecretsMock: ReturnType<typeof mock>;
-let listSecretsMock: ReturnType<typeof mock>;
-
-// Preserve originals for cleanup
-const origLoad = ConfigService.prototype.load;
-const origValidate = ConfigService.prototype.validate;
-const origGetGlobal = ConfigService.prototype.getGlobal;
-const origListWorkers = ConfigService.prototype.listWorkers;
-const origListEnabled = ConfigService.prototype.listEnabledWorkers;
-const origGetWorker = ConfigService.prototype.getWorker;
-
-const origD1List = CloudflareService.prototype.d1List;
-const origKvList = CloudflareService.prototype.kvList;
-const origR2List = CloudflareService.prototype.r2List;
-const origQueueList = CloudflareService.prototype.queueList;
-const origTail = CloudflareService.prototype.tail;
-const origSecretList = CloudflareService.prototype.secretList;
-
-const origCreate = SecretsService.create;
-const origCheckLocal = SecretsService.prototype.checkLocalSecrets;
-const origListSecrets = SecretsService.prototype.listSecrets;
-
-beforeEach(() => {
-  mock.restore();
-
-  // Reset process.exitCode between tests
-  process.exitCode = undefined;
-
-  // Reset to originals on prototypes
-  ConfigService.prototype.load = origLoad;
-  ConfigService.prototype.validate = origValidate;
-  ConfigService.prototype.getGlobal = origGetGlobal;
-  ConfigService.prototype.listWorkers = origListWorkers;
-  ConfigService.prototype.listEnabledWorkers = origListEnabled;
-  ConfigService.prototype.getWorker = origGetWorker;
-
-  CloudflareService.prototype.d1List = origD1List;
-  CloudflareService.prototype.kvList = origKvList;
-  CloudflareService.prototype.r2List = origR2List;
-  CloudflareService.prototype.queueList = origQueueList;
-  CloudflareService.prototype.tail = origTail;
-  CloudflareService.prototype.secretList = origSecretList;
-
-  // Fresh mocks
-  loadMock = mock(async () => ({}));
-  validateMock = mock(() => ({ valid: true, errors: [] }));
-  getGlobalMock = mock(() => ({
-    cloudflare_account_id: "abc123",
-  }));
-  listWorkersMock = mock(() => ["d1-worker", "hoox", "trade-worker"]);
-  listEnabledWorkersMock = mock(() => ["d1-worker", "hoox", "trade-worker"]);
-  getWorkerMock = mock((_name: string) => ({
-    enabled: true,
-    path: "workers/test-worker",
-  }));
-
-  d1ListMock = mock(async () => ({
-    ok: true as const,
-    data: "my-database (abc-123)",
-  }));
-  kvListMock = mock(async () => ({
-    ok: true as const,
-    data: "namespace-1 (id1)\nnamespace-2 (id2)",
-  }));
-  r2ListMock = mock(async () => ({
-    ok: true as const,
-    data: "bucket-1\nbucket-2",
-  }));
-  queueListMock = mock(async () => ({
-    ok: true as const,
-    data: "queue-1\nqueue-2",
-  }));
-  tailMock = mock(async () => ({
-    ok: true as const,
-    data: "Connected to worker",
-  }));
-  secretListMock = mock(async () => ({
-    ok: true as const,
-    data: "Secret names: API_KEY, DB_PASSWORD",
-  }));
-
-  secretsCreateMock = mock(async () =>
-    Object.create(SecretsService.prototype, {
-      checkLocalSecrets: {
-        value: mock(async () => ({ allSet: true, missing: [], secrets: [] })),
-      },
-      listSecrets: { value: mock(() => []) },
-    })
-  );
-
-  checkLocalSecretsMock = mock(async () => ({
-    worker: "test-worker",
-    secrets: [],
-    allSet: true,
-    missing: [],
-  }));
-  listSecretsMock = mock(() => ["API_KEY"]);
-
-  // Apply stubs
-  ConfigService.prototype.load = loadMock;
-  ConfigService.prototype.validate = validateMock;
-  ConfigService.prototype.getGlobal = getGlobalMock;
-  ConfigService.prototype.listWorkers = listWorkersMock;
-  ConfigService.prototype.listEnabledWorkers = listEnabledWorkersMock;
-  ConfigService.prototype.getWorker = getWorkerMock;
-
-  CloudflareService.prototype.d1List = d1ListMock;
-  CloudflareService.prototype.kvList = kvListMock;
-  CloudflareService.prototype.r2List = r2ListMock;
-  CloudflareService.prototype.queueList = queueListMock;
-  CloudflareService.prototype.tail = tailMock;
-  CloudflareService.prototype.secretList = secretListMock;
-
-  // Replace static create on SecretsService
-  (SecretsService as unknown as Record<string, unknown>).create =
-    secretsCreateMock;
-});
-
-afterEach(() => {
-  mock.restore();
-
-  // Restore originals
-  ConfigService.prototype.load = origLoad;
-  ConfigService.prototype.validate = origValidate;
-  ConfigService.prototype.getGlobal = origGetGlobal;
-  ConfigService.prototype.listWorkers = origListWorkers;
-  ConfigService.prototype.listEnabledWorkers = origListEnabled;
-  ConfigService.prototype.getWorker = origGetWorker;
-
-  CloudflareService.prototype.d1List = origD1List;
-  CloudflareService.prototype.kvList = origKvList;
-  CloudflareService.prototype.r2List = origR2List;
-  CloudflareService.prototype.queueList = origQueueList;
-  CloudflareService.prototype.tail = origTail;
-  CloudflareService.prototype.secretList = origSecretList;
-
-  (SecretsService as unknown as Record<string, unknown>).create = origCreate;
-  SecretsService.prototype.checkLocalSecrets = origCheckLocal;
-  SecretsService.prototype.listSecrets = origListSecrets;
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Dynamically import the check command after mocks are in place.
- */
-async function importCheckCommand(): Promise<{
-  registerCheckCommand: typeof import("./check-command.js").registerCheckCommand;
-}> {
-  return import("./check-command.js");
-}
-
-import { Command } from "commander";
-import { ExitCode } from "../../utils/errors.js";
-
-async function createProgram() {
-  const { registerCheckCommand } = await importCheckCommand();
-  const program = new Command()
-    .name("hoox-test")
-    .option("--json", "Output in JSON format")
-    .option("--quiet", "Minimal output")
-    .exitOverride(() => {
-      // Suppress Commander's own exit during tests
-    });
-  registerCheckCommand(program);
-  return program;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("registerCheckCommand", () => {
-  // -- Command registration -------------------------------------------------
-
-  it("registers 'check' as a command on the program", async () => {
-    const program = await createProgram();
-    const checkCmd = program.commands.find((c) => c.name() === "check");
-    expect(checkCmd).toBeDefined();
-  });
-
-  it("registers 'check setup' subcommand", async () => {
-    const program = await createProgram();
-    const checkCmd = program.commands.find((c) => c.name() === "check")!;
-    const setupCmd = checkCmd.commands.find((c) => c.name() === "setup");
-    expect(setupCmd).toBeDefined();
-    expect(setupCmd!.description()).toContain("validation");
-  });
-
-  it("registers 'check health' subcommand", async () => {
-    const program = await createProgram();
-    const checkCmd = program.commands.find((c) => c.name() === "check")!;
-    const healthCmd = checkCmd.commands.find((c) => c.name() === "health");
-    expect(healthCmd).toBeDefined();
-    expect(healthCmd!.description()).toContain("health");
-  });
-
-  it("registers 'check fix' subcommand", async () => {
-    const program = await createProgram();
-    const checkCmd = program.commands.find((c) => c.name() === "check")!;
-    const fixCmd = checkCmd.commands.find((c) => c.name() === "fix");
-    expect(fixCmd).toBeDefined();
-    expect(fixCmd!.description()).toContain("Repair");
-  });
-
-  // -- check setup ----------------------------------------------------------
-
-  describe("check setup", () => {
-    it(
-      "loads config and runs all 4 categories",
-      { timeout: 30000 },
-      async () => {
-        const program = await createProgram();
-        await program.parseAsync(["check", "setup"], { from: "user" });
-
-        expect(loadMock).toHaveBeenCalled();
-        expect(d1ListMock).toHaveBeenCalled();
-        expect(kvListMock).toHaveBeenCalled();
-        expect(r2ListMock).toHaveBeenCalled();
-        expect(queueListMock).toHaveBeenCalled();
-      }
-    );
-
-    it("outputs JSON when --json flag is set", { timeout: 30000 }, async () => {
-      const program = await createProgram();
-      const logSpy = mock((..._args: unknown[]) => {});
-      const origWrite = process.stdout.write;
-      (process.stdout as unknown as Record<string, unknown>).write = logSpy;
-
-      try {
-        await program.parseAsync(["--json", "check", "setup"], {
-          from: "user",
-        });
-
-        // Should have called stdout.write with JSON
-        const jsonCalls = (
-          logSpy as unknown as { mock: { calls: Array<unknown[]> } }
-        ).mock.calls.filter((call: unknown[]) => {
-          const str = String(call[0] ?? "");
-          try {
-            JSON.parse(str);
-            return str.includes("categories") && str.includes("summary");
-          } catch {
-            return false;
-          }
-        });
-        expect(jsonCalls.length).toBeGreaterThan(0);
-      } finally {
-        (process.stdout as unknown as Record<string, unknown>).write =
-          origWrite;
-      }
-    });
-
-    it(
-      "sets exitCode to ERROR when validation fails",
-      { timeout: 30000 },
-      async () => {
-        validateMock = mock(() => ({
-          valid: false,
-          errors: ["global.cloudflare_account_id is required"],
-        }));
-        ConfigService.prototype.validate = validateMock;
-
-        const program = await createProgram();
-        await program.parseAsync(["check", "setup"], { from: "user" });
-
-        expect(process.exitCode).toBe(ExitCode.ERROR);
-      }
-    );
-
-    it("sets exitCode to ERROR when infra check fails", async () => {
-      d1ListMock = mock(async () => ({
-        ok: false as const,
-        error: "Authentication failed",
-      }));
-      CloudflareService.prototype.d1List = d1ListMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["check", "setup"], { from: "user" });
-
-      expect(process.exitCode).toBe(ExitCode.ERROR);
-    });
-
-    it("handles config load failure gracefully", async () => {
-      loadMock = mock(async () => {
-        throw new Error("Config file not found");
-      });
-      ConfigService.prototype.load = loadMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["check", "setup"], { from: "user" });
-
-      expect(process.exitCode).toBe(ExitCode.ERROR);
-    });
-  });
-
-  // -- check health ---------------------------------------------------------
-
-  describe("check health", () => {
-    it("checks connectivity for all enabled workers", async () => {
-      const program = await createProgram();
-      await program.parseAsync(["check", "health"], { from: "user" });
-
-      expect(loadMock).toHaveBeenCalled();
-      // tailMock should have been called for each enabled worker
-      expect(tailMock).toHaveBeenCalled();
-    });
-
-    it("outputs JSON when --json flag is set", async () => {
-      const program = await createProgram();
-      const logSpy = mock((..._args: unknown[]) => {});
-      const origWrite = process.stdout.write;
-      (process.stdout as unknown as Record<string, unknown>).write = logSpy;
-
-      try {
-        await program.parseAsync(["--json", "check", "health"], {
-          from: "user",
-        });
-
-        const jsonCalls = (
-          logSpy as unknown as { mock: { calls: Array<unknown[]> } }
-        ).mock.calls.filter((call: unknown[]) => {
-          const str = String(call[0] ?? "");
-          try {
-            const parsed = JSON.parse(str);
-            return Array.isArray(parsed) && parsed.length > 0;
-          } catch {
-            return false;
-          }
-        });
-        expect(jsonCalls.length).toBeGreaterThan(0);
-      } finally {
-        (process.stdout as unknown as Record<string, unknown>).write =
-          origWrite;
-      }
-    });
-
-    it("sets exitCode to ERROR when any worker is unhealthy", async () => {
-      tailMock = mock(async () => ({
-        ok: false as const,
-        error: "Worker not reachable",
-      }));
-      CloudflareService.prototype.tail = tailMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["check", "health"], { from: "user" });
-
-      expect(process.exitCode).toBe(ExitCode.ERROR);
-    });
-
-    it("handles empty worker list gracefully", async () => {
-      listEnabledWorkersMock = mock(() => []);
-      ConfigService.prototype.listEnabledWorkers = listEnabledWorkersMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["check", "health"], { from: "user" });
-
-      // Should exit cleanly — the handler outputs success message
-      expect(process.exitCode).toBe(1);
-    });
-  });
-
-  // -- check fix ------------------------------------------------------------
-
-  describe("check fix", () => {
-    it("scans for issues and reports when dry-run", async () => {
-      const program = await createProgram();
-
-      // Mock Bun.file so .dev.vars doesn't exist (triggers fix action)
-      const origBunFile = Bun.file;
-      (Bun as Record<string, unknown>).file = mock((_path: string) => ({
-        exists: mock(async () => false),
-        text: mock(async () => ""),
-        name: _path,
-      }));
-
-      try {
-        await program.parseAsync(["check", "fix", "--dry-run"], {
-          from: "user",
-        });
-
-        // Should complete without errors
-        // In dry-run mode, exitCode should not be ERROR (no actual failures to apply)
-      } finally {
-        (Bun as Record<string, unknown>).file = origBunFile;
-      }
-    });
-
-    it("outputs JSON when --json flag is set", async () => {
-      const program = await createProgram();
-      const logSpy = mock((..._args: unknown[]) => {});
-      const origWrite = process.stdout.write;
-      (process.stdout as unknown as Record<string, unknown>).write = logSpy;
-
-      const origBunFile = Bun.file;
-      (Bun as Record<string, unknown>).file = mock((_path: string) => ({
-        exists: mock(async () => false),
-        text: mock(async () => ""),
-        name: _path,
-      }));
-
-      try {
-        await program.parseAsync(["--json", "check", "fix", "--dry-run"], {
-          from: "user",
-        });
-
-        const jsonCalls = (
-          logSpy as unknown as { mock: { calls: Array<unknown[]> } }
-        ).mock.calls.filter((call: unknown[]) => {
-          const str = String(call[0] ?? "");
-          try {
-            const parsed = JSON.parse(str);
-            return parsed.actions !== undefined && parsed.summary !== undefined;
-          } catch {
-            return false;
-          }
-        });
-        expect(jsonCalls.length).toBeGreaterThan(0);
-      } finally {
-        (process.stdout as unknown as Record<string, unknown>).write =
-          origWrite;
-        (Bun as Record<string, unknown>).file = origBunFile;
-      }
-    });
-
-    it("handles config load failure gracefully", async () => {
-      loadMock = mock(async () => {
-        throw new Error("Config file not found");
-      });
-      ConfigService.prototype.load = loadMock;
-
-      const program = await createProgram();
-      await program.parseAsync(["check", "fix"], { from: "user" });
-
-      expect(process.exitCode).toBe(ExitCode.ERROR);
-    });
-  });
-});