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

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

@@ -1,1081 +0,0 @@
-#!/usr/bin/env node
-
-// src/commands/compute/app/deploy.ts
-import { Command, Flags as Flags2 } from "@oclif/core";
-import {
-  getEnvironmentConfig as getEnvironmentConfig2,
-  UserApiClient as UserApiClient3,
-  isMainnet,
-  prepareDeploy,
-  executeDeploy,
-  watchDeployment
-} 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 invalidateProfileCache(environment) {
-  const config = loadGlobalConfig();
-  if (!config.profile_cache) {
-    return;
-  }
-  if (environment) {
-    delete config.profile_cache[environment];
-  } else {
-    config.profile_cache = {};
-  }
-  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;
-}
-function isAppNameAvailable(environment, name) {
-  const apps = listApps(environment);
-  return !apps[name];
-}
-function findAvailableName(environment, baseName) {
-  const apps = listApps(environment);
-  if (!apps[baseName]) {
-    return baseName;
-  }
-  for (let i = 2; i <= 100; i++) {
-    const candidate = `${baseName}-${i}`;
-    if (!apps[candidate]) {
-      return candidate;
-    }
-  }
-  return `${baseName}-${Date.now()}`;
-}
-
-// src/utils/prompts.ts
-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 getAvailableAppNameInteractive(environment, imageRef) {
-  const baseName = extractAppNameFromImage(imageRef);
-  const suggestedName = findAvailableName(environment, baseName);
-  while (true) {
-    console.log("\nApp name selection:");
-    const name = await input({
-      message: "Enter app name:",
-      default: suggestedName,
-      validate: (value) => {
-        try {
-          validateAppName(value);
-          return true;
-        } catch (err) {
-          return err.message;
-        }
-      }
-    });
-    if (isAppNameAvailable(environment, name)) {
-      return name;
-    }
-    console.log(`App name '${name}' is already taken.`);
-    const newSuggested = findAvailableName(environment, name);
-    console.log(`Suggested alternative: ${newSuggested}`);
-  }
-}
-async function getOrPromptAppName(appName, environment, imageRef) {
-  if (appName) {
-    validateAppName(appName);
-    if (isAppNameAvailable(environment, appName)) {
-      return appName;
-    }
-    console.log(`Warning: App name '${appName}' is already taken.`);
-    return getAvailableAppNameInteractive(environment, imageRef);
-  }
-  return getAvailableAppNameInteractive(environment, imageRef);
-}
-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}`);
-  }
-}
-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_DESCRIPTION_LENGTH = 1e3;
-var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
-var VALID_IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png"];
-var VALID_X_HOSTS = ["twitter.com", "www.twitter.com", "x.com", "www.x.com"];
-function validateURL(rawURL) {
-  if (!rawURL.trim()) {
-    return "URL cannot be empty";
-  }
-  try {
-    const url = new URL(rawURL);
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-      return "URL scheme must be http or https";
-    }
-  } catch {
-    return "Invalid URL format";
-  }
-  return void 0;
-}
-function validateXURL(rawURL) {
-  const urlErr = validateURL(rawURL);
-  if (urlErr) {
-    return urlErr;
-  }
-  try {
-    const url = new URL(rawURL);
-    const host = url.hostname.toLowerCase();
-    if (!VALID_X_HOSTS.includes(host)) {
-      return "URL must be a valid X/Twitter URL (x.com or twitter.com)";
-    }
-    if (!url.pathname || url.pathname === "/") {
-      return "X URL must include a username or profile path";
-    }
-  } catch {
-    return "Invalid X URL format";
-  }
-  return void 0;
-}
-function validateDescription(description) {
-  if (!description.trim()) {
-    return "Description cannot be empty";
-  }
-  if (description.length > MAX_DESCRIPTION_LENGTH) {
-    return `Description cannot exceed ${MAX_DESCRIPTION_LENGTH} characters`;
-  }
-  return void 0;
-}
-function validateImagePath(filePath) {
-  const cleanedPath = filePath.trim().replace(/^["']|["']$/g, "");
-  if (!cleanedPath) {
-    return "Image path cannot be empty";
-  }
-  if (!fs3.existsSync(cleanedPath)) {
-    return `Image file not found: ${cleanedPath}`;
-  }
-  const stats = fs3.statSync(cleanedPath);
-  if (stats.isDirectory()) {
-    return "Path is a directory, not a file";
-  }
-  if (stats.size > MAX_IMAGE_SIZE) {
-    const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
-    return `Image file size (${sizeMB} MB) exceeds maximum allowed size of 4 MB`;
-  }
-  const ext = path3.extname(cleanedPath).toLowerCase();
-  if (!VALID_IMAGE_EXTENSIONS.includes(ext)) {
-    return "Image must be JPG or PNG format";
-  }
-  return void 0;
-}
-async function getAppProfileInteractive(defaultName = "", allowRetry = true) {
-  while (true) {
-    const name = await getAppNameForProfile(defaultName);
-    const website = await getAppWebsiteInteractive();
-    const description = await getAppDescriptionInteractive();
-    const xURL = await getAppXURLInteractive();
-    const imagePath = await getAppImageInteractive();
-    const profile = {
-      name,
-      website,
-      description,
-      xURL,
-      imagePath
-    };
-    console.log("\n" + formatProfileForDisplay(profile));
-    const confirmed = await inquirerConfirm({
-      message: "Continue with this profile?",
-      default: true
-    });
-    if (confirmed) {
-      return profile;
-    }
-    if (!allowRetry) {
-      throw new Error("Profile confirmation cancelled");
-    }
-    const retry = await inquirerConfirm({
-      message: "Would you like to re-enter the information?",
-      default: true
-    });
-    if (!retry) {
-      return void 0;
-    }
-    defaultName = name;
-  }
-}
-async function getAppNameForProfile(defaultName) {
-  if (defaultName) {
-    validateAppName(defaultName);
-    return defaultName;
-  }
-  return await input({
-    message: "App name:",
-    default: "",
-    validate: (value) => {
-      if (!value.trim()) {
-        return "Name is required";
-      }
-      try {
-        validateAppName(value);
-        return true;
-      } catch (err) {
-        return err.message;
-      }
-    }
-  });
-}
-async function getAppWebsiteInteractive() {
-  const website = await input({
-    message: "Website URL (optional):",
-    default: "",
-    validate: (value) => {
-      if (!value.trim()) {
-        return true;
-      }
-      const err = validateURL(value);
-      return err ? err : true;
-    }
-  });
-  if (!website.trim()) {
-    return void 0;
-  }
-  return website;
-}
-async function getAppDescriptionInteractive() {
-  const description = await input({
-    message: "Description (optional):",
-    default: "",
-    validate: (value) => {
-      if (!value.trim()) {
-        return true;
-      }
-      const err = validateDescription(value);
-      return err ? err : true;
-    }
-  });
-  if (!description.trim()) {
-    return void 0;
-  }
-  return description;
-}
-async function getAppXURLInteractive() {
-  const xURL = await input({
-    message: "X (Twitter) URL (optional):",
-    default: "",
-    validate: (value) => {
-      if (!value.trim()) {
-        return true;
-      }
-      const err = validateXURL(value);
-      return err ? err : true;
-    }
-  });
-  if (!xURL.trim()) {
-    return void 0;
-  }
-  return xURL;
-}
-async function getAppImageInteractive() {
-  const wantsImage = await inquirerConfirm({
-    message: "Would you like to upload an app icon/logo?",
-    default: false
-  });
-  if (!wantsImage) {
-    return void 0;
-  }
-  const imagePath = await input({
-    message: "Image path (drag & drop image file or enter path - JPG/PNG, max 4MB, square recommended):",
-    default: "",
-    validate: (value) => {
-      if (!value.trim()) {
-        return true;
-      }
-      const err = validateImagePath(value);
-      return err ? err : true;
-    }
-  });
-  if (!imagePath.trim()) {
-    return void 0;
-  }
-  return imagePath.trim().replace(/^["']|["']$/g, "");
-}
-function formatProfileForDisplay(profile) {
-  let output = "\n\u{1F4CB} Profile Summary:\n";
-  output += `  Name:        ${profile.name}
-`;
-  if (profile.website) {
-    output += `  Website:     ${profile.website}
-`;
-  }
-  if (profile.description) {
-    output += `  Description: ${profile.description}
-`;
-  }
-  if (profile.xURL) {
-    output += `  X URL:       ${profile.xURL}
-`;
-  }
-  if (profile.imagePath) {
-    output += `  Image:       ${profile.imagePath}
-`;
-  }
-  return output;
-}
-
-// 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/deploy.ts
-import chalk from "chalk";
-var AppDeploy = class _AppDeploy extends Command {
-  static description = "Deploy new app";
-  static flags = {
-    ...commonFlags,
-    name: Flags2.string({
-      required: false,
-      description: "Friendly name for the app",
-      env: "ECLOUD_NAME"
-    }),
-    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"
-    }),
-    "skip-profile": Flags2.boolean({
-      required: false,
-      description: "Skip app profile setup",
-      default: false
-    }),
-    "resource-usage-monitoring": Flags2.string({
-      required: false,
-      description: "Resource usage monitoring: enable or disable",
-      options: ["enable", "disable"],
-      env: "ECLOUD_RESOURCE_USAGE_MONITORING"
-    }),
-    website: Flags2.string({
-      required: false,
-      description: "App website URL (optional)"
-    }),
-    description: Flags2.string({
-      required: false,
-      description: "App description (optional)"
-    }),
-    "x-url": Flags2.string({
-      required: false,
-      description: "X (Twitter) profile URL (optional)"
-    }),
-    image: Flags2.string({
-      required: false,
-      description: "Path to app icon/logo image - JPG/PNG, max 4MB, square recommended (optional)"
-    })
-  };
-  async run() {
-    const { flags } = await this.parse(_AppDeploy);
-    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 dockerfilePath = await getDockerfileInteractive(flags.dockerfile);
-    const buildFromDockerfile = dockerfilePath !== "";
-    const imageRef = await getImageReferenceInteractive(flags["image-ref"], buildFromDockerfile);
-    const appName = await getOrPromptAppName(flags.name, environment, imageRef);
-    const envFilePath = await getEnvFileInteractive(flags["env-file"]);
-    const availableTypes = await fetchAvailableInstanceTypes(environmentConfig, privateKey, rpcUrl);
-    const instanceType = await getInstanceTypeInteractive(
-      flags["instance-type"],
-      "",
-      // No default for new deployments
-      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 prepareDeploy(
-      {
-        privateKey,
-        rpcUrl,
-        environment,
-        dockerfilePath,
-        imageRef,
-        envFilePath,
-        appName,
-        instanceType,
-        logVisibility,
-        resourceUsageMonitoring
-      },
-      logger
-    );
-    this.log(`
-Estimated transaction cost: ${chalk.cyan(gasEstimate.maxCostEth)} ETH`);
-    if (isMainnet(environmentConfig)) {
-      const confirmed = await confirm(`Continue with deployment?`);
-      if (!confirmed) {
-        this.log(`
-${chalk.gray(`Deployment cancelled`)}`);
-        return;
-      }
-    }
-    const res = await executeDeploy(
-      prepared,
-      {
-        maxFeePerGas: gasEstimate.maxFeePerGas,
-        maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
-      },
-      logger
-    );
-    if (!flags["skip-profile"]) {
-      const hasProfileFlags = flags.website || flags.description || flags["x-url"] || flags.image;
-      let profile = null;
-      if (hasProfileFlags) {
-        profile = {
-          name: appName,
-          website: flags.website,
-          description: flags.description,
-          xURL: flags["x-url"],
-          imagePath: flags.image
-        };
-      } else {
-        this.log(
-          "\nDeployment confirmed onchain. While your instance provisions, set up a public profile:"
-        );
-        try {
-          profile = await getAppProfileInteractive(appName, true) || null;
-        } catch {
-          logger.debug("Profile collection skipped or cancelled");
-        }
-      }
-      if (profile) {
-        logger.info("Uploading app profile...");
-        try {
-          const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl);
-          await userApiClient.uploadAppProfile(
-            res.appId,
-            profile.name,
-            profile.website,
-            profile.description,
-            profile.xURL,
-            profile.imagePath
-          );
-          logger.info("\u2713 Profile uploaded successfully");
-          try {
-            invalidateProfileCache(environment);
-          } catch (cacheErr) {
-            logger.debug(`Failed to invalidate profile cache: ${cacheErr.message}`);
-          }
-        } catch (uploadErr) {
-          logger.warn(`Failed to upload profile: ${uploadErr.message}`);
-        }
-      }
-    }
-    const ipAddress = await watchDeployment(res.appId, privateKey, rpcUrl, environment, logger);
-    this.log(
-      `
-\u2705 ${chalk.green(`App deployed successfully ${chalk.bold(`(id: ${res.appId}, ip: ${ipAddress})`)}`)}`
-    );
-  }
-};
-async function fetchAvailableInstanceTypes(environmentConfig, privateKey, rpcUrl) {
-  try {
-    const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl);
-    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 {
-  AppDeploy as default
-};
-//# sourceMappingURL=deploy.js.map