@layr-labs/ecloud-cli 0.1.2 → 0.2.0-dev.1

package/dist/commands/compute/app/releases.js

@@ -0,0 +1,1111 @@
+#!/usr/bin/env node
+
+// src/commands/compute/app/releases.ts
+import { Command, Args, Flags as Flags2 } from "@oclif/core";
+import { getEnvironmentConfig as getEnvironmentConfig2, UserApiClient as UserApiClient3 } 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 normalizeDirectoryPath(directoryPath) {
+  const resolved = path.resolve(directoryPath);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function getLinkedAppForDirectory(environment, directoryPath) {
+  if (!directoryPath) {
+    return null;
+  }
+  const config = loadGlobalConfig();
+  const links = config.directory_links?.[environment];
+  if (!links) {
+    return null;
+  }
+  const normalizedPath = normalizeDirectoryPath(directoryPath);
+  const appId = links[normalizedPath];
+  return appId || null;
+}
+function getDefaultEnvironment() {
+  const config = loadGlobalConfig();
+  return config.default_environment;
+}
+function getGlobalTelemetryPreference() {
+  const config = loadGlobalConfig();
+  return config.telemetry_enabled;
+}
+function getProfileCache(environment) {
+  const config = loadGlobalConfig();
+  const cacheEntry = config.profile_cache?.[environment];
+  if (!cacheEntry) {
+    return null;
+  }
+  const now = Date.now();
+  if (now - cacheEntry.updated_at > PROFILE_CACHE_TTL_MS) {
+    return null;
+  }
+  return cacheEntry.profiles;
+}
+function setProfileCache(environment, profiles) {
+  const config = loadGlobalConfig();
+  if (!config.profile_cache) {
+    config.profile_cache = {};
+  }
+  config.profile_cache[environment] = {
+    updated_at: Date.now(),
+    profiles
+  };
+  saveGlobalConfig(config);
+}
+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");
+var APP_REGISTRY_VERSION = "1.0.0";
+function getAppRegistryPath(environment) {
+  return path2.join(APPS_DIR, `${environment}.yaml`);
+}
+function loadAppRegistry(environment) {
+  const filePath = getAppRegistryPath(environment);
+  if (!fs2.existsSync(filePath)) {
+    return {
+      version: APP_REGISTRY_VERSION,
+      apps: {}
+    };
+  }
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const registry = loadYaml2(content);
+    if (!registry.apps) {
+      registry.apps = {};
+    }
+    return registry;
+  } catch {
+    return {
+      version: APP_REGISTRY_VERSION,
+      apps: {}
+    };
+  }
+}
+function listApps(environment) {
+  const registry = loadAppRegistry(environment);
+  const result = {};
+  for (const [name, app] of Object.entries(registry.apps)) {
+    if (app?.app_id) {
+      result[name] = String(app.app_id);
+    }
+  }
+  return result;
+}
+
+// src/utils/version.ts
+function getCliVersion() {
+  return true ? "0.2.0-dev.1" : "0.0.0";
+}
+function getClientId() {
+  return `ecloud-cli/v${getCliVersion()}`;
+}
+
+// src/utils/appResolver.ts
+var CHUNK_SIZE = 10;
+async function getAppInfosChunked(userApiClient, appIds, addressCount) {
+  if (appIds.length === 0) {
+    return [];
+  }
+  const chunks = [];
+  for (let i = 0; i < appIds.length; i += CHUNK_SIZE) {
+    chunks.push(appIds.slice(i, i + CHUNK_SIZE));
+  }
+  const chunkResults = await Promise.all(
+    chunks.map((chunk) => userApiClient.getInfos(chunk, addressCount))
+  );
+  return chunkResults.flat();
+}
+
+// src/utils/prompts.ts
+function addHexPrefix(value) {
+  if (value.startsWith("0x")) {
+    return value;
+  }
+  return `0x${value}`;
+}
+function getCurrentProjectPath() {
+  return process.env.INIT_CWD || process.cwd();
+}
+var ContractAppStatusStarted = 1;
+var ContractAppStatusStopped = 2;
+var ContractAppStatusTerminated = 3;
+var ContractAppStatusSuspended = 4;
+function getContractStatusString(status) {
+  switch (status) {
+    case ContractAppStatusStarted:
+      return "Started";
+    case ContractAppStatusStopped:
+      return "Stopped";
+    case ContractAppStatusTerminated:
+      return "Terminated";
+    case ContractAppStatusSuspended:
+      return "Suspended";
+    default:
+      return "Unknown";
+  }
+}
+function getStatusPriority(status, isExited) {
+  if (isExited) {
+    return 1;
+  }
+  switch (status) {
+    case ContractAppStatusStarted:
+      return 0;
+    case ContractAppStatusStopped:
+      return 2;
+    case ContractAppStatusTerminated:
+      return 3;
+    default:
+      return 4;
+  }
+}
+function formatAppDisplay(environmentName, appID, profileName) {
+  if (profileName) {
+    return `${profileName} (${environmentName}:${appID})`;
+  }
+  return `${environmentName}:${appID}`;
+}
+async function getOrPromptAppID(appIDOrOptions, environment) {
+  let options;
+  if (environment !== void 0) {
+    options = {
+      appID: appIDOrOptions,
+      environment
+    };
+  } else if (appIDOrOptions && typeof appIDOrOptions === "object" && "environment" in appIDOrOptions) {
+    options = appIDOrOptions;
+  } else {
+    options = {
+      appID: appIDOrOptions,
+      environment: "sepolia"
+    };
+  }
+  if (options.appID) {
+    const normalized = typeof options.appID === "string" ? addHexPrefix(options.appID) : options.appID;
+    if (isAddress2(normalized)) {
+      return normalized;
+    }
+    const profileCache = getProfileCache(options.environment);
+    if (profileCache) {
+      const searchName = options.appID.toLowerCase();
+      for (const [appId, name] of Object.entries(profileCache)) {
+        if (name.toLowerCase() === searchName) {
+          return appId;
+        }
+      }
+    }
+    const apps = listApps(options.environment);
+    const foundAppID = apps[options.appID];
+    if (foundAppID) {
+      return addHexPrefix(foundAppID);
+    }
+    throw new Error(
+      `App name '${options.appID}' not found in environment '${options.environment}'`
+    );
+  }
+  return getAppIDInteractive(options);
+}
+async function getAppIDInteractive(options) {
+  const action = options.action || "view";
+  const environment = options.environment || "sepolia";
+  const environmentConfig = getEnvironmentConfig(environment);
+  if (!options.privateKey || !options.rpcUrl) {
+    return getAppIDInteractiveFromRegistry(environment, action);
+  }
+  console.log(`
+Select an app to ${action}:
+`);
+  const privateKeyHex = addHexPrefix(options.privateKey);
+  const account = privateKeyToAccount2(privateKeyHex);
+  const developerAddr = account.address;
+  const { apps, appConfigs } = await getAllAppsByDeveloper2(
+    options.rpcUrl,
+    environmentConfig,
+    developerAddr
+  );
+  if (apps.length === 0) {
+    throw new Error("no apps found for your address");
+  }
+  const profileNames = {};
+  let cachedProfiles = getProfileCache(environment);
+  if (!cachedProfiles) {
+    try {
+      const userApiClient = new UserApiClient2(
+        environmentConfig,
+        options.privateKey,
+        options.rpcUrl,
+        getClientId()
+      );
+      const appInfos = await getAppInfosChunked(userApiClient, apps);
+      const freshProfiles = {};
+      for (const info of appInfos) {
+        if (info.profile?.name) {
+          const normalizedId = String(info.address).toLowerCase();
+          freshProfiles[normalizedId] = info.profile.name;
+        }
+      }
+      setProfileCache(environment, freshProfiles);
+      cachedProfiles = freshProfiles;
+    } catch {
+      cachedProfiles = {};
+    }
+  }
+  for (const [appId, name] of Object.entries(cachedProfiles)) {
+    profileNames[appId.toLowerCase()] = name;
+  }
+  const localApps = listApps(environment);
+  for (const [name, appID] of Object.entries(localApps)) {
+    const normalizedID = String(appID).toLowerCase();
+    if (!profileNames[normalizedID]) {
+      profileNames[normalizedID] = name;
+    }
+  }
+  const isEligible = (status) => {
+    switch (action) {
+      case "view":
+      case "view info for":
+      case "view releases for":
+      case "set profile for":
+        return true;
+      case "start":
+        return status === ContractAppStatusStopped || status === ContractAppStatusSuspended;
+      case "stop":
+        return status === ContractAppStatusStarted;
+      default:
+        return status !== ContractAppStatusTerminated && status !== ContractAppStatusSuspended;
+    }
+  };
+  const appItems = [];
+  for (let i = 0; i < apps.length; i++) {
+    const appAddr = apps[i];
+    const config = appConfigs[i];
+    const status = config.status;
+    if (!isEligible(status)) {
+      continue;
+    }
+    const statusStr = getContractStatusString(status);
+    const profileName = profileNames[String(appAddr).toLowerCase()] || "";
+    const displayName = formatAppDisplay(environmentConfig.name, appAddr, profileName);
+    appItems.push({
+      addr: appAddr,
+      display: `${displayName} - ${statusStr}`,
+      status,
+      index: i
+    });
+  }
+  const linkedAppId = getLinkedAppForDirectory(environment, getCurrentProjectPath());
+  const normalizedLinkedAppId = linkedAppId ? linkedAppId.toLowerCase() : "";
+  appItems.sort((a, b) => {
+    if (normalizedLinkedAppId) {
+      const aLinked = String(a.addr).toLowerCase() === normalizedLinkedAppId;
+      const bLinked = String(b.addr).toLowerCase() === normalizedLinkedAppId;
+      if (aLinked && !bLinked) {
+        return -1;
+      }
+      if (bLinked && !aLinked) {
+        return 1;
+      }
+    }
+    const aPriority = getStatusPriority(a.status, false);
+    const bPriority = getStatusPriority(b.status, false);
+    if (aPriority !== bPriority) {
+      return aPriority - bPriority;
+    }
+    return b.index - a.index;
+  });
+  if (appItems.length === 0) {
+    switch (action) {
+      case "start":
+        throw new Error("no startable apps found - only Stopped apps can be started");
+      case "stop":
+        throw new Error("no running apps found - only Running apps can be stopped");
+      default:
+        throw new Error("no active apps found");
+    }
+  }
+  const choices = appItems.map((item) => ({
+    name: item.display,
+    value: item.addr
+  }));
+  const selected = await select({
+    message: "Select app:",
+    choices
+  });
+  return selected;
+}
+async function getAppIDInteractiveFromRegistry(environment, action) {
+  const allApps = {};
+  const cachedProfiles = getProfileCache(environment);
+  if (cachedProfiles) {
+    for (const [appId, name] of Object.entries(cachedProfiles)) {
+      allApps[name] = appId;
+    }
+  }
+  const localApps = listApps(environment);
+  for (const [name, appId] of Object.entries(localApps)) {
+    if (!allApps[name]) {
+      allApps[name] = appId;
+    }
+  }
+  if (Object.keys(allApps).length === 0) {
+    console.log("\nNo apps found in registry.");
+    console.log("You can enter an app ID (address) or app name.");
+    console.log();
+    const appIDInput = await input({
+      message: "Enter app ID or name:",
+      default: "",
+      validate: (value) => {
+        if (!value) {
+          return "App ID or name cannot be empty";
+        }
+        const normalized2 = addHexPrefix(value);
+        if (isAddress2(normalized2)) {
+          return true;
+        }
+        return "Invalid app ID address";
+      }
+    });
+    const normalized = addHexPrefix(appIDInput);
+    if (isAddress2(normalized)) {
+      return normalized;
+    }
+    throw new Error(`Invalid app ID address: ${appIDInput}`);
+  }
+  const entries = Object.entries(allApps);
+  const linkedAppId = getLinkedAppForDirectory(environment, getCurrentProjectPath());
+  if (linkedAppId) {
+    const linkedIndex = entries.findIndex(
+      ([, appId]) => String(appId).toLowerCase() === linkedAppId.toLowerCase()
+    );
+    if (linkedIndex > 0) {
+      const [linkedEntry] = entries.splice(linkedIndex, 1);
+      entries.unshift(linkedEntry);
+    }
+  }
+  const choices = entries.map(([name, appID]) => {
+    const displayName = `${name} (${appID})`;
+    return { name: displayName, value: appID };
+  });
+  choices.push({ name: "Enter custom app ID or name", value: "custom" });
+  console.log(`
+Select an app to ${action}:`);
+  const selected = await select({
+    message: "Choose app:",
+    choices
+  });
+  if (selected === "custom") {
+    const appIDInput = await input({
+      message: "Enter app ID or name:",
+      default: "",
+      validate: (value) => {
+        if (!value) {
+          return "App ID or name cannot be empty";
+        }
+        const normalized2 = addHexPrefix(value);
+        if (isAddress2(normalized2)) {
+          return true;
+        }
+        if (allApps[value]) {
+          return true;
+        }
+        return "Invalid app ID or name not found";
+      }
+    });
+    const normalized = addHexPrefix(appIDInput);
+    if (isAddress2(normalized)) {
+      return normalized;
+    }
+    const foundAppID = allApps[appIDInput];
+    if (foundAppID) {
+      return addHexPrefix(foundAppID);
+    }
+    throw new Error(`Failed to resolve app ID from input: ${appIDInput}`);
+  }
+  return addHexPrefix(selected);
+}
+async function getPrivateKeyInteractive(privateKey) {
+  if (privateKey) {
+    if (!validatePrivateKeyFormat(privateKey)) {
+      throw new Error("Invalid private key format");
+    }
+    return privateKey;
+  }
+  const { getPrivateKeyWithSource } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource({ 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/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/commands/compute/app/releases.ts
+import chalk2 from "chalk";
+
+// src/utils/releases.ts
+import chalk from "chalk";
+
+// src/utils/build.ts
+function formatSourceLink(repoUrl, gitRef) {
+  const normalizedRepo = repoUrl.replace(/\.git$/, "");
+  try {
+    const url = new URL(normalizedRepo);
+    const host = url.host.toLowerCase();
+    if (host === "github.com") {
+      const path4 = url.pathname.replace(/\/+$/, "");
+      if (path4.split("/").filter(Boolean).length >= 2) {
+        return `https://github.com${path4}/tree/${gitRef}`;
+      }
+    }
+  } catch {
+  }
+  return `${repoUrl}@${gitRef}`;
+}
+function extractRepoName(repoUrl) {
+  const normalized = repoUrl.replace(/\.git$/, "");
+  const match = normalized.match(/\/([^/]+?)$/);
+  return match?.[1];
+}
+function formatDependencyLines(dependencies) {
+  if (!dependencies || Object.keys(dependencies).length === 0) return [];
+  const lines = [];
+  lines.push("Dependencies (resolved builds):");
+  for (const [digest, dep] of Object.entries(dependencies)) {
+    const name = extractRepoName(dep.repoUrl);
+    const depSource = formatSourceLink(dep.repoUrl, dep.gitRef);
+    lines.push(`  - ${digest} \u2713${name ? ` ${name}` : ""}`);
+    lines.push(`    ${depSource}`);
+  }
+  return lines;
+}
+
+// src/utils/releases.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortedKeys(obj) {
+  return Object.keys(obj).sort((a, b) => a.localeCompare(b));
+}
+function formatPublicEnv(publicEnv) {
+  if (!publicEnv) return [];
+  if (typeof publicEnv === "string") {
+    try {
+      const parsed = JSON.parse(publicEnv);
+      if (Object.keys(parsed).length === 0) return [];
+      const lines = [];
+      lines.push(chalk.gray("publicEnv:"));
+      for (const k of sortedKeys(parsed)) {
+        const v = parsed[k];
+        lines.push(`  ${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+      }
+      return lines;
+    } catch {
+      return [`publicEnv: ${publicEnv}`];
+    }
+  }
+  if (isJsonObject(publicEnv) && !("BYTES_PER_ELEMENT" in publicEnv)) {
+    if (Object.keys(publicEnv).length === 0) return [];
+    const lines = [];
+    lines.push(chalk.gray("publicEnv:"));
+    for (const k of sortedKeys(publicEnv)) {
+      const v = publicEnv[k];
+      lines.push(`  ${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+    }
+    return lines;
+  }
+  return [`publicEnv: ${chalk.gray("<unavailable>")}`];
+}
+function formatMaybe(label, value) {
+  if (value === void 0 || value === null) return void 0;
+  const s = String(value);
+  if (!s) return void 0;
+  return `${label}: ${s}`;
+}
+function buildSummaryLines(build) {
+  if (!build) return [chalk.gray("Build: -")];
+  const lines = [];
+  lines.push(chalk.green("Build:"));
+  if (build.buildId) lines.push(`  build_id: ${build.buildId}`);
+  if (build.buildType) lines.push(`  build_type: ${build.buildType}`);
+  if (build.repoUrl && build.gitRef) {
+    lines.push(`  repo_url: ${build.repoUrl}`);
+    lines.push(`  git_ref: ${build.gitRef}`);
+    lines.push(`  source: ${formatSourceLink(build.repoUrl, build.gitRef)}`);
+  } else {
+    if (build.repoUrl) lines.push(`  repo_url: ${build.repoUrl}`);
+    if (build.gitRef) lines.push(`  git_ref: ${build.gitRef}`);
+  }
+  if (build.imageUrl) lines.push(`  image_url: ${build.imageUrl}`);
+  if (build.imageDigest) lines.push(`  image_digest: ${build.imageDigest}`);
+  if (build.provenanceSignature) lines.push(`  provenance_signature: ${build.provenanceSignature}`);
+  if (build.createdAt) lines.push(`  created_at: ${build.createdAt}`);
+  const deps = build.dependencies;
+  if (deps && Object.keys(deps).length > 0) {
+    const depMap = {};
+    for (const [digest, dep] of Object.entries(deps)) {
+      if (dep.repoUrl && dep.gitRef) {
+        depMap[digest] = { repoUrl: dep.repoUrl, gitRef: dep.gitRef };
+      }
+    }
+    const depLines = formatDependencyLines(depMap);
+    if (depLines.length) {
+      lines.push("");
+      lines.push(...depLines.map((l) => l ? `  ${l}` : l));
+    }
+  }
+  return lines;
+}
+function formatAppRelease(release, index) {
+  const lines = [];
+  const id = release.rmsReleaseId ?? String(index);
+  lines.push(chalk.cyan.bold(`Release ${id}`));
+  const headerFields = [
+    formatMaybe("createdAt", release.createdAt),
+    formatMaybe("createdAtBlock", release.createdAtBlock),
+    formatMaybe("upgradeByTime", release.upgradeByTime),
+    formatMaybe("registryUrl", release.registryUrl),
+    formatMaybe("imageDigest", release.imageDigest)
+  ].filter(Boolean);
+  lines.push(...headerFields);
+  const pub = formatPublicEnv(release.publicEnv);
+  if (pub.length) {
+    lines.push("");
+    lines.push(...pub);
+  }
+  lines.push("");
+  lines.push(...buildSummaryLines(release.build));
+  return lines;
+}
+
+// src/commands/compute/app/releases.ts
+import { isAddress as isAddress3 } from "viem";
+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 extractRepoName2(repoUrl) {
+  const normalized = String(repoUrl || "").replace(/\.git$/i, "").replace(/\/+$/, "");
+  try {
+    const url = new URL(normalized);
+    const parts = url.pathname.split("/").filter(Boolean);
+    return parts.length ? parts[parts.length - 1] : normalized;
+  } catch {
+    const m = normalized.match(/[:/]+([^/:]+)$/);
+    return m?.[1] || normalized || "unknown";
+  }
+}
+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/app/releases.ts
+function sortReleasesOldestFirst(releases) {
+  const toNum = (v) => {
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+    if (typeof v === "string" && /^\d+$/.test(v)) return Number(v);
+    return 0;
+  };
+  return [...releases].sort((a, b) => {
+    const byBlock = toNum(a.createdAtBlock) - toNum(b.createdAtBlock);
+    if (byBlock !== 0) return byBlock;
+    return toNum(a.createdAt) - toNum(b.createdAt);
+  });
+}
+function separator() {
+  return chalk2.gray("\u2014".repeat(40));
+}
+function formatDepLines(deps) {
+  if (!deps || Object.keys(deps).length === 0) return [];
+  const entries = Object.entries(deps).sort(([a], [b]) => a.localeCompare(b));
+  const lines = [];
+  lines.push("  Dependencies:");
+  for (const [digest, dep] of entries) {
+    const repoUrl = dep.repoUrl || "";
+    const name = extractRepoName2(repoUrl);
+    const repo = repoUrl ? formatRepoDisplay(repoUrl) : "-";
+    lines.push(`  - ${digest}`);
+    lines.push(`    ${name} (${repo})`);
+  }
+  return lines;
+}
+function provenanceSummaryFromBuild(build) {
+  if (!build) return "-";
+  return provenanceSummary({
+    provenanceJson: build.provenanceJson,
+    provenanceSignature: build.provenanceSignature,
+    dependencies: build.dependencies
+  });
+}
+var AppReleases = class _AppReleases extends Command {
+  static description = "Show app releases (including verifiable build + dependency builds when available)";
+  static args = {
+    "app-id": Args.string({
+      description: "App ID or name",
+      required: false
+    })
+  };
+  static flags = {
+    ...commonFlags,
+    json: Flags2.boolean({
+      description: "Output JSON instead of formatted text",
+      default: false
+    }),
+    full: Flags2.boolean({
+      description: "Show the full (multi-line) release details instead of a table",
+      default: false
+    })
+  };
+  async run() {
+    return withTelemetry(this, async () => {
+      const { args, flags } = await this.parse(_AppReleases);
+      const rawAppId = args["app-id"];
+      const needsPrivateKey = !rawAppId || !isAddress3(rawAppId);
+      const validatedFlags = await validateCommonFlags(flags, {
+        requirePrivateKey: needsPrivateKey
+      });
+      const environment = validatedFlags.environment || "sepolia";
+      const environmentConfig = getEnvironmentConfig2(environment);
+      const rpcUrl = validatedFlags["rpc-url"] || environmentConfig.defaultRPCURL;
+      const privateKey = validatedFlags["private-key"];
+      const appID = await getOrPromptAppID({
+        appID: args["app-id"],
+        environment,
+        privateKey,
+        rpcUrl,
+        action: "view releases for"
+      });
+      const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl, getClientId());
+      const data = await userApiClient.getApp(appID);
+      const releases = sortReleasesOldestFirst(data.releases);
+      if (releases.length === 0) {
+        this.log(`
+No releases found for app ${chalk2.gray(appID)}`);
+        return;
+      }
+      if (flags.json) {
+        this.log(JSON.stringify({ appID, releases }, null, 2));
+        return;
+      }
+      this.log(`
+Releases for app ${chalk2.gray(appID)}:
+`);
+      if (flags.full) {
+        for (let i = 0; i < releases.length; i++) {
+          const lines = formatAppRelease(releases[i], i);
+          for (const line of lines) this.log(line);
+          if (i !== releases.length - 1) this.log(`
+${separator()}
+`);
+        }
+        return;
+      }
+      const rows = releases.map((r, i) => {
+        const rel = r.rmsReleaseId ?? String(i);
+        const block = r.createdAtBlock ? String(r.createdAtBlock) : "-";
+        const created = r.createdAt ? formatHumanTime(r.createdAt) : "-";
+        const repo = formatRepoDisplay(r.build?.repoUrl ?? "-");
+        const commit = r.build?.gitRef ?? "-";
+        const digest = r.imageDigest ?? r.build?.imageDigest ?? "-";
+        const image = formatImageDisplay(r.build?.imageUrl ?? r.registryUrl ?? "-");
+        const build = r.build?.buildId ?? "-";
+        const prov = provenanceSummaryFromBuild(r.build);
+        const depCount = r.build?.dependencies ? Object.keys(r.build.dependencies).length : 0;
+        const deps = depCount > 0 ? `deps:${depCount}` : "-";
+        return { rel, block, created, repo, commit, digest, image, build, prov, deps };
+      });
+      const headers = {
+        rel: chalk2.bold("Rel"),
+        block: chalk2.bold("Block"),
+        created: chalk2.bold("Created"),
+        repo: chalk2.bold("Repo"),
+        commit: chalk2.bold("Commit"),
+        digest: chalk2.bold("Digest"),
+        image: chalk2.bold("Image"),
+        build: chalk2.bold("Build"),
+        prov: chalk2.bold("Prov"),
+        deps: chalk2.bold("Deps")
+      };
+      const tw = terminalWidth();
+      const shouldStack = tw < 140;
+      if (shouldStack) {
+        for (const r of rows) {
+          this.log(`${chalk2.cyan(r.rel)}  ${r.created}  (block ${r.block})`);
+          this.log(`  Repo:   ${r.repo}`);
+          this.log(`  Commit: ${r.commit}`);
+          this.log(`  Digest: ${r.digest}`);
+          this.log(`  Image:  ${r.image}`);
+          this.log(`  Build:  ${r.build}`);
+          this.log(`  Provenance: ${r.prov}`);
+          const relObj = releases.find((x, idx) => (x.rmsReleaseId ?? String(idx)) === r.rel);
+          const depLines = formatDepLines(relObj?.build?.dependencies);
+          if (depLines.length) {
+            for (const l of depLines) this.log(l);
+          }
+          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"));
+        }
+        this.log("");
+        this.log(
+          chalk2.gray(
+            `Tip: use ${chalk2.yellow("--full")} for detailed release output, ${chalk2.yellow(
+              "--json"
+            )} to copy/paste, and ${chalk2.yellow(
+              "ecloud compute build info <buildId>"
+            )} for full build/provenance details.`
+          )
+        );
+        return;
+      }
+      const fixed = 6 + 10 + 20 + 36 + 12 + 8 + 10;
+      const remaining = Math.max(60, tw - fixed);
+      const repoW = Math.max(18, Math.floor(remaining * 0.25));
+      const digestW = Math.max(18, Math.floor(remaining * 0.35));
+      const imageW = Math.max(18, remaining - repoW - digestW);
+      const table = new Table({
+        head: [
+          headers.rel,
+          headers.block,
+          headers.created,
+          headers.repo,
+          headers.commit,
+          headers.digest,
+          headers.image,
+          headers.build,
+          headers.prov,
+          headers.deps
+        ],
+        colWidths: [6, 10, 20, repoW, 10, digestW, imageW, 36, 12, 8],
+        wordWrap: true,
+        style: { "padding-left": 0, "padding-right": 1, head: [], border: [] }
+      });
+      for (const r of rows) {
+        table.push([
+          r.rel,
+          r.block,
+          r.created,
+          r.repo,
+          r.commit,
+          r.digest,
+          r.image,
+          r.build,
+          r.prov,
+          r.deps
+        ]);
+      }
+      this.log(table.toString());
+      this.log("");
+      this.log(
+        chalk2.gray(
+          `Tip: use ${chalk2.yellow("--full")} for detailed release output, ${chalk2.yellow(
+            "--json"
+          )} to copy/paste, and ${chalk2.yellow(
+            "ecloud compute build info <buildId>"
+          )} for full build/provenance details.`
+        )
+      );
+    });
+  }
+};
+export {
+  AppReleases as default
+};
+//# sourceMappingURL=releases.js.map