@jango-blockchained/hoox-cli 0.3.4 → 0.3.5

package/src/services/secrets/secrets-service.ts

@@ -1,8 +1,8 @@
 import { parse as parseJsonc } from "jsonc-parser";
 import type {
+  Result,
   SecretCheckResult,
   SecretStatus,
-  WranglerResult,
   WorkersJsonc,
 } from "./types.js";
 
@@ -140,11 +140,11 @@ export class SecretsService {
    * Creates (or overwrites) a `.dev.vars` template file for a worker
    * with placeholder values for every secret declared in `wrangler.jsonc`.
    */
-  async generateDevVars(workerName: string): Promise<WranglerResult<string>> {
+  async generateDevVars(workerName: string): Promise<Result<string>> {
     const worker = this.config.workers[workerName];
     if (!worker) {
       return {
-        success: false,
+        ok: false,
         error: `Worker "${workerName}" not found in config`,
       };
     }
@@ -159,10 +159,10 @@ export class SecretsService {
 
     try {
       await Bun.write(devVarsPath, content);
-      return { success: true, data: devVarsPath };
+      return { ok: true, value: devVarsPath };
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : String(err);
-      return { success: false, error: `Failed to write .dev.vars: ${message}` };
+      return { ok: false, error: `Failed to write .dev.vars: ${message}` };
     }
   }
 
@@ -173,13 +173,11 @@ export class SecretsService {
    * the worker's `.dev.vars` file.  Secrets with placeholder values are
    * skipped and reported as errors.
    */
-  async syncToCloudflare(
-    workerName: string
-  ): Promise<WranglerResult<string[]>> {
+  async syncToCloudflare(workerName: string): Promise<Result<string[]>> {
     const worker = this.config.workers[workerName];
     if (!worker) {
       return {
-        success: false,
+        ok: false,
         error: `Worker "${workerName}" not found in config`,
       };
     }
@@ -215,15 +213,11 @@ export class SecretsService {
       }
     }
 
-    if (synced.length === 0 && errors.length > 0) {
-      return { success: false, error: errors.join("; ") };
+    if (errors.length > 0) {
+      return { ok: false, error: errors.join("; ") };
     }
 
-    return {
-      success: errors.length === 0,
-      data: synced,
-      error: errors.length > 0 ? errors.join("; ") : undefined,
-    };
+    return { ok: true, value: synced };
   }
 
   // -----------------------------------------------------------------------

package/src/services/secrets/types.ts

@@ -1,22 +1,15 @@
 /**
  * SecretsService types — secret management for Cloudflare Workers.
- *
- * The `Result<T>` discriminated-union mirrors the pattern used in
- * @jango-blockchained/hoox-shared (see packages/shared/src/types.ts:92) but is defined
- * locally to avoid adding a public export to the shared package.
  */
 
 // ---------------------------------------------------------------------------
-// Result / Wrangler
+// Result
 // ---------------------------------------------------------------------------
 
-export type Result<T> = { ok: true; value: T } | { ok: false; error: string };
+import type { Result } from "@jango-blockchained/hoox-shared";
 
-export interface WranglerResult<T> {
-  success: boolean;
-  data?: T;
-  error?: string;
-}
+// Re-export the shared Result<T> for convenience
+export type { Result };
 
 // ---------------------------------------------------------------------------
 // Domain types

package/src/services/update/index.ts

@@ -0,0 +1,2 @@
+export { UpdateService } from "./update-service.js";
+export type { UpdateResult } from "./update-service.js";

package/src/services/update/update-service.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it, mock } from "bun:test";
+import { UpdateService } from "./update-service.js";
+
+function createMockPrereqs(
+  overrides?: Partial<{
+    outdated: boolean;
+    current: string;
+    minimum: string;
+  }>
+) {
+  const defaults = { outdated: false, current: "4.0.0", minimum: "3.88.0" };
+  const config = { ...defaults, ...overrides };
+
+  return {
+    checkWranglerVersion: mock(() => Promise.resolve(config)),
+    checkBun: mock(() => Promise.resolve({})),
+    checkGit: mock(() => Promise.resolve({})),
+    checkNode: mock(() => Promise.resolve({})),
+    checkWrangler: mock(() => Promise.resolve({})),
+    checkCloudflareAuth: mock(() => Promise.resolve({})),
+    checkDocker: mock(() => Promise.resolve({})),
+    checkRepository: mock(() => Promise.resolve({})),
+    runAll: mock(() => Promise.resolve({ checks: [], allPassed: true })),
+  };
+}
+
+describe("UpdateService", () => {
+  describe("checkAndPromptUpdate", () => {
+    it("returns updated=false when wrangler is up to date", async () => {
+      const mockPrereqs = createMockPrereqs({ outdated: false });
+      const svc = new UpdateService(undefined, mockPrereqs as any);
+
+      const result = await svc.checkAndPromptUpdate({ yes: true });
+
+      expect(result.updated).toBe(false);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("auto-updates when wrangler is outdated and --yes is set", async () => {
+      const mockPrereqs = createMockPrereqs({
+        outdated: true,
+        current: "3.87.0",
+      });
+      const svc = new UpdateService(undefined, mockPrereqs as any);
+
+      const result = await svc.checkAndPromptUpdate({ yes: true });
+
+      expect(typeof result.updated).toBe("boolean");
+    }, 30000);
+  });
+
+  describe("updateWrangler", () => {
+    it("returns result when called (does not throw)", async () => {
+      const mockPrereqs = createMockPrereqs({
+        outdated: false,
+        current: "4.0.0",
+      });
+      const svc = new UpdateService(undefined, mockPrereqs as any);
+
+      const result = await svc.updateWrangler();
+
+      expect(typeof result.updated).toBe("boolean");
+    }, 30000);
+  });
+
+  describe("checkLatestVersion", () => {
+    it("returns a version string or null", async () => {
+      const svc = new UpdateService();
+      const version = await svc.checkLatestVersion();
+      expect(version === null || typeof version === "string").toBe(true);
+      if (typeof version === "string") {
+        expect(version).toMatch(/^\d+\.\d+\.\d+$/);
+      }
+    }, 30000);
+  });
+});

package/src/services/update/update-service.ts

@@ -0,0 +1,193 @@
+/**
+ * UpdateService — manages wrangler version updates.
+ *
+ * Checks current wrangler version, compares against minimum, and updates
+ * via `bun update wrangler` when needed. Integrates with PrerequisitesService
+ * for version checking.
+ */
+
+import { PrerequisitesService } from "../prerequisites/index.js";
+import { theme } from "../../utils/theme.js";
+import { confirm } from "@clack/prompts";
+
+export interface UpdateResult {
+  updated: boolean;
+  previousVersion?: string;
+  newVersion?: string;
+  error?: string;
+}
+
+export class UpdateService {
+  private readonly prereqs: PrerequisitesService;
+  private readonly cwd: string;
+
+  constructor(cwd?: string, prereqs?: PrerequisitesService) {
+    this.prereqs = prereqs ?? new PrerequisitesService();
+    this.cwd = cwd ?? process.cwd();
+  }
+
+  /**
+   * Check if wrangler is outdated. If yes, prompt user (TTY) or
+   * auto-update (non-TTY / --yes flag). Never throws — errors are
+   * returned in UpdateResult.
+   */
+  async checkAndPromptUpdate(options?: {
+    yes?: boolean;
+  }): Promise<UpdateResult> {
+    try {
+      const versionCheck = await this.prereqs.checkWranglerVersion();
+
+      if (!versionCheck.outdated) {
+        process.stdout.write(
+          `  ${theme.success("✓")} Wrangler ${versionCheck.current} is up to date\n`
+        );
+        return { updated: false };
+      }
+
+      const current = versionCheck.current ?? "unknown";
+      const minimum = versionCheck.minimum ?? "unknown";
+
+      // Fetch latest available version for the prompt
+      const latest = await this.checkLatestVersion();
+
+      // Determine if we should prompt or auto-update
+      let shouldUpdate: boolean;
+      if (options?.yes ?? !process.stdout.isTTY) {
+        shouldUpdate = true;
+      } else {
+        shouldUpdate = await this.promptUpdate(current, minimum, latest);
+      }
+
+      if (!shouldUpdate) {
+        process.stdout.write(
+          `  ${theme.warning("!")} Skipping wrangler update (current: ${current})\n`
+        );
+        return { updated: false };
+      }
+
+      return await this.runUpdate();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stdout.write(
+        `  ${theme.error("!")} Wrangler update check failed: ${message}\n`
+      );
+      return { updated: false, error: message };
+    }
+  }
+
+  /**
+   * Force-update wrangler regardless of current version.
+   * Used by the standalone `hoox update` command.
+   */
+  async updateWrangler(): Promise<UpdateResult> {
+    process.stdout.write(`  ${theme.info("i")} Checking wrangler version...\n`);
+
+    const before = await this.prereqs.checkWranglerVersion();
+    const previousVersion = before.current;
+
+    if (!previousVersion) {
+      process.stdout.write(
+        `  ${theme.warning("!")} Wrangler is not installed. Install with: bun add -g wrangler\n`
+      );
+      return { updated: false, error: "Wrangler not installed" };
+    }
+
+    const result = await this.runUpdate(previousVersion);
+    return { ...result, previousVersion };
+  }
+
+  /**
+   * Check the latest available wrangler version from the npm registry.
+   * Uses the npm registry JSON API directly — no dependency on npm CLI.
+   * Returns null if the check fails (network error, etc.).
+   */
+  async checkLatestVersion(): Promise<string | null> {
+    try {
+      const res = await fetch("https://registry.npmjs.org/wrangler/latest");
+      if (!res.ok) return null;
+      const data = (await res.json()) as { version?: string };
+      return data.version ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  // ── Private helpers ──────────────────────────────────────────────
+
+  /**
+   * Prompt the user whether to update wrangler.
+   * Returns true if the user wants to update.
+   */
+  private async promptUpdate(
+    current: string,
+    minimum: string,
+    latest: string | null
+  ): Promise<boolean> {
+    const latestStr = latest ? `, latest: ${latest}` : "";
+    process.stdout.write(
+      `\n  ${theme.warning("!")} Wrangler ${current} is outdated (minimum: ${minimum}${latestStr})\n`
+    );
+
+    const result = await confirm({
+      message: "Update wrangler?",
+      initialValue: true,
+    });
+
+    // Confirm returns boolean | symbol (CLACK_CANCEL)
+    return result === true;
+  }
+
+  /**
+   * Run `bun update wrangler` in the project root and verify the result.
+   */
+  private async runUpdate(previousVersion?: string): Promise<UpdateResult> {
+    process.stdout.write(`  ${theme.info("i")} Updating wrangler...\n`);
+
+    try {
+      const proc = Bun.spawn(["bun", "update", "wrangler"], {
+        cwd: this.cwd,
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+
+      const stderr = await new Response(proc.stderr).text();
+      const exitCode = await proc.exited;
+
+      if (exitCode !== 0) {
+        const errorMsg = stderr.split("\n")[0] || "bun update wrangler failed";
+        process.stdout.write(
+          `  ${theme.error("!")} Update failed: ${errorMsg}\n`
+        );
+        return { updated: false, error: errorMsg };
+      }
+
+      // Verify the new version
+      const verify = await this.prereqs.checkWranglerVersion();
+      const newVersion = verify.current;
+
+      const versionChanged = previousVersion
+        ? previousVersion !== newVersion
+        : true;
+
+      if (versionChanged) {
+        process.stdout.write(
+          `  ${theme.success("✓")} Wrangler updated from ${previousVersion ?? "?"} to ${newVersion}\n`
+        );
+      } else {
+        process.stdout.write(
+          `  ${theme.warning("!")} Wrangler version unchanged (${newVersion})\n`
+        );
+      }
+
+      return {
+        updated: versionChanged,
+        previousVersion,
+        newVersion,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stdout.write(`  ${theme.error("!")} Update failed: ${message}\n`);
+      return { updated: false, error: message };
+    }
+  }
+}

package/src/ui/banner.ts

@@ -25,12 +25,12 @@ export function renderBanner(): string {
   const top = ` ${theme.corner.charAt(0)}${theme.separator.repeat(bannerWidth - 2)}${theme.corner.charAt(2)}`;
   const bottom = ` ${theme.corner.charAt(3)}${theme.separator.repeat(bannerWidth - 2)}${theme.corner.charAt(1)}`;
 
-  const lines = BANNER_LINES.map((line) =>
-    ` ${theme.heading(line)}`
-  );
+  const lines = BANNER_LINES.map((line) => ` ${theme.heading(line)}`);
 
   // Center the tagline
-  const taglineLeft = Math.floor((bannerWidth - TAGLINE.length - VERSION.length - 2) / 2);
+  const taglineLeft = Math.floor(
+    (bannerWidth - TAGLINE.length - VERSION.length - 2) / 2
+  );
   const tagline = ` ${" ".repeat(taglineLeft)}${theme.dim(TAGLINE)} ${theme.dim(VERSION)}`;
 
   const result = [
@@ -49,4 +49,4 @@ export function renderBanner(): string {
  */
 export function renderCompactBanner(): string {
   return `${theme.heading("Hoox CLI")} ${theme.dim(`${TAGLINE} ${VERSION}`)}`;
-}
+}

package/src/ui/menu.ts

@@ -422,6 +422,11 @@ async function showToolsMenu(
           label: "Dashboard UI",
           hint: "manage dashboard URLs",
         },
+        {
+          value: "tui",
+          label: "Launch TUI Dashboard",
+          hint: "OpenTUI terminal operations center",
+        },
         { value: "__back", label: "◀ Back to main menu" },
       ],
     });
@@ -470,4 +475,4 @@ async function runCommand(program: Command, commandStr: string): Promise<void> {
           : String(err);
     log.error(`Command failed: ${message}`);
   }
-}
+}

package/src/utils/formatters.ts

@@ -6,6 +6,7 @@
 
 import { CLIError, ExitCode } from "./errors.js";
 import { theme, icons, stripAnsi, hr } from "./theme.js";
+import { Command } from "commander";
 
 export interface FormatOptions {
   json?: boolean;
@@ -48,7 +49,10 @@ export function renderProgressBar(
  * Returns lines suitable for overwriting via \r or manual clear.
  */
 export function renderStepProgress(
-  steps: Array<{ name: string; status: "pending" | "running" | "done" | "failed" }>
+  steps: Array<{
+    name: string;
+    status: "pending" | "running" | "done" | "failed";
+  }>
 ): string {
   const iconMap: Record<string, string> = {
     pending: theme.dim("○"),
@@ -212,11 +216,15 @@ export function formatKeyValue(
     return;
   }
 
-  const maxKeyLen = Math.max(...Object.keys(pairs).map((k) => stripAnsi(k).length));
+  const maxKeyLen = Math.max(
+    ...Object.keys(pairs).map((k) => stripAnsi(k).length)
+  );
 
   for (const [key, value] of Object.entries(pairs)) {
     const paddedKey = key.padEnd(maxKeyLen);
-    process.stdout.write(`  ${theme.key(paddedKey)} ${theme.dim(":")} ${value}\n`);
+    process.stdout.write(
+      `  ${theme.key(paddedKey)} ${theme.dim(":")} ${value}\n`
+    );
   }
 }
 
@@ -249,4 +257,13 @@ export function formatList(
   for (const item of items) {
     process.stdout.write(`  ${icon} ${item}\n`);
   }
-}
+}
+
+/**
+ * Build the format options for output, reading global --json / --quiet flags.
+ * Uses `optsWithGlobals()` to include options inherited from the top-level program.
+ */
+export function getFormatOptions(cmd: Command): FormatOptions {
+  const opts = cmd.optsWithGlobals();
+  return { json: Boolean(opts.json), quiet: Boolean(opts.quiet) };
+}

package/src/utils/theme.ts

@@ -91,4 +91,4 @@ export function kv(key: string, value: string): string {
 /** Format a labeled value. */
 export function tagged(label: string, value: string): string {
   return `${theme.key(label)} ${theme.dim(":")} ${theme.value(value)}`;
-}
+}