@layr-labs/ecloud-cli 0.4.0-dev → 0.4.0-dev.0

package/dist/commands/billing/__tests__/subscribe.test.js

@@ -0,0 +1,580 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/viemClients.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  getEnvironmentConfig,
+  addHexPrefix,
+  createViemClients as sdkCreateViemClients,
+  getChainFromID
+} from "@layr-labs/ecloud-sdk";
+var init_viemClients = __esm({
+  "src/utils/viemClients.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/globalConfig.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { load as loadYaml, dump as dumpYaml } from "js-yaml";
+import { getBuildType } from "@layr-labs/ecloud-sdk";
+import * as crypto from "crypto";
+function getGlobalConfigDir() {
+  const configHome = process.env.XDG_CONFIG_HOME;
+  let baseDir;
+  if (configHome && path.isAbsolute(configHome)) {
+    baseDir = configHome;
+  } else {
+    baseDir = path.join(os.homedir(), ".config");
+  }
+  const buildType = getBuildType();
+  const buildSuffix = buildType === "dev" ? "-dev" : "";
+  const configDirName = `ecloud${buildSuffix}`;
+  return path.join(baseDir, configDirName);
+}
+function getGlobalConfigPath() {
+  return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE);
+}
+function loadGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {
+      first_run: true
+    };
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = loadYaml(content);
+    return config || { first_run: true };
+  } catch {
+    return {
+      first_run: true
+    };
+  }
+}
+function saveGlobalConfig(config) {
+  const configPath = getGlobalConfigPath();
+  const configDir = path.dirname(configPath);
+  fs.mkdirSync(configDir, { recursive: true, mode: 493 });
+  const content = dumpYaml(config, { lineWidth: -1 });
+  fs.writeFileSync(configPath, content, { mode: 420 });
+}
+function getDefaultEnvironment() {
+  const config = loadGlobalConfig();
+  return config.default_environment;
+}
+function getGlobalTelemetryPreference() {
+  const config = loadGlobalConfig();
+  return config.telemetry_enabled;
+}
+function getOrCreateUserUUID() {
+  const config = loadGlobalConfig();
+  if (config.user_uuid) {
+    return config.user_uuid;
+  }
+  const uuid = generateUUID();
+  config.user_uuid = uuid;
+  config.first_run = false;
+  saveGlobalConfig(config);
+  return uuid;
+}
+function generateUUID() {
+  const bytes = crypto.randomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return hex.slice(0, 4).join("") + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 12).join("") + "-" + hex.slice(12, 16).join("");
+}
+var GLOBAL_CONFIG_FILE, PROFILE_CACHE_TTL_MS;
+var init_globalConfig = __esm({
+  "src/utils/globalConfig.ts"() {
+    "use strict";
+    GLOBAL_CONFIG_FILE = "config.yaml";
+    PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/utils/appNames.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import { load as loadYaml2, dump as dumpYaml2 } from "js-yaml";
+var CONFIG_DIR, APPS_DIR;
+var init_appNames = __esm({
+  "src/utils/appNames.ts"() {
+    "use strict";
+    CONFIG_DIR = path2.join(os2.homedir(), ".eigenx");
+    APPS_DIR = path2.join(CONFIG_DIR, "apps");
+  }
+});
+
+// src/utils/version.ts
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/appResolver.ts
+import { isAddress } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import {
+  UserApiClient,
+  getAllAppsByDeveloper
+} from "@layr-labs/ecloud-sdk";
+var init_appResolver = __esm({
+  "src/utils/appResolver.ts"() {
+    "use strict";
+    init_viemClients();
+    init_globalConfig();
+    init_appNames();
+    init_version();
+  }
+});
+
+// src/utils/prompts.ts
+import { input, select, password, confirm as inquirerConfirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+import { isAddress as isAddress2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import {
+  getEnvironmentConfig as getEnvironmentConfig2,
+  getAvailableEnvironments,
+  isEnvironmentAvailable,
+  getAllAppsByDeveloper as getAllAppsByDeveloper2,
+  getCategoryDescriptions,
+  fetchTemplateCatalog,
+  PRIMARY_LANGUAGES,
+  validateAppName,
+  validateImageReference,
+  validateFilePath,
+  validatePrivateKeyFormat,
+  extractAppNameFromImage,
+  UserApiClient as UserApiClient2
+} from "@layr-labs/ecloud-sdk";
+async function getPrivateKeyInteractive(privateKey) {
+  if (privateKey) {
+    if (!validatePrivateKeyFormat(privateKey)) {
+      throw new Error("Invalid private key format");
+    }
+    return privateKey;
+  }
+  const { getPrivateKeyWithSource: getPrivateKeyWithSource2 } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource2({ privateKey: void 0 });
+  if (result) {
+    return result.key;
+  }
+  const key = await password({
+    message: "Enter private key:",
+    mask: true,
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Private key is required";
+      }
+      if (!validatePrivateKeyFormat(value)) {
+        return "Invalid private key format (must be 64 hex characters, optionally prefixed with 0x)";
+      }
+      return true;
+    }
+  });
+  return key.trim();
+}
+var MAX_IMAGE_SIZE;
+var init_prompts = __esm({
+  "src/utils/prompts.ts"() {
+    "use strict";
+    init_appResolver();
+    init_viemClients();
+    init_globalConfig();
+    init_appNames();
+    init_version();
+    MAX_IMAGE_SIZE = 4 * 1024 * 1024;
+  }
+});
+
+// src/flags.ts
+import { Flags } from "@oclif/core";
+import { getBuildType as getBuildType2 } from "@layr-labs/ecloud-sdk";
+var commonFlags;
+var init_flags = __esm({
+  "src/flags.ts"() {
+    "use strict";
+    init_prompts();
+    init_globalConfig();
+    commonFlags = {
+      environment: Flags.string({
+        required: false,
+        description: "Deployment environment to use",
+        env: "ECLOUD_ENV",
+        default: async () => getDefaultEnvironment() || (getBuildType2() === "dev" ? "sepolia-dev" : "sepolia")
+      }),
+      "private-key": Flags.string({
+        required: false,
+        description: "Private key for signing transactions",
+        env: "ECLOUD_PRIVATE_KEY"
+      }),
+      "rpc-url": Flags.string({
+        required: false,
+        description: "RPC URL to connect to blockchain",
+        env: "ECLOUD_RPC_URL"
+      }),
+      verbose: Flags.boolean({
+        required: false,
+        description: "Enable verbose logging (default: false)",
+        default: false
+      })
+    };
+  }
+});
+
+// src/client.ts
+import {
+  createComputeModule,
+  createBillingModule,
+  createBuildModule,
+  getEnvironmentConfig as getEnvironmentConfig3,
+  requirePrivateKey,
+  getPrivateKeyWithSource,
+  addHexPrefix as addHexPrefix2
+} from "@layr-labs/ecloud-sdk";
+import { createWalletClient, custom } from "viem";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+async function createBillingClient(flags) {
+  const result = await getPrivateKeyWithSource({
+    privateKey: flags["private-key"]
+  });
+  const privateKey = await getPrivateKeyInteractive(result?.key);
+  const account = privateKeyToAccount4(addHexPrefix2(privateKey));
+  const walletClient = createWalletClient({
+    account,
+    transport: custom({
+      async request() {
+        throw new Error("RPC not available - billing uses local signing only");
+      }
+    })
+  });
+  return createBillingModule({
+    verbose: flags.verbose ?? false,
+    walletClient,
+    skipTelemetry: true
+    // CLI already has telemetry, skip SDK telemetry
+  });
+}
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_flags();
+    init_prompts();
+    init_version();
+    init_viemClients();
+  }
+});
+
+// src/telemetry.ts
+import {
+  createTelemetryClient,
+  createAppEnvironment,
+  createMetricsContext,
+  addMetric,
+  addMetricWithDimensions,
+  emitMetrics,
+  getBuildType as getBuildType3
+} from "@layr-labs/ecloud-sdk";
+function createCLITelemetryClient() {
+  const userUUID = getOrCreateUserUUID();
+  const environment = createAppEnvironment(userUUID);
+  const telemetryEnabled = getGlobalTelemetryPreference();
+  return createTelemetryClient(environment, "ecloud-cli", {
+    telemetryEnabled: telemetryEnabled !== false
+    // Enabled by default, disabled only if explicitly set to false
+  });
+}
+async function withTelemetry(command, action) {
+  const client = createCLITelemetryClient();
+  const metrics = createMetricsContext();
+  metrics.properties["source"] = "ecloud-cli";
+  metrics.properties["command"] = command.id || command.constructor.name;
+  const environment = getDefaultEnvironment() || "sepolia";
+  metrics.properties["environment"] = environment;
+  const buildType = getBuildType3() || "prod";
+  metrics.properties["build_type"] = buildType;
+  const cliVersion = command.config.version;
+  if (cliVersion) {
+    metrics.properties["cli_version"] = cliVersion;
+  }
+  addMetric(metrics, "Count", 1);
+  let actionError;
+  let result;
+  try {
+    result = await action();
+    return result;
+  } catch (err) {
+    actionError = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const resultValue = actionError ? "Failure" : "Success";
+    const dimensions = {};
+    if (actionError) {
+      dimensions["error"] = actionError.message;
+    }
+    addMetricWithDimensions(metrics, resultValue, 1, dimensions);
+    const duration = Date.now() - metrics.startTime.getTime();
+    addMetric(metrics, "DurationMilliseconds", duration);
+    try {
+      await emitMetrics(client, metrics);
+      await client.close();
+    } catch {
+    }
+  }
+}
+var init_telemetry = __esm({
+  "src/telemetry.ts"() {
+    "use strict";
+    init_globalConfig();
+  }
+});
+
+// src/commands/billing/subscribe.ts
+var subscribe_exports = {};
+__export(subscribe_exports, {
+  default: () => BillingSubscribe
+});
+import { Command, Flags as Flags2 } from "@oclif/core";
+import { isSubscriptionActive } from "@layr-labs/ecloud-sdk";
+import chalk2 from "chalk";
+import open from "open";
+import { select as select2 } from "@inquirer/prompts";
+var PAYMENT_TIMEOUT_MS, POLL_INTERVAL_MS, BillingSubscribe;
+var init_subscribe = __esm({
+  "src/commands/billing/subscribe.ts"() {
+    "use strict";
+    init_client();
+    init_flags();
+    init_telemetry();
+    PAYMENT_TIMEOUT_MS = 5 * 60 * 1e3;
+    POLL_INTERVAL_MS = 3e3;
+    BillingSubscribe = class _BillingSubscribe extends Command {
+      static description = "Create subscription to start deploying apps";
+      static flags = {
+        ...commonFlags,
+        product: Flags2.string({
+          required: false,
+          description: "Product ID",
+          default: "compute",
+          options: ["compute"],
+          env: "ECLOUD_PRODUCT_ID"
+        })
+      };
+      async run() {
+        return withTelemetry(this, async () => {
+          const { flags } = await this.parse(_BillingSubscribe);
+          const billing = await createBillingClient(flags);
+          this.debug(`
+Checking subscription status for ${flags.product}...`);
+          const result = await billing.subscribe({
+            productId: flags.product
+          });
+          if (result.type === "already_active") {
+            this.log(
+              `
+${chalk2.green("\u2713")} Wallet ${chalk2.bold(billing.address)} is already subscribed to ${flags.product}.`
+            );
+            this.log(chalk2.gray("Run 'ecloud billing status' for details."));
+            return;
+          }
+          if (result.type === "payment_issue") {
+            this.log(
+              `
+${chalk2.yellow("\u26A0")} You already have a subscription on ${flags.product}, but it has a payment issue.`
+            );
+            this.log("Please update your payment method to restore access.");
+            if (result.portalUrl) {
+              this.log(`
+${chalk2.bold("Update payment method:")}`);
+              this.log(`  ${result.portalUrl}`);
+            }
+            return;
+          }
+          const paymentMethod = await select2({
+            message: "How would you like to pay for EigenCompute?",
+            choices: [
+              {
+                value: "card",
+                name: "Credit card",
+                description: "Pay via Stripe checkout (opens browser)"
+              },
+              {
+                value: "usdc",
+                name: "Purchase credits with USDC",
+                description: "Pay on-chain \u2014 no credit card needed"
+              }
+            ]
+          });
+          if (paymentMethod === "usdc") {
+            await this.config.runCommand("billing:top-up", [
+              ...flags["private-key"] ? ["--private-key", flags["private-key"]] : [],
+              ...flags.verbose ? ["--verbose"] : [],
+              ...flags.environment ? ["--environment", flags.environment] : [],
+              ...flags["rpc-url"] ? ["--rpc-url", flags["rpc-url"]] : [],
+              "--product",
+              flags.product
+            ]);
+            return;
+          }
+          this.log(`
+Opening checkout for wallet ${chalk2.bold(billing.address)}...`);
+          this.log(chalk2.gray(`
+URL: ${result.checkoutUrl}`));
+          this.log(chalk2.gray(`
+Prefer to pay with USDC? Run: ecloud billing top-up`));
+          await open(result.checkoutUrl);
+          this.log(`
+${chalk2.gray("Waiting for payment confirmation...")}`);
+          const startTime = Date.now();
+          while (Date.now() - startTime < PAYMENT_TIMEOUT_MS) {
+            await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL_MS));
+            try {
+              const status = await billing.getStatus({
+                productId: flags.product
+              });
+              if (isSubscriptionActive(status.subscriptionStatus)) {
+                this.log(
+                  `
+${chalk2.green("\u2713")} Subscription activated successfully for ${flags.product}!`
+                );
+                this.log(`
+${chalk2.gray("Start deploying with:")} ecloud compute app deploy`);
+                return;
+              }
+            } catch (error) {
+              this.debug(`Error polling for subscription status: ${error}`);
+            }
+          }
+          this.log(`
+${chalk2.yellow("\u26A0")} Payment confirmation timed out after 5 minutes.`);
+          this.log(
+            chalk2.gray(`If you completed payment, run 'ecloud billing status' to check status.`)
+          );
+        });
+      }
+    };
+  }
+});
+
+// src/commands/billing/__tests__/subscribe.test.ts
+init_client();
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { select as select3 } from "@inquirer/prompts";
+vi.mock("../../../client", () => ({
+  createBillingClient: vi.fn()
+}));
+vi.mock("../../../telemetry", () => ({
+  withTelemetry: vi.fn((_cmd, fn) => fn())
+}));
+vi.mock("@inquirer/prompts", () => ({
+  select: vi.fn(),
+  confirm: vi.fn()
+}));
+vi.mock("open", () => ({
+  default: vi.fn()
+}));
+describe("ecloud billing subscribe \u2014 payment method selection", () => {
+  let logOutput;
+  let mockBilling;
+  let runCommandCalls;
+  beforeEach(() => {
+    logOutput = [];
+    runCommandCalls = [];
+    mockBilling = {
+      address: "0xabcdef1234567890abcdef1234567890abcdef12",
+      subscribe: vi.fn(),
+      getStatus: vi.fn()
+    };
+    createBillingClient.mockResolvedValue(mockBilling);
+  });
+  async function runCommand(selectResponse, subscribeResult = { type: "checkout_created", checkoutUrl: "https://checkout.stripe.com/test" }) {
+    const { default: BillingSubscribe2 } = await Promise.resolve().then(() => (init_subscribe(), subscribe_exports));
+    select3.mockResolvedValue(selectResponse);
+    mockBilling.subscribe.mockResolvedValue(subscribeResult);
+    mockBilling.getStatus.mockResolvedValue({
+      subscriptionStatus: "active"
+    });
+    const cmd = new BillingSubscribe2([], {});
+    cmd.parse = vi.fn().mockResolvedValue({
+      flags: { product: "compute", verbose: false }
+    });
+    cmd.log = vi.fn((...args) => logOutput.push(args.join(" ")));
+    cmd.debug = vi.fn();
+    cmd.config = {
+      runCommand: vi.fn((...args) => {
+        runCommandCalls.push(args);
+        return Promise.resolve();
+      })
+    };
+    await cmd.run();
+    return logOutput;
+  }
+  it("presents CC and USDC as payment options", async () => {
+    await runCommand("card");
+    expect(select3).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("pay"),
+        choices: expect.arrayContaining([
+          expect.objectContaining({ value: "card" }),
+          expect.objectContaining({ value: "usdc" })
+        ])
+      })
+    );
+  });
+  it("delegates to ecloud billing top-up when USDC is selected", async () => {
+    await runCommand("usdc");
+    expect(runCommandCalls.length).toBe(1);
+    expect(runCommandCalls[0][0]).toBe("billing:top-up");
+  });
+  it("opens Stripe checkout when credit card is selected", async () => {
+    const open2 = (await import("open")).default;
+    await runCommand("card");
+    expect(open2).toHaveBeenCalledWith("https://checkout.stripe.com/test");
+  });
+  it("shows top-up hint during credit card checkout", async () => {
+    await runCommand("card");
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain("ecloud billing top-up");
+  });
+  it("skips payment selection when subscription is already active", async () => {
+    mockBilling.subscribe.mockResolvedValue({
+      type: "already_active",
+      status: "active"
+    });
+    const { default: BillingSubscribe2 } = await Promise.resolve().then(() => (init_subscribe(), subscribe_exports));
+    const cmd = new BillingSubscribe2([], {});
+    cmd.parse = vi.fn().mockResolvedValue({
+      flags: { product: "compute", verbose: false }
+    });
+    cmd.log = vi.fn((...args) => logOutput.push(args.join(" ")));
+    cmd.debug = vi.fn();
+    await cmd.run();
+    expect(select3).not.toHaveBeenCalled();
+    const fullOutput = logOutput.join("\n");
+    expect(fullOutput).toContain("already subscribed");
+  });
+});
+//# sourceMappingURL=subscribe.test.js.map