@jango-blockchained/hoox-cli 0.5.1 → 0.5.6

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

@@ -1,287 +0,0 @@
-import { parse as parseJsonc } from "jsonc-parser";
-import type {
-  Result,
-  SecretCheckResult,
-  SecretStatus,
-  WorkersJsonc,
-} from "./types.js";
-
-/**
- * Manages Cloudflare Worker secrets defined in `wrangler.jsonc`.
- *
- * Reads worker-level `secrets` arrays, checks local `.dev.vars` files,
- * syncs secrets to Cloudflare via `wrangler secret put`, and generates
- * `.dev.vars` templates.
- *
- * Use the static `create()` factory to instantiate — the constructor
- * is private so the config is parsed once and the sync methods remain
- * synchronous.
- *
- * @example
- * ```ts
- * const svc = await SecretsService.create("wrangler.jsonc");
- * const names = svc.listSecrets("trade-worker");
- * const check = await svc.checkLocalSecrets("trade-worker");
- * ```
- */
-export class SecretsService {
-  private config: WorkersJsonc;
-  private configPath: string;
-
-  // -----------------------------------------------------------------------
-  // Construction
-  // -----------------------------------------------------------------------
-
-  /** Use {@link create} instead — private so config is always loaded. */
-  private constructor(config: WorkersJsonc, configPath: string) {
-    this.config = config;
-    this.configPath = configPath;
-  }
-
-  /**
-   * Factory that reads and parses the wrangler.jsonc config file.
-   * Throws if the file doesn't exist or can't be parsed.
-   */
-  static async create(configPath?: string): Promise<SecretsService> {
-    const path = configPath ?? "wrangler.jsonc";
-    const file = Bun.file(path);
-    if (!(await file.exists())) {
-      throw new Error(`Config file not found: ${path}`);
-    }
-    const text = await file.text();
-    const config = parseJsonc(text) as WorkersJsonc;
-    return new SecretsService(config, path);
-  }
-
-  // -----------------------------------------------------------------------
-  // Public API
-  // -----------------------------------------------------------------------
-
-  /**
-   * Returns secret names declared for a worker in `wrangler.jsonc`.
-   * Synchronous because the config was loaded during construction.
-   */
-  listSecrets(workerName: string): string[] {
-    const worker = this.config.workers[workerName];
-    return worker?.secrets ?? [];
-  }
-
-  /**
-   * Returns a map of every worker → its declared secret names.
-   * Workers that declare no secrets are omitted from the result.
-   */
-  listAllSecrets(): Record<string, string[]> {
-    const result: Record<string, string[]> = {};
-    for (const [name, worker] of Object.entries(this.config.workers)) {
-      if (worker.secrets && worker.secrets.length > 0) {
-        result[name] = worker.secrets;
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Checks a worker's local `.dev.vars` file and reports which secrets
-   * are set (with real, non-placeholder values) and which are missing.
-   */
-  async checkLocalSecrets(workerName: string): Promise<SecretCheckResult> {
-    const worker = this.config.workers[workerName];
-    if (!worker) {
-      return {
-        worker: workerName,
-        secrets: [],
-        allSet: false,
-        missing: [],
-      };
-    }
-
-    const requiredSecrets = worker.secrets ?? [];
-    const devVarsPath = `${worker.path}/.dev.vars`;
-    const file = Bun.file(devVarsPath);
-
-    if (!(await file.exists())) {
-      return {
-        worker: workerName,
-        secrets: requiredSecrets.map((s) => ({ name: s, set: false })),
-        allSet: requiredSecrets.length === 0,
-        missing: [...requiredSecrets],
-      };
-    }
-
-    const content = await file.text();
-    const secretMap = this.parseDotEnv(content);
-
-    const secrets: SecretStatus[] = [];
-    const missing: string[] = [];
-
-    for (const name of requiredSecrets) {
-      const value = secretMap.get(name);
-      if (value !== undefined && !this.isPlaceholder(value)) {
-        secrets.push({ name, set: true, source: devVarsPath });
-      } else {
-        secrets.push({
-          name,
-          set: false,
-          source: value !== undefined ? devVarsPath : undefined,
-        });
-        missing.push(name);
-      }
-    }
-
-    return {
-      worker: workerName,
-      secrets,
-      allSet: missing.length === 0,
-      missing,
-    };
-  }
-
-  /**
-   * 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<Result<string>> {
-    const worker = this.config.workers[workerName];
-    if (!worker) {
-      return {
-        ok: false,
-        error: `Worker "${workerName}" not found in config`,
-      };
-    }
-
-    const secrets = worker.secrets ?? [];
-    const content =
-      secrets.length > 0
-        ? secrets.map((s) => `${s}=placeholder_${s.toLowerCase()}`).join("\n") +
-          "\n"
-        : "";
-    const devVarsPath = `${worker.path}/.dev.vars`;
-
-    try {
-      await Bun.write(devVarsPath, content);
-      return { ok: true, value: devVarsPath };
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: `Failed to write .dev.vars: ${message}` };
-    }
-  }
-
-  /**
-   * Syncs a worker's secrets to Cloudflare via `wrangler secret put`.
-   *
-   * For each required secret the service first looks for a real value in
-   * the worker's `.dev.vars` file.  Secrets with placeholder values are
-   * skipped and reported as errors.
-   */
-  async syncToCloudflare(workerName: string): Promise<Result<string[]>> {
-    const worker = this.config.workers[workerName];
-    if (!worker) {
-      return {
-        ok: false,
-        error: `Worker "${workerName}" not found in config`,
-      };
-    }
-
-    const secrets = worker.secrets ?? [];
-    const synced: string[] = [];
-    const errors: string[] = [];
-
-    // Pre-load existing .dev.vars to avoid prompting in a service.
-    const devVarsPath = `${worker.path}/.dev.vars`;
-    const devVarsFile = Bun.file(devVarsPath);
-    let existingValues: Map<string, string> = new Map();
-
-    if (await devVarsFile.exists()) {
-      const content = await devVarsFile.text();
-      existingValues = this.parseDotEnv(content);
-    }
-
-    for (const secret of secrets) {
-      try {
-        const value = existingValues.get(secret);
-        if (value !== undefined && !this.isPlaceholder(value)) {
-          await this.execWranglerSecretPut(worker.path, secret, value);
-          synced.push(secret);
-        } else {
-          errors.push(
-            `Secret "${secret}": no valid value in .dev.vars (run generateDevVars then edit)`
-          );
-        }
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        errors.push(`Secret "${secret}": ${message}`);
-      }
-    }
-
-    if (errors.length > 0) {
-      return { ok: false, error: errors.join("; ") };
-    }
-
-    return { ok: true, value: synced };
-  }
-
-  // -----------------------------------------------------------------------
-  // Private helpers
-  // -----------------------------------------------------------------------
-
-  /**
-   * Parses a `.env` / `.dev.vars` style file into a `Map<key, value>`.
-   * Skips empty lines and comments (lines starting with `#`).
-   */
-  private parseDotEnv(content: string): Map<string, string> {
-    const map = new Map<string, string>();
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (trimmed === "" || trimmed.startsWith("#")) continue;
-
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx < 1) continue;
-
-      const key = trimmed.substring(0, eqIdx).trim();
-      const value = trimmed.substring(eqIdx + 1).trim();
-      map.set(key, value);
-    }
-    return map;
-  }
-
-  /** Returns `true` when a value looks like an unfilled template. */
-  private isPlaceholder(value: string): boolean {
-    return (
-      value.startsWith("placeholder_") ||
-      value.startsWith("your_") ||
-      value.startsWith("generate_") ||
-      value === ""
-    );
-  }
-
-  /**
-   * Runs `wrangler secret put <name>` inside the worker's directory.
-   * Marked `protected` so unit tests can stub it without touching the
-   * real `Bun.spawn`.
-   */
-  protected async execWranglerSecretPut(
-    workerPath: string,
-    name: string,
-    value: string
-  ): Promise<void> {
-    const proc = Bun.spawn(["wrangler", "secret", "put", name], {
-      cwd: workerPath,
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    proc.stdin.write(value + "\n");
-    proc.stdin.end();
-
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      const stderrText = await new Response(proc.stderr).text();
-      throw new Error(
-        `wrangler exited with code ${exitCode}: ${stderrText.trim()}`
-      );
-    }
-  }
-}
-
-export default SecretsService;

package/src/services/secrets/types.ts

@@ -1,50 +0,0 @@
-/**
- * SecretsService types — secret management for Cloudflare Workers.
- */
-
-// ---------------------------------------------------------------------------
-// Result
-// ---------------------------------------------------------------------------
-
-import type { Result } from "@jango-blockchained/hoox-shared";
-
-// Re-export the shared Result<T> for convenience
-export type { Result };
-
-// ---------------------------------------------------------------------------
-// Domain types
-// ---------------------------------------------------------------------------
-
-export interface SecretStatus {
-  /** Name of the secret (e.g. "TELEGRAM_BOT_TOKEN"). */
-  name: string;
-  /** Whether the secret has a real (non-placeholder) value set. */
-  set: boolean;
-  /** Where the value was found ("workers/<name>/.dev.vars" or undefined). */
-  source?: string;
-}
-
-export interface SecretCheckResult {
-  /** Worker name as it appears in wrangler.jsonc. */
-  worker: string;
-  /** Per-secret status entries. */
-  secrets: SecretStatus[];
-  /** True when *every* required secret is present with a real value. */
-  allSet: boolean;
-  /** Secret names that are either missing or still placeholder. */
-  missing: string[];
-}
-
-// ---------------------------------------------------------------------------
-// Internal config shape (subset of wrangler.jsonc used by SecretsService)
-// ---------------------------------------------------------------------------
-
-export interface WorkerSecretConfig {
-  enabled: boolean;
-  path: string;
-  secrets?: string[];
-}
-
-export interface WorkersJsonc {
-  workers: Record<string, WorkerSecretConfig>;
-}

package/src/services/update/index.ts

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

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

@@ -1,76 +0,0 @@
-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

@@ -1,193 +0,0 @@
-/**
- * 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 };
-    }
-  }
-}