@layr-labs/ecloud-cli 0.0.1-rfc.1 → 0.1.0-dev.1

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

@@ -0,0 +1,1072 @@
+#!/usr/bin/env node
+
+// src/commands/compute/app/upgrade.ts
+import { Command, Args, Flags as Flags2 } from "@oclif/core";
+import {
+  getEnvironmentConfig as getEnvironmentConfig2,
+  UserApiClient as UserApiClient3,
+  isMainnet,
+  prepareUpgrade,
+  executeUpgrade,
+  watchUpgrade
+} from "@layr-labs/ecloud-sdk";
+
+// 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";
+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 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);
+}
+
+// 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.1.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}`;
+}
+async function getDockerfileInteractive(dockerfilePath) {
+  if (dockerfilePath) {
+    return dockerfilePath;
+  }
+  const cwd = process.env.INIT_CWD || process.cwd();
+  const dockerfilePath_resolved = path3.join(cwd, "Dockerfile");
+  if (!fs3.existsSync(dockerfilePath_resolved)) {
+    return "";
+  }
+  console.log(`
+Found Dockerfile in ${cwd}`);
+  const choice = await select({
+    message: "Choose deployment method:",
+    choices: [
+      { name: "Build and deploy from Dockerfile", value: "build" },
+      { name: "Deploy existing image from registry", value: "existing" }
+    ]
+  });
+  switch (choice) {
+    case "build":
+      return dockerfilePath_resolved;
+    case "existing":
+      return "";
+    default:
+      throw new Error(`Unexpected choice: ${choice}`);
+  }
+}
+function extractHostname(registry) {
+  let hostname = registry.replace(/^https?:\/\//, "");
+  hostname = hostname.split("/")[0];
+  hostname = hostname.split(":")[0];
+  return hostname.toLowerCase();
+}
+function isDockerHub(registry) {
+  const hostname = extractHostname(registry);
+  return hostname === "docker.io" || hostname === "index.docker.io" || hostname === "registry-1.docker.io";
+}
+function isGHCR(registry) {
+  const hostname = extractHostname(registry);
+  return hostname === "ghcr.io";
+}
+function isGCR(registry) {
+  const hostname = extractHostname(registry);
+  return hostname === "gcr.io" || hostname.endsWith(".gcr.io");
+}
+async function getCredentialsFromHelper(registry) {
+  const dockerConfigPath = path3.join(os3.homedir(), ".docker", "config.json");
+  if (!fs3.existsSync(dockerConfigPath)) {
+    return void 0;
+  }
+  try {
+    const config = JSON.parse(fs3.readFileSync(dockerConfigPath, "utf-8"));
+    const credsStore = config.credsStore;
+    if (!credsStore) {
+      return void 0;
+    }
+    const { execSync } = await import("child_process");
+    const helper = `docker-credential-${credsStore}`;
+    try {
+      const registryVariants = [];
+      if (isDockerHub(registry)) {
+        registryVariants.push("https://index.docker.io/v1/");
+        registryVariants.push("https://index.docker.io/v1");
+        registryVariants.push("index.docker.io");
+        registryVariants.push("docker.io");
+      } else {
+        const baseRegistry = registry.replace(/^https?:\/\//, "").replace(/\/v1\/?$/, "").replace(/\/$/, "");
+        registryVariants.push(`https://${baseRegistry}`);
+        registryVariants.push(`https://${baseRegistry}/v1/`);
+        registryVariants.push(baseRegistry);
+      }
+      for (const variant of registryVariants) {
+        try {
+          const output = execSync(`echo "${variant}" | ${helper} get`, {
+            encoding: "utf-8"
+          });
+          const creds = JSON.parse(output);
+          if (creds.Username && creds.Secret) {
+            return { username: creds.Username, password: creds.Secret };
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      return void 0;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+async function getAvailableRegistries() {
+  const dockerConfigPath = path3.join(os3.homedir(), ".docker", "config.json");
+  if (!fs3.existsSync(dockerConfigPath)) {
+    return [];
+  }
+  try {
+    const configContent = fs3.readFileSync(dockerConfigPath, "utf-8");
+    const config = JSON.parse(configContent);
+    const auths = config.auths || {};
+    const credsStore = config.credsStore;
+    const gcrProjects = /* @__PURE__ */ new Map();
+    const registries = [];
+    for (const [registry, auth] of Object.entries(auths)) {
+      const authData = auth;
+      const hostname = extractHostname(registry);
+      if (hostname.includes("access-token") || hostname.includes("refresh-token")) {
+        continue;
+      }
+      let username = authData.username;
+      let registryType = "other";
+      let normalizedURL = registry;
+      if (isDockerHub(registry)) {
+        registryType = "dockerhub";
+        normalizedURL = "https://index.docker.io/v1/";
+      } else if (isGHCR(registry)) {
+        registryType = "ghcr";
+        normalizedURL = registry.replace(/^https?:\/\//, "").replace(/\/v1\/?$/, "");
+      } else if (isGCR(registry)) {
+        registryType = "gcr";
+        normalizedURL = "gcr.io";
+      }
+      if (!username && credsStore) {
+        const creds = await getCredentialsFromHelper(registry);
+        if (creds) {
+          username = creds.username;
+        }
+      }
+      if (!username) {
+        continue;
+      }
+      const info = {
+        URL: normalizedURL,
+        Username: username,
+        Type: registryType
+      };
+      if (registryType === "gcr") {
+        if (!gcrProjects.has(username)) {
+          gcrProjects.set(username, info);
+        }
+        continue;
+      }
+      registries.push(info);
+    }
+    for (const gcrInfo of Array.from(gcrProjects.values())) {
+      registries.push(gcrInfo);
+    }
+    registries.sort((a, b) => {
+      if (a.Type === "dockerhub") return -1;
+      if (b.Type === "dockerhub") return 1;
+      return a.Type.localeCompare(b.Type);
+    });
+    return registries;
+  } catch {
+    return [];
+  }
+}
+function getDefaultAppName() {
+  try {
+    const cwd = process.env.INIT_CWD || process.cwd();
+    return path3.basename(cwd);
+  } catch {
+    return "myapp";
+  }
+}
+function suggestImageReference(registry, imageName, tag) {
+  imageName = imageName.toLowerCase().replace(/_/g, "-");
+  if (!tag) {
+    tag = "latest";
+  }
+  switch (registry.Type) {
+    case "dockerhub":
+      return `${registry.Username}/${imageName}:${tag}`;
+    case "ghcr":
+      return `ghcr.io/${registry.Username}/${imageName}:${tag}`;
+    case "gcr":
+      return `gcr.io/${registry.Username}/${imageName}:${tag}`;
+    default:
+      let host = registry.URL;
+      if (host.startsWith("https://")) {
+        host = host.substring(8);
+      } else if (host.startsWith("http://")) {
+        host = host.substring(7);
+      }
+      host = host.replace(/\/$/, "");
+      return `${host}/${registry.Username}/${imageName}:${tag}`;
+  }
+}
+function displayDetectedRegistries(registries, appName) {
+  console.log("Detected authenticated registries:");
+  for (const reg of registries) {
+    const suggestion = suggestImageReference(reg, appName, "latest");
+    console.log(`  ${reg.Type}: ${suggestion}`);
+  }
+  console.log();
+}
+function displayAuthenticationInstructions() {
+  console.log("No authenticated registries detected.");
+  console.log("To authenticate:");
+  console.log("  docker login <registry-url>");
+  console.log();
+}
+function displayRegistryExamples(appName) {
+  console.log("Examples:");
+  console.log(`  docker.io/${appName.toLowerCase()}:latest`);
+  console.log(`  ghcr.io/username/${appName.toLowerCase()}:latest`);
+  console.log(`  gcr.io/project-id/${appName.toLowerCase()}:latest`);
+  console.log();
+}
+async function selectRegistryInteractive(registries, imageName, tag) {
+  if (registries.length === 1) {
+    const defaultRef = suggestImageReference(registries[0], imageName, tag);
+    return input({
+      message: "Enter image reference:",
+      default: defaultRef,
+      validate: (value) => {
+        const result = validateImageReference(value);
+        return result === true ? true : result;
+      }
+    });
+  }
+  const choices = registries.map((reg) => ({
+    name: suggestImageReference(reg, imageName, tag),
+    value: suggestImageReference(reg, imageName, tag)
+  }));
+  choices.push({ name: "Enter custom image reference", value: "custom" });
+  const choice = await select({
+    message: "Select image destination:",
+    choices
+  });
+  if (choice === "custom") {
+    return input({
+      message: "Enter image reference:",
+      default: "",
+      validate: (value) => {
+        const result = validateImageReference(value);
+        return result === true ? true : result;
+      }
+    });
+  }
+  return choice;
+}
+async function getImageReferenceInteractive(imageRef, buildFromDockerfile = false) {
+  if (imageRef) {
+    return imageRef;
+  }
+  const registries = await getAvailableRegistries();
+  const appName = getDefaultAppName();
+  if (buildFromDockerfile) {
+    console.log("\n\u{1F4E6} Build & Push Configuration");
+    console.log("Your Docker image will be built and pushed to a registry");
+    console.log("so that EigenX can pull and run it in the TEE.");
+    console.log();
+    if (registries.length > 0) {
+      displayDetectedRegistries(registries, appName);
+      return selectRegistryInteractive(registries, appName, "latest");
+    }
+    displayAuthenticationInstructions();
+  } else {
+    console.log("\n\u{1F433} Docker Image Selection");
+    console.log("Specify an existing Docker image from a registry to run in the TEE.");
+    console.log();
+  }
+  displayRegistryExamples(appName);
+  const imageRefInput = await input({
+    message: "Enter Docker image reference:",
+    default: "",
+    validate: (value) => {
+      const result = validateImageReference(value);
+      return result === true ? true : result;
+    }
+  });
+  return imageRefInput;
+}
+async function getEnvFileInteractive(envFilePath) {
+  if (envFilePath && fs3.existsSync(envFilePath)) {
+    return envFilePath;
+  }
+  if (fs3.existsSync(".env")) {
+    return ".env";
+  }
+  console.log("\nEnvironment file not found.");
+  console.log("Environment files contain variables like RPC_URL, etc.");
+  const choice = await select({
+    message: "Choose an option:",
+    choices: [
+      { name: "Enter path to existing env file", value: "enter" },
+      { name: "Continue without env file", value: "continue" }
+    ]
+  });
+  switch (choice) {
+    case "enter":
+      const envFile = await input({
+        message: "Enter environment file path:",
+        default: "",
+        validate: (value) => {
+          const result = validateFilePath(value);
+          return result === true ? true : result;
+        }
+      });
+      return envFile;
+    case "continue":
+      return "";
+    default:
+      throw new Error(`Unexpected choice: ${choice}`);
+  }
+}
+async function getInstanceTypeInteractive(instanceType, defaultSKU, availableTypes) {
+  if (instanceType) {
+    const valid = availableTypes.find((t) => t.sku === instanceType);
+    if (valid) {
+      return instanceType;
+    }
+    const validSKUs = availableTypes.map((t) => t.sku).join(", ");
+    throw new Error(`Invalid instance-type: ${instanceType} (must be one of: ${validSKUs})`);
+  }
+  const isCurrentType = defaultSKU !== "";
+  if (defaultSKU === "" && availableTypes.length > 0) {
+    defaultSKU = availableTypes[0].sku;
+  }
+  if (isCurrentType && defaultSKU) {
+    console.log(`
+Select instance type (current: ${defaultSKU}):`);
+  } else {
+    console.log("\nSelect instance type:");
+  }
+  const choices = availableTypes.map((it) => {
+    let name = `${it.sku} - ${it.description}`;
+    if (it.sku === defaultSKU) {
+      name += isCurrentType ? " (current)" : " (default)";
+    }
+    return { name, value: it.sku };
+  });
+  const choice = await select({
+    message: "Choose instance:",
+    choices
+  });
+  return choice;
+}
+async function getLogSettingsInteractive(logVisibility) {
+  if (logVisibility) {
+    switch (logVisibility) {
+      case "public":
+        return { logRedirect: "always", publicLogs: true };
+      case "private":
+        return { logRedirect: "always", publicLogs: false };
+      case "off":
+        return { logRedirect: "", publicLogs: false };
+      default:
+        throw new Error(
+          `Invalid log-visibility: ${logVisibility} (must be public, private, or off)`
+        );
+    }
+  }
+  const choice = await select({
+    message: "Do you want to view your app's logs?",
+    choices: [
+      { name: "Yes, but only viewable by app and platform admins", value: "private" },
+      { name: "Yes, publicly viewable by anyone", value: "public" },
+      { name: "No, disable logs entirely", value: "off" }
+    ]
+  });
+  switch (choice) {
+    case "private":
+      return { logRedirect: "always", publicLogs: false };
+    case "public":
+      return { logRedirect: "always", publicLogs: true };
+    case "off":
+      return { logRedirect: "", publicLogs: false };
+    default:
+      throw new Error(`Unexpected choice: ${choice}`);
+  }
+}
+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 "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
+    });
+  }
+  appItems.sort((a, b) => {
+    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 choices = Object.entries(allApps).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 getResourceUsageMonitoringInteractive(resourceUsageMonitoring) {
+  if (resourceUsageMonitoring) {
+    switch (resourceUsageMonitoring) {
+      case "enable":
+      case "disable":
+        return resourceUsageMonitoring;
+      default:
+        throw new Error(
+          `Invalid resource-usage-monitoring: ${resourceUsageMonitoring} (must be enable or disable)`
+        );
+    }
+  }
+  const choice = await select({
+    message: "Show resource usage (CPU/memory) for your app?",
+    choices: [
+      { name: "Yes, enable resource usage monitoring", value: "enable" },
+      { name: "No, disable resource usage monitoring", value: "disable" }
+    ]
+  });
+  return choice;
+}
+async function confirm(prompt) {
+  return confirmWithDefault(prompt, false);
+}
+async function confirmWithDefault(prompt, defaultValue = false) {
+  return await inquirerConfirm({
+    message: prompt,
+    default: defaultValue
+  });
+}
+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();
+}
+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
+  })
+};
+
+// src/commands/compute/app/upgrade.ts
+import chalk from "chalk";
+var AppUpgrade = class _AppUpgrade extends Command {
+  static description = "Upgrade existing deployment";
+  static args = {
+    "app-id": Args.string({
+      description: "App ID or name to upgrade",
+      required: false
+    })
+  };
+  static flags = {
+    ...commonFlags,
+    dockerfile: Flags2.string({
+      required: false,
+      description: "Path to Dockerfile",
+      env: "ECLOUD_DOCKERFILE_PATH"
+    }),
+    "image-ref": Flags2.string({
+      required: false,
+      description: "Image reference pointing to registry",
+      env: "ECLOUD_IMAGE_REF"
+    }),
+    "env-file": Flags2.string({
+      required: false,
+      description: 'Environment file to use (default: ".env")',
+      default: ".env",
+      env: "ECLOUD_ENVFILE_PATH"
+    }),
+    "log-visibility": Flags2.string({
+      required: false,
+      description: "Log visibility setting: public, private, or off",
+      options: ["public", "private", "off"],
+      env: "ECLOUD_LOG_VISIBILITY"
+    }),
+    "instance-type": Flags2.string({
+      required: false,
+      description: "Machine instance type to use e.g. g1-standard-4t, g1-standard-8t",
+      env: "ECLOUD_INSTANCE_TYPE"
+    }),
+    "resource-usage-monitoring": Flags2.string({
+      required: false,
+      description: "Resource usage monitoring: enable or disable",
+      options: ["enable", "disable"],
+      env: "ECLOUD_RESOURCE_USAGE_MONITORING"
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_AppUpgrade);
+    const logger = {
+      info: (msg) => this.log(msg),
+      warn: (msg) => this.warn(msg),
+      error: (msg) => this.error(msg),
+      debug: (msg) => flags.verbose && this.log(msg)
+    };
+    const environment = flags.environment || "sepolia";
+    const environmentConfig = getEnvironmentConfig2(environment);
+    const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
+    const privateKey = await getPrivateKeyInteractive(flags["private-key"]);
+    const appID = await getOrPromptAppID({
+      appID: args["app-id"],
+      environment,
+      privateKey,
+      rpcUrl,
+      action: "upgrade"
+    });
+    const dockerfilePath = await getDockerfileInteractive(flags.dockerfile);
+    const buildFromDockerfile = dockerfilePath !== "";
+    const imageRef = await getImageReferenceInteractive(flags["image-ref"], buildFromDockerfile);
+    const envFilePath = await getEnvFileInteractive(flags["env-file"]);
+    let currentInstanceType = "";
+    try {
+      const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl, getClientId());
+      const infos = await userApiClient.getInfos([appID], 1);
+      if (infos.length > 0) {
+        currentInstanceType = infos[0].machineType || "";
+      }
+    } catch {
+    }
+    const availableTypes = await fetchAvailableInstanceTypes(environmentConfig, privateKey, rpcUrl);
+    const instanceType = await getInstanceTypeInteractive(
+      flags["instance-type"],
+      currentInstanceType,
+      availableTypes
+    );
+    const logSettings = await getLogSettingsInteractive(
+      flags["log-visibility"]
+    );
+    const resourceUsageMonitoring = await getResourceUsageMonitoringInteractive(
+      flags["resource-usage-monitoring"]
+    );
+    const logVisibility = logSettings.publicLogs ? "public" : logSettings.logRedirect ? "private" : "off";
+    const { prepared, gasEstimate } = await prepareUpgrade(
+      {
+        appId: appID,
+        privateKey,
+        rpcUrl,
+        environment,
+        dockerfilePath,
+        imageRef,
+        envFilePath,
+        instanceType,
+        logVisibility,
+        resourceUsageMonitoring
+      },
+      logger
+    );
+    this.log(`
+Estimated transaction cost: ${chalk.cyan(gasEstimate.maxCostEth)} ETH`);
+    if (isMainnet(environmentConfig)) {
+      const confirmed = await confirm(`Continue with upgrade?`);
+      if (!confirmed) {
+        this.log(`
+${chalk.gray(`Upgrade cancelled`)}`);
+        return;
+      }
+    }
+    const res = await executeUpgrade(
+      prepared,
+      {
+        maxFeePerGas: gasEstimate.maxFeePerGas,
+        maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
+      },
+      logger
+    );
+    await watchUpgrade(res.appId, privateKey, rpcUrl, environment, logger, getClientId());
+    this.log(
+      `
+\u2705 ${chalk.green(`App upgraded successfully ${chalk.bold(`(id: ${res.appId}, image: ${res.imageRef})`)}`)}`
+    );
+  }
+};
+async function fetchAvailableInstanceTypes(environmentConfig, privateKey, rpcUrl) {
+  try {
+    const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl, getClientId());
+    const skuList = await userApiClient.getSKUs();
+    if (skuList.skus.length === 0) {
+      throw new Error("No instance types available from server");
+    }
+    return skuList.skus;
+  } catch (err) {
+    console.warn(`Failed to fetch instance types: ${err.message}`);
+    return [{ sku: "g1-standard-4t", description: "Standard 4-thread instance" }];
+  }
+}
+export {
+  AppUpgrade as default
+};
+//# sourceMappingURL=upgrade.js.map