@jango-blockchained/hoox-cli 0.3.4 → 0.3.5

package/src/services/kv/kv-sync-service.ts

@@ -25,7 +25,10 @@ export class KvSyncService {
 
       if (exitCode === 0) {
         try {
-          const namespaces = JSON.parse(stdout) as Array<{ id: string; title: string }>;
+          const namespaces = JSON.parse(stdout) as Array<{
+            id: string;
+            title: string;
+          }>;
           const configKv = namespaces.find((n) => n.title === "CONFIG_KV");
           if (configKv) return configKv.id;
         } catch {
@@ -37,23 +40,21 @@ export class KvSyncService {
     }
 
     throw new Error(
-      "Could not resolve CONFIG_KV namespace ID. Provide --namespace-id flag.",
+      "Could not resolve CONFIG_KV namespace ID. Provide --namespace-id flag."
     );
   }
 
-  async list(
-    namespaceId: string,
-  ): Promise<Array<{ name: string }>> {
+  async list(namespaceId: string): Promise<Array<{ name: string }>> {
     const proc = Bun.spawn(
       ["wrangler", "kv:key", "list", "--namespace-id", namespaceId],
-      { stdout: "pipe", stderr: "pipe" },
+      { stdout: "pipe", stderr: "pipe" }
     );
     const stdout = await new Response(proc.stdout).text();
     const exitCode = await proc.exited;
 
     if (exitCode !== 0) {
       throw new Error(
-        `Failed to list KV keys: ${stdout.trim() || `exit ${exitCode}`}`,
+        `Failed to list KV keys: ${stdout.trim() || `exit ${exitCode}`}`
       );
     }
 
@@ -71,7 +72,7 @@ export class KvSyncService {
   async get(namespaceId: string, key: string): Promise<string | null> {
     const proc = Bun.spawn(
       ["wrangler", "kv:key", "get", "--namespace-id", namespaceId, key],
-      { stdout: "pipe", stderr: "pipe" },
+      { stdout: "pipe", stderr: "pipe" }
     );
     const stdout = await new Response(proc.stdout).text();
     const stderr = await new Response(proc.stderr).text();
@@ -80,28 +81,24 @@ export class KvSyncService {
     if (exitCode !== 0) {
       if (stderr.includes("not found")) return null;
       throw new Error(
-        `Failed to get key "${key}": ${stderr.trim() || `exit ${exitCode}`}`,
+        `Failed to get key "${key}": ${stderr.trim() || `exit ${exitCode}`}`
       );
     }
 
     return stdout.trim() || null;
   }
 
-  async set(
-    namespaceId: string,
-    key: string,
-    value: string,
-  ): Promise<void> {
+  async set(namespaceId: string, key: string, value: string): Promise<void> {
     const proc = Bun.spawn(
       ["wrangler", "kv:key", "put", "--namespace-id", namespaceId, key, value],
-      { stdout: "pipe", stderr: "pipe" },
+      { stdout: "pipe", stderr: "pipe" }
     );
     const exitCode = await proc.exited;
     const stderr = await new Response(proc.stderr).text();
 
     if (exitCode !== 0) {
       throw new Error(
-        `Failed to set key "${key}": ${stderr.trim() || `exit ${exitCode}`}`,
+        `Failed to set key "${key}": ${stderr.trim() || `exit ${exitCode}`}`
       );
     }
   }
@@ -109,14 +106,14 @@ export class KvSyncService {
   async delete(namespaceId: string, key: string): Promise<void> {
     const proc = Bun.spawn(
       ["wrangler", "kv:key", "delete", "--namespace-id", namespaceId, key],
-      { stdout: "pipe", stderr: "pipe" },
+      { stdout: "pipe", stderr: "pipe" }
     );
     const exitCode = await proc.exited;
     const stderr = await new Response(proc.stderr).text();
 
     if (exitCode !== 0) {
       throw new Error(
-        `Failed to delete key "${key}": ${stderr.trim() || `exit ${exitCode}`}`,
+        `Failed to delete key "${key}": ${stderr.trim() || `exit ${exitCode}`}`
       );
     }
   }
@@ -125,22 +122,108 @@ export class KvSyncService {
     return {
       namespace: "CONFIG_KV",
       keys: [
-        { key: "webhook:tradingview:ip_check_enabled", type: "boolean", default: "false", description: "Enable TradingView IP allowlist check" },
-        { key: "webhook:allowed_ips", type: "string", default: "", description: "Comma-separated allowed IPs for webhook" },
-        { key: "routing:dynamic:enabled", type: "boolean", default: "false", description: "Enable dynamic routing" },
-        { key: "trade:max_daily_drawdown_percent", type: "number", default: "10", description: "Max daily loss percentage before halt" },
-        { key: "trade:kill_switch", type: "boolean", default: "false", description: "Emergency stop all trading" },
-        { key: "trade:watermark:{exchange}:{symbol}:{side}", type: "number", default: "", description: "Per-market watermark (template key)", secret: true },
-        { key: "agent:openai_key", type: "string", default: "", description: "OpenAI API key for AI agent", secret: true },
-        { key: "agent:anthropic_key", type: "string", default: "", description: "Anthropic API key for AI agent", secret: true },
-        { key: "agent:google_key", type: "string", default: "", description: "Google AI API key for agent", secret: true },
-        { key: "agent:azure_api_key", type: "string", default: "", description: "Azure OpenAI API key", secret: true },
-        { key: "agent:azure_endpoint", type: "string", default: "", description: "Azure OpenAI endpoint", secret: true },
-        { key: "email:scan_subject", type: "string", default: "", description: "Email subject filter for signal scanning" },
-        { key: "email:coin_pattern", type: "string", default: "", description: "Regex pattern to extract coin from email" },
-        { key: "email:action_pattern", type: "string", default: "", description: "Regex pattern to extract action from email" },
-        { key: "email:quantity_multiplier", type: "number", default: "1", description: "Multiplier for email signal quantity" },
-        { key: "email:use_imap", type: "boolean", default: "false", description: "Use IMAP for email scanning" },
+        {
+          key: "webhook:tradingview:ip_check_enabled",
+          type: "boolean",
+          default: "false",
+          description: "Enable TradingView IP allowlist check",
+        },
+        {
+          key: "webhook:allowed_ips",
+          type: "string",
+          default: "",
+          description: "Comma-separated allowed IPs for webhook",
+        },
+        {
+          key: "routing:dynamic:enabled",
+          type: "boolean",
+          default: "false",
+          description: "Enable dynamic routing",
+        },
+        {
+          key: "trade:max_daily_drawdown_percent",
+          type: "number",
+          default: "10",
+          description: "Max daily loss percentage before halt",
+        },
+        {
+          key: "trade:kill_switch",
+          type: "boolean",
+          default: "false",
+          description: "Emergency stop all trading",
+        },
+        {
+          key: "trade:watermark:{exchange}:{symbol}:{side}",
+          type: "number",
+          default: "",
+          description: "Per-market watermark (template key)",
+          secret: true,
+        },
+        {
+          key: "agent:openai_key",
+          type: "string",
+          default: "",
+          description: "OpenAI API key for AI agent",
+          secret: true,
+        },
+        {
+          key: "agent:anthropic_key",
+          type: "string",
+          default: "",
+          description: "Anthropic API key for AI agent",
+          secret: true,
+        },
+        {
+          key: "agent:google_key",
+          type: "string",
+          default: "",
+          description: "Google AI API key for agent",
+          secret: true,
+        },
+        {
+          key: "agent:azure_api_key",
+          type: "string",
+          default: "",
+          description: "Azure OpenAI API key",
+          secret: true,
+        },
+        {
+          key: "agent:azure_endpoint",
+          type: "string",
+          default: "",
+          description: "Azure OpenAI endpoint",
+          secret: true,
+        },
+        {
+          key: "email:scan_subject",
+          type: "string",
+          default: "",
+          description: "Email subject filter for signal scanning",
+        },
+        {
+          key: "email:coin_pattern",
+          type: "string",
+          default: "",
+          description: "Regex pattern to extract coin from email",
+        },
+        {
+          key: "email:action_pattern",
+          type: "string",
+          default: "",
+          description: "Regex pattern to extract action from email",
+        },
+        {
+          key: "email:quantity_multiplier",
+          type: "number",
+          default: "1",
+          description: "Multiplier for email signal quantity",
+        },
+        {
+          key: "email:use_imap",
+          type: "boolean",
+          default: "false",
+          description: "Use IMAP for email scanning",
+        },
       ],
     };
   }

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

@@ -100,14 +100,27 @@ export class PrerequisitesService {
   async checkBun(): Promise<PrerequisiteCheck> {
     const base = { name: "Bun", category: "tool" as const, required: ">=1.2" };
     try {
-      const proc = Bun.spawn(["bun", "--version"], { stdout: "pipe", stderr: "pipe" });
+      const proc = Bun.spawn(["bun", "--version"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
       const stdout = await new Response(proc.stdout).text();
       const version = stdout.trim();
       const [major, minor] = version.split(".").map(Number);
       const passed = (major ?? 0) >= 1 && (minor ?? 0) >= 2;
-      return { ...base, passed, version: version || "not found", hint: passed ? undefined : "Install: curl -fsSL https://bun.sh | bash" };
+      return {
+        ...base,
+        passed,
+        version: version || "not found",
+        hint: passed ? undefined : "Install: curl -fsSL https://bun.sh | bash",
+      };
     } catch {
-      return { ...base, passed: false, version: "not found", hint: "Install: curl -fsSL https://bun.sh | bash" };
+      return {
+        ...base,
+        passed: false,
+        version: "not found",
+        hint: "Install: curl -fsSL https://bun.sh | bash",
+      };
     }
   }
 
@@ -118,15 +131,28 @@ export class PrerequisitesService {
   async checkGit(): Promise<PrerequisiteCheck> {
     const base = { name: "Git", category: "tool" as const, required: ">=2.40" };
     try {
-      const proc = Bun.spawn(["git", "--version"], { stdout: "pipe", stderr: "pipe" });
+      const proc = Bun.spawn(["git", "--version"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
       const stdout = await new Response(proc.stdout).text();
       const match = stdout.match(/(\d+\.\d+)/);
       const version = match ? match[1] : "unknown";
       const [major, minor] = version.split(".").map(Number);
       const passed = (major ?? 0) >= 2 && (minor ?? 0) >= 40;
-      return { ...base, passed, version, hint: passed ? undefined : "Install: apt install git" };
+      return {
+        ...base,
+        passed,
+        version,
+        hint: passed ? undefined : "Install: apt install git",
+      };
     } catch {
-      return { ...base, passed: false, version: "not found", hint: "Install: apt install git" };
+      return {
+        ...base,
+        passed: false,
+        version: "not found",
+        hint: "Install: apt install git",
+      };
     }
   }
 
@@ -135,16 +161,33 @@ export class PrerequisitesService {
    * Runs `node --version` if available, skips gracefully if not installed.
    */
   async checkNode(): Promise<PrerequisiteCheck> {
-    const base = { name: "Node.js", category: "tool" as const, required: ">=18 (optional)" };
+    const base = {
+      name: "Node.js",
+      category: "tool" as const,
+      required: ">=18 (optional)",
+    };
     try {
-      const proc = Bun.spawn(["node", "--version"], { stdout: "pipe", stderr: "pipe" });
+      const proc = Bun.spawn(["node", "--version"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
       const stdout = await new Response(proc.stdout).text();
       const version = stdout.trim().replace(/^v/, "");
       const [major] = version.split(".").map(Number);
       const passed = (major ?? 0) >= 18;
-      return { ...base, passed, version: version || "not found", hint: passed ? undefined : "Install: nvm or https://nodejs.org" };
+      return {
+        ...base,
+        passed,
+        version: version || "not found",
+        hint: passed ? undefined : "Install: nvm or https://nodejs.org",
+      };
     } catch {
-      return { ...base, passed: true, version: "not installed", hint: "Optional — not required when using Bun" };
+      return {
+        ...base,
+        passed: true,
+        version: "not installed",
+        hint: "Optional — not required when using Bun",
+      };
     }
   }
 
@@ -153,16 +196,27 @@ export class PrerequisitesService {
    * Delegates to the existing method to avoid duplicating semver logic.
    */
   async checkWrangler(): Promise<PrerequisiteCheck> {
-    const base = { name: "Wrangler CLI", category: "tool" as const, required: `>=${this.MINIMUM_WRANGLER}` };
+    const base = {
+      name: "Wrangler CLI",
+      category: "tool" as const,
+      required: `>=${this.MINIMUM_WRANGLER}`,
+    };
     const result = await this.checkWranglerVersion();
     if (!result.current) {
-      return { ...base, passed: false, version: "not found", hint: "Install: bun add -g wrangler" };
+      return {
+        ...base,
+        passed: false,
+        version: "not found",
+        hint: "Install: bun add -g wrangler",
+      };
     }
     return {
       ...base,
       passed: !result.outdated,
       version: result.current,
-      hint: result.outdated ? `Update: bun add -g wrangler@latest (${result.current} < ${result.minimum})` : undefined,
+      hint: result.outdated
+        ? `Update: bun add -g wrangler@latest (${result.current} < ${result.minimum})`
+        : undefined,
     };
   }
 
@@ -171,9 +225,16 @@ export class PrerequisitesService {
    * Verifies the CLI is authenticated and extracts the user email.
    */
   async checkCloudflareAuth(): Promise<PrerequisiteCheck> {
-    const base = { name: "Cloudflare Auth", category: "account" as const, required: "wrangler whoami" };
+    const base = {
+      name: "Cloudflare Auth",
+      category: "account" as const,
+      required: "wrangler whoami",
+    };
     try {
-      const proc = Bun.spawn(["wrangler", "whoami"], { stdout: "pipe", stderr: "pipe" });
+      const proc = Bun.spawn(["wrangler", "whoami"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
       const stdout = await new Response(proc.stdout).text();
       const exitCode = await proc.exited;
       const passed = exitCode === 0 && !stdout.includes("not authenticated");
@@ -185,7 +246,12 @@ export class PrerequisitesService {
         hint: passed ? undefined : "Run: wrangler login",
       };
     } catch {
-      return { ...base, passed: false, version: "not authenticated", hint: "Run: wrangler login" };
+      return {
+        ...base,
+        passed: false,
+        version: "not authenticated",
+        hint: "Run: wrangler login",
+      };
     }
   }
 
@@ -194,23 +260,44 @@ export class PrerequisitesService {
    * Also checks `docker compose` availability separately.
    */
   async checkDocker(): Promise<PrerequisiteCheck> {
-    const base = { name: "Docker", category: "tool" as const, required: "optional" };
+    const base = {
+      name: "Docker",
+      category: "tool" as const,
+      required: "optional",
+    };
     try {
-      const proc = Bun.spawn(["docker", "--version"], { stdout: "pipe", stderr: "pipe" });
+      const proc = Bun.spawn(["docker", "--version"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
       const stdout = await new Response(proc.stdout).text();
-      const version = stdout.trim().replace(/^Docker version /, "").replace(/,.*$/, "");
+      const version = stdout
+        .trim()
+        .replace(/^Docker version /, "")
+        .replace(/,.*$/, "");
       let composeVersion = "";
       try {
-        const composeProc = Bun.spawn(["docker", "compose", "version"], { stdout: "pipe", stderr: "pipe" });
+        const composeProc = Bun.spawn(["docker", "compose", "version"], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
         composeVersion = (await new Response(composeProc.stdout).text()).trim();
-      } catch { /* compose optional */ }
+      } catch {
+        /* compose optional */
+      }
       return {
         ...base,
         passed: true,
-        version: version + (composeVersion ? ` (compose: yes)` : " (compose: no)"),
+        version:
+          version + (composeVersion ? ` (compose: yes)` : " (compose: no)"),
       };
     } catch {
-      return { ...base, passed: true, version: "not installed", hint: "Optional — used for Docker dev runtime" };
+      return {
+        ...base,
+        passed: true,
+        version: "not installed",
+        hint: "Optional — used for Docker dev runtime",
+      };
     }
   }
 
@@ -218,28 +305,49 @@ export class PrerequisitesService {
    * Check repository integrity: wrangler.jsonc exists, .env file present, submodules initialized.
    */
   async checkRepository(): Promise<PrerequisiteCheck> {
-    const base = { name: "Repository", category: "repository" as const, required: "valid" };
+    const base = {
+      name: "Repository",
+      category: "repository" as const,
+      required: "valid",
+    };
     try {
       const wranglerExists = await Bun.file("wrangler.jsonc").exists();
-      const envExists = await Bun.file(".env.local").exists() || await Bun.file(".env.example").exists();
+      const envExists =
+        (await Bun.file(".env.local").exists()) ||
+        (await Bun.file(".env.example").exists());
       const issues: string[] = [];
       if (!wranglerExists) issues.push("wrangler.jsonc not found");
       if (!envExists) issues.push("no .env.local or .env.example found");
       let submoduleOk = false;
       try {
-        const proc = Bun.spawn(["git", "submodule", "status"], { stdout: "pipe", stderr: "pipe" });
+        const proc = Bun.spawn(["git", "submodule", "status"], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
         const stdout = await new Response(proc.stdout).text();
         submoduleOk = !stdout.startsWith("-");
-      } catch { /* not a git repo */ }
+      } catch {
+        /* not a git repo */
+      }
       const passed = wranglerExists && issues.length === 0;
       return {
         ...base,
         passed,
-        version: issues.length > 0 ? issues.join("; ") : (submoduleOk ? "OK" : "submodules may need init"),
+        version:
+          issues.length > 0
+            ? issues.join("; ")
+            : submoduleOk
+              ? "OK"
+              : "submodules may need init",
         hint: passed ? undefined : "Run: hoox init or hoox clone --all",
       };
     } catch {
-      return { ...base, passed: false, version: "check failed", hint: "Check repository structure" };
+      return {
+        ...base,
+        passed: false,
+        version: "check failed",
+        hint: "Check repository structure",
+      };
     }
   }
 

package/src/services/secrets/index.ts

@@ -4,7 +4,6 @@ export {
 } from "./secrets-service.js";
 export type {
   Result,
-  WranglerResult,
   SecretStatus,
   SecretCheckResult,
   WorkerSecretConfig,

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

@@ -2,12 +2,31 @@ import { describe, it, expect, mock } from "bun:test";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { Result } from "./types.js";
 import { SecretsService } from "./secrets-service.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Narrow a discriminated union Result<T> after checking ok.
+ * Calling expect(result.ok).toBe(true) does not narrow the type,
+ * so we use this to unwrap the value after asserting ok.
+ */
+function expectOk<T>(result: Result<T>): T {
+  expect(result.ok).toBe(true);
+  return (result as { ok: true; value: T }).value;
+}
+
+/**
+ * Assert a Result<T> is an error and return the error message.
+ */
+function expectErr<T>(result: Result<T>): string {
+  expect(result.ok).toBe(false);
+  return (result as { ok: false; error: string }).error;
+}
+
 const WORKERS_JSONC = JSON.stringify({
   global: {},
   workers: {
@@ -256,8 +275,7 @@ describe("SecretsService", () => {
         (svc as any).config.workers["telegram-worker"].path = dir;
 
         const result = await svc.generateDevVars("telegram-worker");
-        expect(result.success).toBe(true);
-        expect(result.data).toBe(join(dir, ".dev.vars"));
+        expect(expectOk(result)).toBe(join(dir, ".dev.vars"));
 
         // Verify file content
         const content = await Bun.file(join(dir, ".dev.vars")).text();
@@ -277,8 +295,7 @@ describe("SecretsService", () => {
         (svc as any).config.workers["no-secrets-worker"].path = dir;
 
         const result = await svc.generateDevVars("no-secrets-worker");
-        expect(result.success).toBe(true);
-        expect(result.data).toBe(join(dir, ".dev.vars"));
+        expect(expectOk(result)).toBe(join(dir, ".dev.vars"));
 
         const content = await Bun.file(join(dir, ".dev.vars")).text();
         expect(content).toBe("");
@@ -290,8 +307,7 @@ describe("SecretsService", () => {
     it("returns error for unknown worker", async () => {
       const svc = await createService();
       const result = await svc.generateDevVars("unknown-worker");
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found in config");
+      expect(expectErr(result)).toContain("not found in config");
     });
 
     it("overwrites existing .dev.vars", async () => {
@@ -341,8 +357,7 @@ describe("SecretsService", () => {
         );
 
         const result = await svc.syncToCloudflare("telegram-worker");
-        expect(result.success).toBe(true);
-        expect(result.data).toEqual(["TELEGRAM_BOT_TOKEN"]);
+        expect(expectOk(result)).toEqual(["TELEGRAM_BOT_TOKEN"]);
         expect(called).toEqual([["TELEGRAM_BOT_TOKEN", "my-real-token"]]);
       } finally {
         rmSync(dir, { recursive: true, force: true });
@@ -370,11 +385,10 @@ describe("SecretsService", () => {
         );
 
         const result = await svc.syncToCloudflare("trade-worker");
-        // Only BINANCE_API_KEY was synced
-        expect(result.success).toBe(false); // partial success = false
-        expect(result.data).toEqual(["BINANCE_API_KEY"]);
-        expect(result.error).toContain("API_SERVICE_KEY");
-        expect(result.error).toContain("BINANCE_API_SECRET");
+        const errMsg = expectErr(result);
+        // Only BINANCE_API_KEY was synced — but errors exist, so overall result is error
+        expect(errMsg).toContain("API_SERVICE_KEY");
+        expect(errMsg).toContain("BINANCE_API_SECRET");
         expect(called).toEqual([["BINANCE_API_KEY", "real-binance-key"]]);
       } finally {
         rmSync(dir, { recursive: true, force: true });
@@ -397,11 +411,10 @@ describe("SecretsService", () => {
         );
 
         const result = await svc.syncToCloudflare("trade-worker");
-        expect(result.success).toBe(false);
-        expect(result.data).toBeUndefined();
-        expect(result.error).toContain("API_SERVICE_KEY");
-        expect(result.error).toContain("BINANCE_API_KEY");
-        expect(result.error).toContain("BINANCE_API_SECRET");
+        const errMsg = expectErr(result);
+        expect(errMsg).toContain("API_SERVICE_KEY");
+        expect(errMsg).toContain("BINANCE_API_KEY");
+        expect(errMsg).toContain("BINANCE_API_SECRET");
         expect(called).toHaveLength(0);
       } finally {
         rmSync(dir, { recursive: true, force: true });
@@ -411,8 +424,7 @@ describe("SecretsService", () => {
     it("returns error for unknown worker", async () => {
       const svc = await createService();
       const result = await svc.syncToCloudflare("unknown-worker");
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found in config");
+      expect(expectErr(result)).toContain("not found in config");
     });
 
     it("handles wrangler failures gracefully", async () => {
@@ -431,9 +443,7 @@ describe("SecretsService", () => {
         });
 
         const result = await svc.syncToCloudflare("telegram-worker");
-        expect(result.success).toBe(false);
-        expect(result.data).toBeUndefined();
-        expect(result.error).toContain("wrangler command failed");
+        expect(expectErr(result)).toContain("wrangler command failed");
       } finally {
         rmSync(dir, { recursive: true, force: true });
       }
@@ -447,8 +457,7 @@ describe("SecretsService", () => {
         (svc as any).config.workers["no-secrets-worker"].path = dir;
 
         const result = await svc.syncToCloudflare("no-secrets-worker");
-        expect(result.success).toBe(true);
-        expect(result.data).toEqual([]);
+        expect(expectOk(result)).toEqual([]);
       } finally {
         rmSync(dir, { recursive: true, force: true });
       }