@jango-blockchained/hoox-cli 0.3.4

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

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "bun:test";
+import { DbService } from "./db-service.js";
+
+describe("DbService", () => {
+  describe("resolveDbName", () => {
+    it("uses explicit name when provided", async () => {
+      const svc = new DbService();
+      const name = await svc.resolveDbName("my-explicit-db");
+      expect(name).toBe("my-explicit-db");
+    });
+
+    it("falls back to default when no config exists", async () => {
+      const svc = new DbService();
+      const name = await svc.resolveDbName();
+      expect(name).toBe("my-database");
+    });
+  });
+
+  describe("parseTableNames", () => {
+    it("extracts table names from wrangler JSON output", () => {
+      const output = JSON.stringify([
+        {
+          results: [
+            { name: "trade_signals" },
+            { name: "trades" },
+            { name: "positions" },
+          ],
+        },
+      ]);
+      const tables = DbService.parseTableNames(output);
+      expect(tables).toContain("trade_signals");
+      expect(tables).toContain("trades");
+      expect(tables).toContain("positions");
+      expect(tables.length).toBe(3);
+    });
+
+    it("handles empty results", () => {
+      const output = JSON.stringify([{ results: [] }]);
+      const tables = DbService.parseTableNames(output);
+      expect(tables.length).toBe(0);
+    });
+
+    it("handles non-JSON output as text lines", () => {
+      const output = "table1\ntable2\ntable3\n";
+      const tables = DbService.parseTableNames(output);
+      expect(tables).toContain("table1");
+      expect(tables).toContain("table2");
+      expect(tables).toContain("table3");
+    });
+  });
+});

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

