@jango-blockchained/hoox-cli 0.5.2 → 0.5.7

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

@@ -1,372 +0,0 @@
-export interface EnvVarDefinition {
-  name: string;
-  required: boolean;
-  secret: boolean;
-  section: string;
-  default?: string;
-  hint?: string;
-}
-
-/** A .env file with its path and parsed variables. */
-export interface EnvFile {
-  path: string;
-  vars: Record<string, string>;
-}
-
-export interface EnvValidationResult {
-  missing: string[];
-  warnings: string[];
-}
-
-export class EnvService {
-  static getDefinitions(): EnvVarDefinition[] {
-    return [
-      {
-        name: "CLOUDFLARE_API_TOKEN",
-        required: true,
-        secret: true,
-        section: "Cloudflare Account",
-        hint: "API token with Workers/KV/D1/R2 permissions",
-      },
-      {
-        name: "CLOUDFLARE_ACCOUNT_ID",
-        required: true,
-        secret: false,
-        section: "Cloudflare Account",
-        hint: "From Cloudflare dashboard URL",
-      },
-      {
-        name: "CLOUDFLARE_SECRET_STORE_ID",
-        required: false,
-        secret: false,
-        section: "Cloudflare Account",
-        default: "",
-        hint: "Optional",
-      },
-      {
-        name: "SUBDOMAIN_PREFIX",
-        required: true,
-        secret: false,
-        section: "Cloudflare Account",
-        default: "cryptolinx",
-        hint: "Prefix for worker URLs",
-      },
-      {
-        name: "INTERNAL_KEY_BINDING",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Internal key for D1 worker auth",
-      },
-      {
-        name: "TRADE_INTERNAL_KEY",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Internal key for trade worker auth",
-      },
-      {
-        name: "AGENT_INTERNAL_KEY",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Internal key for agent worker auth",
-      },
-      {
-        name: "WEBHOOK_API_KEY_BINDING",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Webhook auth key for hoox gateway",
-      },
-      {
-        name: "INTERNAL_KEY_BINDING",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Shared internal auth key for inter-worker communication",
-      },
-      {
-        name: "API_SERVICE_KEY_BINDING",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "API service key for trade-worker",
-      },
-      {
-        name: "TELEGRAM_INTERNAL_KEY",
-        required: true,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Internal key for telegram worker auth",
-      },
-      {
-        name: "HA_TOKEN_BINDING",
-        required: false,
-        secret: true,
-        section: "Internal Auth",
-        hint: "Home Assistant token for hoox",
-      },
-      {
-        name: "TG_BOT_TOKEN_BINDING",
-        required: false,
-        secret: true,
-        section: "Telegram",
-        hint: "From @BotFather",
-      },
-      {
-        name: "TELEGRAM_SECRET_TOKEN",
-        required: false,
-        secret: true,
-        section: "Telegram",
-        hint: "Telegram webhook secret token",
-      },
-      // AI provider keys consolidated into AGENT_INTERNAL_KEY (above)
-      {
-        name: "BINANCE_KEY_BINDING",
-        required: false,
-        secret: true,
-        section: "Exchanges",
-        hint: "Binance API key",
-      },
-      {
-        name: "BINANCE_SECRET_BINDING",
-        required: false,
-        secret: true,
-        section: "Exchanges",
-        hint: "Binance API secret",
-      },
-      {
-        name: "MEXC_KEY_BINDING",
-        required: false,
-        secret: true,
-        section: "Exchanges",
-        hint: "MEXC API key",
-      },
-      {
-        name: "MEXC_SECRET_BINDING",
-        required: false,
-        secret: true,
-        section: "Exchanges",
-        hint: "MEXC API secret",
-      },
-      {
-        name: "BYBIT_KEY_BINDING",
-        required: false,
-        secret: true,
-        section: "Exchanges",
-        hint: "Bybit API key",
-      },
-      {
-        name: "BYBIT_SECRET_BINDING",
-        required: false,
-        secret: true,
-        section: "Exchanges",
-        hint: "Bybit API secret",
-      },
-      // Email
-      {
-        name: "EMAIL_HOST_BINDING",
-        required: false,
-        secret: true,
-        section: "Email",
-        hint: "Email IMAP server host",
-      },
-      {
-        name: "EMAIL_USER_BINDING",
-        required: false,
-        secret: true,
-        section: "Email",
-        hint: "Email IMAP username",
-      },
-      {
-        name: "EMAIL_PASS_BINDING",
-        required: false,
-        secret: true,
-        section: "Email",
-        hint: "Email IMAP password",
-      },
-      // INTERNAL_KEY_BINDING consolidated into INTERNAL_KEY_BINDING (above)
-      // Wallet
-      {
-        name: "WALLET_MNEMONIC_SECRET",
-        required: false,
-        secret: true,
-        section: "Wallet",
-        hint: "Wallet mnemonic phrase for web3-wallet-worker",
-      },
-      {
-        name: "WALLET_PK_SECRET",
-        required: false,
-        secret: true,
-        section: "Wallet",
-        hint: "Wallet private key for web3-wallet-worker",
-      },
-      {
-        name: "DASHBOARD_USER",
-        required: true,
-        secret: false,
-        section: "Dashboard",
-        default: "admin",
-        hint: "Dashboard login username",
-      },
-      {
-        name: "DASHBOARD_PASS",
-        required: true,
-        secret: true,
-        section: "Dashboard",
-        hint: "Dashboard login password",
-      },
-      {
-        name: "SESSION_SECRET",
-        required: true,
-        secret: true,
-        section: "Dashboard",
-        hint: "32+ char random string for session signing",
-      },
-    ];
-  }
-
-  static getSections(): string[] {
-    return [...new Set(EnvService.getDefinitions().map((d) => d.section))];
-  }
-
-  static async loadDotEnvAsync(
-    filePath: string
-  ): Promise<Record<string, string>> {
-    const file = Bun.file(filePath);
-    if (!(await file.exists())) return {};
-    const text = await file.text();
-    const vars: Record<string, string> = {};
-    for (const line of text.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();
-      let value = trimmed.substring(eqIdx + 1).trim();
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1);
-      }
-      vars[key] = value;
-    }
-    return vars;
-  }
-
-  static validate(vars: Record<string, string>): EnvValidationResult {
-    const missing: string[] = [];
-    const warnings: string[] = [];
-    for (const def of EnvService.getDefinitions()) {
-      if (def.required) {
-        const val = vars[def.name];
-        if (!val || val.startsWith("your_") || val.startsWith("generate_")) {
-          missing.push(def.name);
-        }
-      }
-    }
-    if (vars.SESSION_SECRET && vars.SESSION_SECRET.length < 32) {
-      warnings.push("SESSION_SECRET should be at least 32 characters");
-    }
-    return { missing, warnings };
-  }
-
-  static generateEnvLocal(vars?: Record<string, string>): string {
-    const v = vars ?? {};
-    const defs = EnvService.getDefinitions();
-    const sections = EnvService.getSections();
-    let output =
-      "# Hoox Local Environment Configuration\n# Generated by `hoox config env init`.\n# NEVER commit this file.\n\n";
-    for (const section of sections) {
-      output += `# --- ${section.toUpperCase()} ---\n`;
-      for (const def of defs.filter((d) => d.section === section)) {
-        const val =
-          v[def.name] !== undefined
-            ? v[def.name]
-            : (def.default ?? `your_${def.name.toLowerCase()}`);
-        output += `${def.name}="${val}"\n`;
-      }
-      output += "\n";
-    }
-    return output;
-  }
-
-  static getWorkerDevVars(
-    vars: Record<string, string>
-  ): Record<string, Record<string, string>> {
-    const workerMap: Record<string, string[]> = {
-      "workers/hoox": [
-        "WEBHOOK_API_KEY_BINDING",
-        "INTERNAL_KEY_BINDING",
-        "HA_TOKEN_BINDING",
-      ],
-      "workers/trade-worker": [
-        "API_SERVICE_KEY_BINDING",
-        "INTERNAL_KEY_BINDING",
-        "BINANCE_KEY_BINDING",
-        "BINANCE_SECRET_BINDING",
-        "MEXC_KEY_BINDING",
-        "MEXC_SECRET_BINDING",
-        "BYBIT_KEY_BINDING",
-        "BYBIT_SECRET_BINDING",
-      ],
-      "workers/agent-worker": ["AGENT_INTERNAL_KEY"],
-      "workers/d1-worker": ["INTERNAL_KEY_BINDING"],
-      "workers/telegram-worker": [
-        "TG_BOT_TOKEN_BINDING",
-        "TELEGRAM_SECRET_TOKEN",
-      ],
-      "workers/web3-wallet-worker": [
-        "WALLET_MNEMONIC_SECRET",
-        "WALLET_PK_SECRET",
-      ],
-      "workers/email-worker": [
-        "EMAIL_HOST_BINDING",
-        "EMAIL_USER_BINDING",
-        "EMAIL_PASS_BINDING",
-        "INTERNAL_KEY_BINDING",
-      ],
-      "workers/analytics-worker": ["CLOUDFLARE_API_TOKEN"],
-      "workers/dashboard": [
-        "DASHBOARD_USER",
-        "DASHBOARD_PASS",
-        "SESSION_SECRET",
-        "INTERNAL_KEY_BINDING",
-        "AGENT_INTERNAL_KEY",
-        "TRADE_INTERNAL_KEY",
-        "TELEGRAM_INTERNAL_KEY",
-        "API_SERVICE_KEY_BINDING",
-      ],
-    };
-    const result: Record<string, Record<string, string>> = {};
-    for (const [workerPath, varNames] of Object.entries(workerMap)) {
-      const workerVars: Record<string, string> = {};
-      for (const name of varNames) {
-        if (vars[name] !== undefined && vars[name] !== "") {
-          workerVars[name] = vars[name];
-        }
-      }
-      if (Object.keys(workerVars).length > 0) result[workerPath] = workerVars;
-    }
-    return result;
-  }
-
-  static show(vars: Record<string, string>): string {
-    const defs = EnvService.getDefinitions();
-    const sections = EnvService.getSections();
-    let output = "";
-    for (const section of sections) {
-      output += `\n${section}:\n`;
-      for (const def of defs.filter((d) => d.section === section)) {
-        const val = vars[def.name];
-        const displayVal =
-          def.secret && val ? "********" : (val ?? "(not set)");
-        const status = val ? " [set]" : " [missing]";
-        output += `  ${def.name}=${displayVal}${def.secret ? " (secret)" : ""}${status}\n`;
-      }
-    }
-    return output;
-  }
-}

