@layr-labs/ecloud-cli 0.1.1-dev → 0.2.0-dev

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

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+
+// src/commands/compute/build/logs.ts
+import { Args, Command, Flags as Flags2 } from "@oclif/core";
+
+// src/flags.ts
+import { Flags } from "@oclif/core";
+
+// 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" : "0.0.0";
+}
+function getClientId() {
+  return `ecloud-cli/v${getCliVersion()}`;
+}
+
+// src/utils/prompts.ts
+function formatBuildChoice(build) {
+  const repoUrl = String(build.repoUrl || "").replace(/\.git$/i, "").replace(/\/+$/, "");
+  const repoName = (() => {
+    try {
+      const url = new URL(repoUrl);
+      const parts = url.pathname.split("/").filter(Boolean);
+      return parts.length ? parts[parts.length - 1] : repoUrl;
+    } catch {
+      const m = repoUrl.match(/[:/]+([^/:]+)$/);
+      return m?.[1] || repoUrl || "unknown";
+    }
+  })();
+  const shortSha = build.gitRef ? String(build.gitRef).slice(0, 10) : "unknown";
+  const shortId = build.buildId ? String(build.buildId).slice(0, 8) : "unknown";
+  const created = build.createdAt ? new Date(build.createdAt).toLocaleString() : "";
+  const status = String(build.status || "unknown");
+  return `${status}  ${repoName}@${shortSha}  ${shortId}  ${created}`;
+}
+async function promptBuildIdFromRecentBuilds(options) {
+  const limit = Math.max(1, Math.min(100, options.limit ?? 20));
+  const builds = await options.client.list({
+    billingAddress: options.billingAddress,
+    limit,
+    offset: 0
+  });
+  if (!builds || builds.length === 0) {
+    throw new Error(`No builds found for billing address ${options.billingAddress}`);
+  }
+  const choice = await select({
+    message: "Select a build:",
+    choices: builds.map((b) => ({
+      name: formatBuildChoice(b),
+      value: b.buildId
+    }))
+  });
+  return choice;
+}
+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"
+  }),
+  "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) {
+  if (!flags["environment"]) {
+    flags["environment"] = getDefaultEnvironment();
+  }
+  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 getBuildType2
+} from "@layr-labs/ecloud-sdk";
+function createCLITelemetryClient() {
+  const userUUID = getOrCreateUserUUID();
+  const environment = createAppEnvironment(userUUID);
+  const telemetryEnabled = getGlobalTelemetryPreference();
+  return createTelemetryClient(environment, "ecloud-cli", {
+    telemetryEnabled: telemetryEnabled === true
+    // Only enabled if explicitly set to true
+  });
+}
+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 = getBuildType2() || "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/commands/compute/build/logs.ts
+import chalk from "chalk";
+import { BUILD_STATUS as BUILD_STATUS2 } from "@layr-labs/ecloud-sdk";
+
+// src/utils/verifiableBuild.ts
+import { BUILD_STATUS } from "@layr-labs/ecloud-sdk";
+function assertBuildId(buildId) {
+  const trimmed = String(buildId ?? "").trim();
+  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  if (!UUID_RE.test(trimmed)) {
+    throw new Error(`Invalid build ID: '${buildId}' (expected a UUID)`);
+  }
+}
+
+// src/commands/compute/build/logs.ts
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import { addHexPrefix } from "@layr-labs/ecloud-sdk";
+var BuildLogs = class _BuildLogs extends Command {
+  static description = "Get or stream build logs";
+  static examples = [
+    `$ ecloud compute build logs abc123-def456-...`,
+    `$ ecloud compute build logs abc123-def456-... --follow`,
+    `$ ecloud compute build logs abc123-def456-... --tail 50`
+  ];
+  static args = {
+    buildId: Args.string({
+      description: "Build ID",
+      required: false
+    })
+  };
+  static flags = {
+    ...commonFlags,
+    follow: Flags2.boolean({
+      char: "f",
+      description: "Follow logs in real-time",
+      default: false
+    }),
+    tail: Flags2.integer({
+      description: "Show last N lines"
+    })
+  };
+  async run() {
+    return withTelemetry(this, async () => {
+      const { args, flags } = await this.parse(_BuildLogs);
+      const validatedFlags = await validateCommonFlags(flags);
+      const client = await createBuildClient(validatedFlags);
+      let buildId = args.buildId;
+      if (!buildId) {
+        const billingAddress = privateKeyToAccount3(
+          addHexPrefix(validatedFlags["private-key"])
+        ).address;
+        buildId = await promptBuildIdFromRecentBuilds({ client, billingAddress, limit: 20 });
+      } else {
+        try {
+          assertBuildId(buildId);
+        } catch (e) {
+          this.error(e?.message || String(e));
+        }
+      }
+      if (flags.follow) {
+        const pollIntervalMs = 2e3;
+        let lastLogLength = 0;
+        while (true) {
+          const build = await client.get(buildId);
+          let logs2 = "";
+          try {
+            logs2 = await client.getLogs(buildId);
+          } catch {
+          }
+          if (logs2.length > lastLogLength) {
+            process.stdout.write(logs2.slice(lastLogLength));
+            lastLogLength = logs2.length;
+          }
+          if (build.status !== BUILD_STATUS2.BUILDING) {
+            process.stdout.write("\n");
+            break;
+          }
+          await showCountdown(Math.ceil(pollIntervalMs / 1e3));
+        }
+        return;
+      }
+      const logs = await client.getLogs(buildId);
+      if (flags.tail !== void 0) {
+        const lines = logs.split("\n");
+        const tailedLines = lines.slice(-flags.tail);
+        this.log(tailedLines.join("\n"));
+      } else {
+        this.log(logs);
+      }
+    });
+  }
+};
+async function showCountdown(seconds) {
+  for (let i = seconds; i >= 0; i--) {
+    process.stdout.write(chalk.gray(`\rRefreshing in ${i}...`));
+    if (i > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+  }
+  process.stdout.write("\r");
+}
+export {
+  BuildLogs as default
+};
+//# sourceMappingURL=logs.js.map