@@ -0,0 +1,140 @@
+import { ConfigService } from "../config/index.js";
+
+export interface QueryResult {
+  columns: string[];
+  rows: Record<string, unknown>[];
+}
+
+export class DbService {
+  private configService: ConfigService;
+
+  constructor(configService?: ConfigService) {
+    this.configService = configService ?? new ConfigService();
+  }
+
+  async resolveDbName(dbName?: string): Promise<string> {
+    if (dbName) return dbName;
+    try {
+      await this.configService.load();
+      const d1Worker = this.configService.getWorker("d1-worker");
+      const vars = d1Worker?.vars as Record<string, string> | undefined;
+      if (vars?.database_name) return vars.database_name;
+    } catch {
+      // Config not found — use default
+    }
+    return "my-database";
+  }
+
+  async apply(
+    dbName: string,
+    remote: boolean,
+    schemaPath?: string,
+  ): Promise<string> {
+    const path = schemaPath ?? "workers/trade-worker/schema.sql";
+    const args = ["d1", "execute", dbName, "--file", path];
+    if (remote) args.push("--remote");
+    return await this.runWrangler(args);
+  }
+
+  async migrate(dbName: string, remote: boolean): Promise<string> {
+    const migrationSql = await this.readMigrationSql();
+    const args = ["d1", "execute", dbName, "--command", migrationSql];
+    if (remote) args.push("--remote");
+    return await this.runWrangler(args);
+  }
+
+  async listTables(dbName: string, remote: boolean): Promise<string[]> {
+    const args = [
+      "d1",
+      "execute",
+      dbName,
+      "--command",
+      "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name",
+      "--json",
+    ];
+    if (remote) args.push("--remote");
+
+    const output = await this.runWrangler(args);
+    return DbService.parseTableNames(output);
+  }
+
+  async query(
+    dbName: string,
+    sql: string,
+    remote: boolean,
+  ): Promise<string> {
+    const args = ["d1", "execute", dbName, "--command", sql, "--json"];
+    if (remote) args.push("--remote");
+    return await this.runWrangler(args);
+  }
+
+  async export(
+    dbName: string,
+    outputPath?: string,
+  ): Promise<string> {
+    const outPath =
+      outputPath ?? `backup-${new Date().toISOString().slice(0, 10)}.sql`;
+    const args = ["d1", "export", dbName, "--output", outPath, "--remote"];
+    await this.runWrangler(args);
+    return outPath;
+  }
+
+  async reset(dbName: string): Promise<string> {
+    await this.runWrangler(["d1", "delete", dbName, "-y"]);
+    return await this.runWrangler(["d1", "create", dbName]);
+  }
+
+  static parseTableNames(output: string): string[] {
+    try {
+      const parsed = JSON.parse(output);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        const first = parsed[0];
+        if (first.results && Array.isArray(first.results)) {
+          return first.results.map(
+            (r: Record<string, unknown>) => String(r.name ?? ""),
+          ).filter(Boolean);
+        }
+      }
+    } catch {
+      // Not JSON — try text parse
+    }
+    return output
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean);
+  }
+
+  private async runWrangler(args: string[]): Promise<string> {
+    const proc = Bun.spawn(["wrangler", ...args], {
+      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) {
+      throw new Error(
+        stderr.trim() || `wrangler exited with code ${exitCode}`,
+      );
+    }
+
+    return stdout.trim();
+  }
+
+  private async readMigrationSql(): Promise<string> {
+    try {
+      const file = Bun.file("scripts/migrate-tracking.sh");
+      if (await file.exists()) {
+        const content = await file.text();
+        const match = content.match(
+          /d1\s+execute\s+\S+\s+--command=["'](.+?)["']/s,
+        );
+        if (match) return match[1];
+      }
+    } catch {
+      // Fall through
+    }
+    return "SELECT 1";
+  }
+}

package/src/services/db/index.ts

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

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

@@ -0,0 +1,155 @@
+/**
+ * DockerService wraps Docker Compose operations for local development.
+ *
+ * Provides availability checks, compose file detection, and compose up/down.
+ */
+
+interface DockerAvailability {
+  docker: boolean;
+  compose: boolean;
+}
+
+interface ComposeResult {
+  ok: boolean;
+  error?: string;
+}
+
+/**
+ * Resolved path to docker-compose.yml in the project root.
+ */
+const COMPOSE_FILE = "docker-compose.yml";
+
+export class DockerService {
+  private readonly cwd: string;
+
+  constructor(cwd?: string) {
+    this.cwd = cwd ?? process.cwd();
+  }
+
+  /**
+   * Check if Docker and docker-compose are available in PATH.
+   */
+  async checkAvailability(): Promise<DockerAvailability> {
+    const [dockerOk, composeOk] = await Promise.all([
+      this.isCommandAvailable("docker"),
+      this.isCommandAvailable("docker compose"),
+    ]);
+
+    return { docker: dockerOk, compose: composeOk };
+  }
+
+  /**
+   * Check if docker-compose.yml exists in the project root.
+   */
+  async composeFileExists(): Promise<boolean> {
+    const file = Bun.file(
+      this.cwd.endsWith("/")
+        ? `${this.cwd}${COMPOSE_FILE}`
+        : `${this.cwd}/${COMPOSE_FILE}`
+    );
+    return file.exists();
+  }
+
+  /**
+   * Run `docker compose up` for the given profiles.
+   *
+   * @param profiles  - Compose profiles to activate (e.g. ["workers", "dashboard"]).
+   * @param detached  - Run in detached mode (default false, inherits stdout/stderr).
+   * @returns ComposeResult with ok=true on success.
+   */
+  async composeUp(
+    profiles: string[],
+    detached = false
+  ): Promise<ComposeResult> {
+    const args = ["compose", "up", "--profile", ...profiles];
+
+    if (detached) {
+      args.push("-d");
+    }
+
+    try {
+      const proc = Bun.spawn(["docker", ...args], {
+        cwd: this.cwd,
+        stdout: detached ? "pipe" : "inherit",
+        stderr: "inherit",
+        stdin: "pipe",
+      });
+
+      if (!detached) {
+        // For non-detached, inherit stdout/stderr — user sees real-time output.
+        // Wait for the process to exit naturally (Ctrl+C or completion).
+        const exitCode = await proc.exited;
+
+        if (exitCode === 0) {
+          return { ok: true };
+        }
+        return {
+          ok: false,
+          error: `docker compose exited with code ${exitCode}`,
+        };
+      }
+
+      // Detached mode: capture output
+      const stdout = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+
+      if (exitCode === 0) {
+        return { ok: true };
+      }
+      return {
+        ok: false,
+        error: stdout.trim() || `docker compose exited with code ${exitCode}`,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: `Failed to run docker compose: ${message}` };
+    }
+  }
+
+  /**
+   * Run `docker compose down` to stop running containers.
+   */
+  async composeDown(): Promise<ComposeResult> {
+    try {
+      const proc = Bun.spawn(["docker", "compose", "down"], {
+        cwd: this.cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const stderr = await new Response(proc.stderr).text();
+      const exitCode = await proc.exited;
+
+      if (exitCode === 0) {
+        return { ok: true };
+      }
+      return {
+        ok: false,
+        error:
+          stderr.trim() || `docker compose down exited with code ${exitCode}`,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        error: `Failed to run docker compose down: ${message}`,
+      };
+    }
+  }
+
+  /**
+   * Probe PATH for a command's availability without throwing.
+   */
+  private isCommandAvailable(cmd: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const proc = Bun.spawn(["which", cmd.split(" ")[0]!], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      proc.exited
+        .then((code) => resolve(code === 0))
+        .catch(() => resolve(false));
+    });
+  }
+}

package/src/services/docker/index.ts

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

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

@@ -0,0 +1,210 @@
+import { describe, expect, it } from "bun:test";
+import { EnvService } from "./env-service.js";
+
+describe("EnvService", () => {
+  describe("getDefinitions", () => {
+    it("returns all known env var definitions", () => {
+      const defs = EnvService.getDefinitions();
+      expect(defs.length).toBe(31);
+      expect(defs.some(d => d.name === "CLOUDFLARE_API_TOKEN")).toBe(true);
+    });
+
+    it("each definition has required fields", () => {
+      for (const def of EnvService.getDefinitions()) {
+        expect(def.name).toBeTruthy();
+        expect(typeof def.required).toBe("boolean");
+        expect(typeof def.secret).toBe("boolean");
+        expect(def.section).toBeTruthy();
+      }
+    });
+  });
+
+  describe("getSections", () => {
+    it("returns unique sections in order", () => {
+      const sections = EnvService.getSections();
+      expect(sections.length).toBeGreaterThanOrEqual(7);
+      expect(sections[0]).toBe("Cloudflare Account");
+    });
+  });
+
+  describe("generateEnvLocal", () => {
+    it("generates template with all vars", () => {
+      const content = EnvService.generateEnvLocal();
+      expect(content).toContain("CLOUDFLARE_API_TOKEN");
+      expect(content).toContain("NEVER commit this file");
+    });
+
+    it("includes provided values", () => {
+      const content = EnvService.generateEnvLocal({ SUBDOMAIN_PREFIX: "myapp" });
+      expect(content).toContain('SUBDOMAIN_PREFIX="myapp"');
+    });
+
+    it("uses defaults for missing vars", () => {
+      const content = EnvService.generateEnvLocal({});
+      expect(content).toContain('SUBDOMAIN_PREFIX="cryptolinx"');
+    });
+  });
+
+  describe("getWorkerDevVars", () => {
+    it("maps vars to correct workers", () => {
+      const vars = {
+        AGENT_OPENAI_KEY: "sk-123",
+        TELEGRAM_BOT_TOKEN: "tg-456",
+        D1_INTERNAL_KEY: "d1-789",
+      };
+      const result = EnvService.getWorkerDevVars(vars);
+      expect(result["workers/agent-worker"]).toBeDefined();
+      expect(result["workers/agent-worker"].AGENT_OPENAI_KEY).toBe("sk-123");
+      expect(result["workers/telegram-worker"]).toBeDefined();
+      expect(result["workers/telegram-worker"].TELEGRAM_BOT_TOKEN).toBe("tg-456");
+    });
+
+    it("omits workers with no matching vars", () => {
+      const result = EnvService.getWorkerDevVars({});
+      expect(Object.keys(result).length).toBe(0);
+    });
+
+    it("omits empty-string vars", () => {
+      const result = EnvService.getWorkerDevVars({ D1_INTERNAL_KEY: "" });
+      expect(Object.keys(result).length).toBe(0);
+    });
+
+    it("maps all newly added vars to correct workers", () => {
+      const vars = {
+        WEBHOOK_API_KEY_BINDING: "webhook-key",
+        HA_TOKEN_BINDING: "ha-token",
+        API_SERVICE_KEY: "api-key",
+        TELEGRAM_SECRET_TOKEN: "tg-secret",
+        WALLET_MNEMONIC_SECRET: "mnemonic",
+        WALLET_PK_SECRET: "pk",
+        EMAIL_HOST: "imap.example.com",
+        EMAIL_USER: "user",
+        EMAIL_PASS: "pass",
+        INTERNAL_KEY: "int-key",
+      };
+      const result = EnvService.getWorkerDevVars(vars);
+      expect(result["workers/hoox"]).toBeDefined();
+      expect(result["workers/hoox"].WEBHOOK_API_KEY_BINDING).toBe("webhook-key");
+      expect(result["workers/hoox"].HA_TOKEN_BINDING).toBe("ha-token");
+      expect(result["workers/trade-worker"].API_SERVICE_KEY).toBe("api-key");
+      expect(result["workers/telegram-worker"].TELEGRAM_SECRET_TOKEN).toBe("tg-secret");
+      expect(result["workers/web3-wallet-worker"]).toBeDefined();
+      expect(result["workers/web3-wallet-worker"].WALLET_MNEMONIC_SECRET).toBe("mnemonic");
+      expect(result["workers/email-worker"]).toBeDefined();
+      expect(result["workers/email-worker"].EMAIL_HOST).toBe("imap.example.com");
+    });
+  });
+
+  describe("validate", () => {
+    it("flags missing required vars", () => {
+      const result = EnvService.validate({});
+      expect(result.missing.length).toBeGreaterThan(0);
+      expect(result.missing).toContain("CLOUDFLARE_API_TOKEN");
+    });
+
+    it("flags 'your_' placeholder values as missing", () => {
+      const result = EnvService.validate({ CLOUDFLARE_API_TOKEN: "your_cloudflare_api_token" });
+      expect(result.missing).toContain("CLOUDFLARE_API_TOKEN");
+    });
+
+    it("flags 'generate_' placeholder values as missing", () => {
+      const result = EnvService.validate({ SESSION_SECRET: "generate_a_32_character_secure_random_string" });
+      expect(result.missing).toContain("SESSION_SECRET");
+    });
+
+    it("passes when all required vars are set with real values", () => {
+      const vars: Record<string, string> = {
+        CLOUDFLARE_API_TOKEN: "cfut_xxx",
+        CLOUDFLARE_ACCOUNT_ID: "abc123",
+        SUBDOMAIN_PREFIX: "myapp",
+        D1_INTERNAL_KEY: "d1-key",
+        TRADE_INTERNAL_KEY: "trade-key",
+        AGENT_INTERNAL_KEY: "agent-key",
+        WEBHOOK_API_KEY_BINDING: "webhook-key",
+        INTERNAL_KEY_BINDING: "int-key",
+        API_SERVICE_KEY: "api-key",
+        DASHBOARD_USER: "admin",
+        DASHBOARD_PASS: "pass123",
+        SESSION_SECRET: "a".repeat(32),
+      };
+      const result = EnvService.validate(vars);
+      expect(result.missing.length).toBe(0);
+    });
+
+    it("warns on short session secret", () => {
+      const vars: Record<string, string> = {
+        CLOUDFLARE_API_TOKEN: "tok",
+        CLOUDFLARE_ACCOUNT_ID: "id",
+        SUBDOMAIN_PREFIX: "p",
+        D1_INTERNAL_KEY: "k",
+        TRADE_INTERNAL_KEY: "k",
+        AGENT_INTERNAL_KEY: "k",
+        WEBHOOK_API_KEY_BINDING: "wk",
+        INTERNAL_KEY_BINDING: "ik",
+        API_SERVICE_KEY: "ak",
+        DASHBOARD_USER: "u",
+        DASHBOARD_PASS: "p",
+        SESSION_SECRET: "short",
+      };
+      const result = EnvService.validate(vars);
+      expect(result.warnings).toContain("SESSION_SECRET should be at least 32 characters");
+    });
+  });
+
+  describe("show", () => {
+    it("redacts secrets", () => {
+      const output = EnvService.show({ CLOUDFLARE_API_TOKEN: "secret123" });
+      expect(output).toContain("********");
+      expect(output).not.toContain("secret123");
+    });
+
+    it("shows non-secrets in plain text", () => {
+      const output = EnvService.show({ SUBDOMAIN_PREFIX: "myapp" });
+      expect(output).toContain("myapp");
+    });
+  });
+
+  describe("loadDotEnvAsync", () => {
+    it("returns empty object for missing file", async () => {
+      const result = await EnvService.loadDotEnvAsync("/tmp/nonexistent-file-12345.env");
+      expect(Object.keys(result).length).toBe(0);
+    });
+
+    it("parses simple key=value lines", async () => {
+      const filePath = "/tmp/test-simple-12345.env";
+      await Bun.write(filePath, 'KEY=value\nFOO=bar\n');
+      const result = await EnvService.loadDotEnvAsync(filePath);
+      expect(result.KEY).toBe("value");
+      expect(result.FOO).toBe("bar");
+      await Bun.write(filePath, ""); // cleanup
+    });
+
+    it("strips double quotes from values", async () => {
+      const filePath = "/tmp/test-quotes-12345.env";
+      await Bun.write(filePath, 'KEY="quoted value"\nNESTED="val with \\"quote\\""\n');
+      const result = await EnvService.loadDotEnvAsync(filePath);
+      // First quote-stripped value
+      expect(result.KEY).toBe("quoted value");
+      await Bun.write(filePath, "");
+    });
+
+    it("skips comments and blank lines", async () => {
+      const filePath = "/tmp/test-comments-12345.env";
+      await Bun.write(filePath, '# this is a comment\n\nKEY=val\n# another comment\nFOO=bar\n');
+      const result = await EnvService.loadDotEnvAsync(filePath);
+      expect(result.KEY).toBe("val");
+      expect(result.FOO).toBe("bar");
+      expect(Object.keys(result).length).toBe(2);
+      await Bun.write(filePath, "");
+    });
+
+    it("handles empty values", async () => {
+      const filePath = "/tmp/test-empty-12345.env";
+      await Bun.write(filePath, 'EMPTY=\nKEY=val\n');
+      const result = await EnvService.loadDotEnvAsync(filePath);
+      expect(result.EMPTY).toBe("");
+      expect(result.KEY).toBe("val");
+      await Bun.write(filePath, "");
+    });
+  });
+});