package/src/services/env/index.ts

@@ -1 +0,0 @@
-export { EnvService } from "./env-service.js";

package/src/services/kv/index.ts

@@ -1 +0,0 @@
-export { KvSyncService } from "./kv-sync-service.js";

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

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { KvSyncService } from "./kv-sync-service.js";
-
-describe("KvSyncService", () => {
-  describe("getManifest", () => {
-    it("returns manifest with CONFIG_KV namespace", () => {
-      const manifest = KvSyncService.getManifest();
-      expect(manifest.namespace).toBe("CONFIG_KV");
-      expect(manifest.keys.length).toBeGreaterThan(10);
-    });
-
-    it("each key has required fields", () => {
-      for (const key of KvSyncService.getManifestKeys()) {
-        expect(key.key).toBeTruthy();
-        expect(["boolean", "number", "string"]).toContain(key.type);
-        expect(key.description).toBeTruthy();
-        expect(typeof key.default).toBe("string");
-      }
-    });
-
-    it("includes known critical keys", () => {
-      const keys = KvSyncService.getManifestKeys().map((k) => k.key);
-      expect(keys).toContain("trade:kill_switch");
-      expect(keys).toContain("trade:max_daily_drawdown_percent");
-      expect(keys).toContain("agent:openai_key");
-      expect(keys).toContain("email:use_imap");
-    });
-
-    it("returns exactly 16 manifest keys", () => {
-      expect(KvSyncService.getManifestKeys().length).toBe(16);
-    });
-
-    it("has no duplicates", () => {
-      const keys = KvSyncService.getManifestKeys().map((k) => k.key);
-      expect(new Set(keys).size).toBe(keys.length);
-    });
-  });
-});

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

