@layr-labs/ecloud-cli 0.2.0-dev.2 → 0.2.0-dev.3

package/dist/commands/compute/build/list.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+
+// src/commands/compute/build/list.ts
+import { Command, Flags as Flags2 } from "@oclif/core";
+import chalk2 from "chalk";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import { addHexPrefix } from "@layr-labs/ecloud-sdk";
+
+// src/flags.ts
+import { Flags } from "@oclif/core";
+import { getBuildType as getBuildType2 } from "@layr-labs/ecloud-sdk";
+
+// src/utils/prompts.ts
+import { input, select, password, confirm as inquirerConfirm } from "@inquirer/prompts";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+import { isAddress as isAddress2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import {
+  getEnvironmentConfig,
+  getAvailableEnvironments,
+  isEnvironmentAvailable,
+  getAllAppsByDeveloper as getAllAppsByDeveloper2,
+  getCategoryDescriptions,
+  fetchTemplateCatalog,
+  PRIMARY_LANGUAGES,
+  validateAppName,
+  validateImageReference,
+  validateFilePath,
+  validatePrivateKeyFormat,
+  extractAppNameFromImage,
+  UserApiClient as UserApiClient2
+} from "@layr-labs/ecloud-sdk";
+
+// src/utils/appResolver.ts
+import { isAddress } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  UserApiClient,
+  getAllAppsByDeveloper
+} from "@layr-labs/ecloud-sdk";
+
+// 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";
+var GLOBAL_CONFIG_FILE = "config.yaml";
+var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+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("");
+}
+
+// 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 = path2.join(os2.homedir(), ".eigenx");
+var APPS_DIR = path2.join(CONFIG_DIR, "apps");
+
+// src/utils/version.ts
+function getCliVersion() {
+  return true ? "0.2.0-dev.3" : "0.0.0";
+}
+function getClientId() {
+  return `ecloud-cli/v${getCliVersion()}`;
+}
+
+// src/utils/prompts.ts
+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();
+}
+async function getEnvironmentInteractive(environment) {
+  if (environment) {
+    try {
+      getEnvironmentConfig(environment);
+      if (!isEnvironmentAvailable(environment)) {
+        throw new Error(`Environment ${environment} is not available in this build`);
+      }
+      return environment;
+    } catch {
+    }
+  }
+  const availableEnvs = getAvailableEnvironments();
+  let defaultEnv;
+  const configDefaultEnv = getDefaultEnvironment();
+  if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
+    try {
+      getEnvironmentConfig(configDefaultEnv);
+      defaultEnv = configDefaultEnv;
+    } catch {
+    }
+  }
+  const choices = [];
+  if (availableEnvs.includes("sepolia")) {
+    choices.push({ name: "sepolia - Ethereum Sepolia testnet", value: "sepolia" });
+  }
+  if (availableEnvs.includes("sepolia-dev")) {
+    choices.push({ name: "sepolia-dev - Ethereum Sepolia testnet (dev)", value: "sepolia-dev" });
+  }
+  if (availableEnvs.includes("mainnet-alpha")) {
+    choices.push({
+      name: "mainnet-alpha - Ethereum mainnet (\u26A0\uFE0F  uses real funds)",
+      value: "mainnet-alpha"
+    });
+  }
+  if (choices.length === 0) {
+    throw new Error("No environments available in this build");
+  }
+  const env = await select({
+    message: "Select environment:",
+    choices,
+    default: defaultEnv
+  });
+  return env;
+}
+var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
+
+// src/flags.ts
+var 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
+  })
+};
+async function validateCommonFlags(flags, options) {
+  flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
+  if (options?.requirePrivateKey !== false) {
+    flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
+  }
+  return flags;
+}
+
+// src/client.ts
+import {
+  createComputeModule,
+  createBillingModule,
+  createBuildModule,
+  getEnvironmentConfig as getEnvironmentConfig2,
+  requirePrivateKey,
+  getPrivateKeyWithSource
+} from "@layr-labs/ecloud-sdk";
+async function createBuildClient(flags) {
+  flags = await validateCommonFlags(flags, { requirePrivateKey: false });
+  return createBuildModule({
+    verbose: flags.verbose,
+    privateKey: flags["private-key"],
+    environment: flags.environment,
+    clientId: getClientId(),
+    skipTelemetry: true
+    // CLI already has telemetry, skip SDK telemetry
+  });
+}
+
+// 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 {
+    }
+  }
+}
+
+// src/utils/buildInfo.ts
+import { BUILD_STATUS } from "@layr-labs/ecloud-sdk";
+import chalk from "chalk";
+function formatBuildStatus(status) {
+  const s = status;
+  const color = {
+    [BUILD_STATUS.BUILDING]: chalk.yellow,
+    [BUILD_STATUS.SUCCESS]: chalk.green,
+    [BUILD_STATUS.FAILED]: chalk.red
+  }[s];
+  return color ? color(status) : status;
+}
+
+// src/commands/compute/build/list.ts
+import Table from "cli-table3";
+
+// src/utils/cliFormat.ts
+function terminalWidth(fallback = 120) {
+  const cols = typeof process.stdout.columns === "number" ? process.stdout.columns : void 0;
+  return cols && cols > 0 ? cols : fallback;
+}
+function formatHumanTime(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) return "-";
+  if (/^\d+$/.test(raw)) {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n > 0) {
+      const ms = raw.length <= 10 ? n * 1e3 : n;
+      const d2 = new Date(ms);
+      if (!Number.isNaN(d2.getTime())) return d2.toLocaleString();
+    }
+    return raw;
+  }
+  const d = new Date(raw);
+  if (Number.isNaN(d.getTime())) return raw;
+  return d.toLocaleString();
+}
+function formatRepoDisplay(repoUrl) {
+  const normalized = String(repoUrl || "").replace(/\.git$/i, "").replace(/\/+$/, "");
+  try {
+    const url = new URL(normalized);
+    const host = url.host.toLowerCase();
+    if (host === "github.com") {
+      const parts = url.pathname.split("/").filter(Boolean);
+      if (parts.length >= 2) return `github.com/${parts[0]}/${parts[1]}`;
+    }
+    return `${host}${url.pathname}`.replace(/\/+$/, "");
+  } catch {
+    return normalized;
+  }
+}
+function formatImageDisplay(imageUrl) {
+  const s = String(imageUrl || "");
+  return s.replace(/^docker\.io\//i, "");
+}
+function provenanceSummary(options) {
+  const parts = [];
+  if (options.provenanceJson) parts.push("prov\u2713");
+  if (options.provenanceSignature) parts.push("sig\u2713");
+  const depCount = options.dependencies ? Object.keys(options.dependencies).length : 0;
+  if (depCount > 0) parts.push(`deps:${depCount}`);
+  return parts.length ? parts.join(" ") : "-";
+}
+
+// src/commands/compute/build/list.ts
+var BuildList = class _BuildList extends Command {
+  static description = "List recent verifiable builds for a billing address (most recent first)";
+  static examples = [
+    `$ ecloud compute build list`,
+    `$ ecloud compute build list --limit 10`,
+    `$ ecloud compute build list --json`
+  ];
+  static flags = {
+    ...commonFlags,
+    limit: Flags2.integer({
+      description: "Maximum number of builds to return (min 1, max 100)",
+      default: 20
+    }),
+    offset: Flags2.integer({
+      description: "Number of builds to skip",
+      default: 0
+    }),
+    json: Flags2.boolean({
+      description: "Output JSON instead of a table",
+      default: false
+    })
+  };
+  async run() {
+    return withTelemetry(this, async () => {
+      const { flags } = await this.parse(_BuildList);
+      const validatedFlags = await validateCommonFlags(flags);
+      const client = await createBuildClient(validatedFlags);
+      const billingAddress = privateKeyToAccount3(
+        addHexPrefix(validatedFlags["private-key"])
+      ).address;
+      const limit = Math.max(1, Math.min(100, flags.limit ?? 20));
+      const offset = Math.max(0, flags.offset ?? 0);
+      const builds = (await client.list({ billingAddress, limit, offset })).slice().reverse();
+      if (flags.json) {
+        this.log(JSON.stringify(builds, null, 2));
+        return;
+      }
+      if (!builds.length) {
+        this.log(`No builds found for ${billingAddress}`);
+        return;
+      }
+      const rows = builds.map((b) => ({
+        buildId: b.buildId || "-",
+        status: formatBuildStatus(b.status),
+        repo: formatRepoDisplay(b.repoUrl || "-"),
+        commit: b.gitRef || "-",
+        image: formatImageDisplay(b.imageUrl || "-"),
+        created: formatHumanTime(b.createdAt),
+        prov: provenanceSummary({
+          provenanceJson: b.provenanceJson,
+          provenanceSignature: b.provenanceSignature,
+          dependencies: b.dependencies
+        })
+      }));
+      const tw = terminalWidth();
+      const shouldStack = tw < 110;
+      this.log("");
+      this.log(chalk2.bold(`Builds for ${billingAddress} (${validatedFlags.environment}):`));
+      this.log("");
+      if (shouldStack) {
+        for (const r of rows) {
+          this.log(`${r.status}  ${chalk2.cyan(r.buildId)}  ${r.created}`);
+          this.log(`  Repo:   ${r.repo}`);
+          this.log(`  Commit: ${r.commit}`);
+          this.log(`  Image:  ${r.image}`);
+          this.log(`  Prov:   ${r.prov}`);
+          this.log(chalk2.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        }
+      } else {
+        const fixed = 37 + 10 + 20 + 14 + 8;
+        const remaining = Math.max(30, tw - fixed);
+        const repoW = Math.max(18, Math.floor(remaining * 0.28));
+        const commitW = Math.max(18, Math.floor(remaining * 0.36));
+        const imageW = Math.max(18, remaining - repoW - commitW);
+        const table = new Table({
+          head: [
+            chalk2.bold("ID"),
+            chalk2.bold("Status"),
+            chalk2.bold("Repo"),
+            chalk2.bold("Commit"),
+            chalk2.bold("Image"),
+            chalk2.bold("Created"),
+            chalk2.bold("Prov")
+          ],
+          colWidths: [37, 10, repoW, commitW, imageW, 20, 14],
+          wordWrap: true,
+          style: { "padding-left": 0, "padding-right": 1, head: [], border: [] }
+        });
+        for (const r of rows) {
+          table.push([r.buildId, r.status, r.repo, r.commit, r.image, r.created, r.prov]);
+        }
+        this.log(table.toString());
+      }
+      this.log("");
+      this.log(chalk2.gray(`Showing ${builds.length} build(s) (limit=${limit}, offset=${offset})`));
+      this.log(
+        chalk2.gray(
+          `Tip: use ${chalk2.yellow("ecloud compute build info <buildId>")} for full details, or add ${chalk2.yellow(
+            "--json"
+          )} to copy/paste.`
+        )
+      );
+    });
+  }
+};
+export {
+  BuildList as default
+};
+//# sourceMappingURL=list.js.map