@@ -1,243 +0,0 @@
-export interface KvManifestKey {
-  key: string;
-  type: "boolean" | "number" | "string";
-  default: string;
-  description: string;
-  secret?: boolean;
-}
-
-export interface KvManifest {
-  namespace: string;
-  keys: KvManifestKey[];
-}
-
-export class KvSyncService {
-  async resolveNamespaceId(namespaceId?: string): Promise<string> {
-    if (namespaceId) return namespaceId;
-
-    try {
-      const proc = Bun.spawn(["wrangler", "kv", "namespace", "list"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const stdout = await new Response(proc.stdout).text();
-      const exitCode = await proc.exited;
-
-      if (exitCode === 0) {
-        try {
-          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 {
-          // Not JSON — skip
-        }
-      }
-    } catch {
-      // wrangler not available
-    }
-
-    throw new Error(
-      "Could not resolve CONFIG_KV namespace ID. Provide --namespace-id flag."
-    );
-  }
-
-  async list(namespaceId: string): Promise<Array<{ name: string }>> {
-    const proc = Bun.spawn(
-      ["wrangler", "kv", "key", "list", "--namespace-id", namespaceId],
-      { 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}`}`
-      );
-    }
-
-    try {
-      const parsed = JSON.parse(stdout) as Array<{ name: string }>;
-      return parsed;
-    } catch {
-      return stdout
-        .split("\n")
-        .filter(Boolean)
-        .map((name) => ({ name: name.trim() }));
-    }
-  }
-
-  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" }
-    );
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-
-    if (exitCode !== 0) {
-      if (stderr.includes("not found")) return null;
-      throw new Error(
-        `Failed to get key "${key}": ${stderr.trim() || `exit ${exitCode}`}`
-      );
-    }
-
-    return stdout.trim() || null;
-  }
-
-  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" }
-    );
-    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}`}`
-      );
-    }
-  }
-
-  async delete(namespaceId: string, key: string): Promise<void> {
-    const proc = Bun.spawn(
-      ["wrangler", "kv", "key", "delete", "--namespace-id", namespaceId, key],
-      { 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}`}`
-      );
-    }
-  }
-
-  static getManifest(): KvManifest {
-    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",
-        },
-      ],
-    };
-  }
-
-  static getManifestKeys(): KvManifestKey[] {
-    return KvSyncService.getManifest().keys;
-  }
-}

package/src/services/prerequisites/index.ts

@@ -1 +0,0 @@
-export { PrerequisitesService } from "./prerequisites-service.js";