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

package/dist/commands/compute/app/profile/set.js

@@ -1,1072 +0,0 @@
-#!/usr/bin/env node
-
-// src/commands/compute/app/profile/set.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";
-
-// 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);
-}
-function invalidateProfileCache(environment) {
-  const config = loadGlobalConfig();
-  if (!config.profile_cache) {
-    return;
-  }
-  if (environment) {
-    delete config.profile_cache[environment];
-  } else {
-    config.profile_cache = {};
-  }
-  saveGlobalConfig(config);
-}
-function updateProfileCacheEntry(environment, appId, profileName) {
-  const config = loadGlobalConfig();
-  if (!config.profile_cache) {
-    config.profile_cache = {};
-  }
-  if (!config.profile_cache[environment]) {
-    config.profile_cache[environment] = {
-      updated_at: Date.now(),
-      profiles: {}
-    };
-  }
-  const normalizedAppId = appId.toLowerCase();
-  config.profile_cache[environment].profiles[normalizedAppId] = profileName;
-  config.profile_cache[environment].updated_at = Date.now();
-  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 resolveAppIDFromRegistry(environment, appIDOrName) {
-  if (/^0x[a-fA-F0-9]{40}$/.test(appIDOrName)) {
-    return appIDOrName;
-  }
-  const registry = loadAppRegistry(environment);
-  const app = registry.apps[appIDOrName];
-  if (app) {
-    return app.app_id;
-  }
-  return null;
-}
-function getAppName(environment, appID) {
-  const registry = loadAppRegistry(environment);
-  const normalizedAppID = appID.toLowerCase();
-  for (const [name, app] of Object.entries(registry.apps)) {
-    if (app?.app_id && String(app.app_id).toLowerCase() === normalizedAppID) {
-      return name;
-    }
-  }
-  return "";
-}
-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/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();
-}
-var AppResolver = class {
-  constructor(environment, environmentConfig, privateKey, rpcUrl) {
-    this.environment = environment;
-    this.environmentConfig = environmentConfig;
-    this.privateKey = privateKey;
-    this.rpcUrl = rpcUrl;
-  }
-  profileNames = {};
-  // appId (lowercase) -> name
-  cacheInitialized = false;
-  /**
-   * Resolve app name or ID to a valid Address
-   * @param appIDOrName - App ID (hex address) or app name
-   * @returns Resolved app address
-   * @throws Error if app cannot be resolved
-   */
-  async resolveAppID(appIDOrName) {
-    if (!appIDOrName) {
-      throw new Error("App ID or name is required");
-    }
-    const normalized = appIDOrName.startsWith("0x") ? appIDOrName : `0x${appIDOrName}`;
-    if (isAddress(normalized)) {
-      return normalized;
-    }
-    await this.ensureCacheInitialized();
-    const searchName = appIDOrName.toLowerCase();
-    for (const [appId, name] of Object.entries(this.profileNames)) {
-      if (name.toLowerCase() === searchName) {
-        return appId;
-      }
-    }
-    const localAppId = resolveAppIDFromRegistry(this.environment, appIDOrName);
-    if (localAppId) {
-      return localAppId;
-    }
-    throw new Error(`App '${appIDOrName}' not found in environment '${this.environment}'`);
-  }
-  /**
-   * Get app name from app ID
-   * @param appID - App address
-   * @returns Profile name if found, empty string otherwise
-   */
-  async getAppName(appID) {
-    const normalizedId = String(appID).toLowerCase();
-    await this.ensureCacheInitialized();
-    const profileName = this.profileNames[normalizedId];
-    if (profileName) {
-      return profileName;
-    }
-    return getAppName(this.environment, appID);
-  }
-  /**
-   * Check if an app name is available (not used by any existing app)
-   * @param name - Name to check
-   * @returns true if available, false if taken
-   */
-  async isAppNameAvailable(name) {
-    await this.ensureCacheInitialized();
-    const searchName = name.toLowerCase();
-    for (const profileName of Object.values(this.profileNames)) {
-      if (profileName.toLowerCase() === searchName) {
-        return false;
-      }
-    }
-    const localApps = listApps(this.environment);
-    return !localApps[name];
-  }
-  /**
-   * Find an available app name by appending numbers if needed
-   * @param baseName - Base name to start with
-   * @returns Available name (may have number suffix)
-   */
-  async findAvailableName(baseName) {
-    if (await this.isAppNameAvailable(baseName)) {
-      return baseName;
-    }
-    for (let i = 2; i <= 100; i++) {
-      const candidate = `${baseName}-${i}`;
-      if (await this.isAppNameAvailable(candidate)) {
-        return candidate;
-      }
-    }
-    return `${baseName}-${Date.now()}`;
-  }
-  /**
-   * Get all profile names (for display/listing purposes)
-   * @returns Map of appId -> name
-   */
-  async getAllProfileNames() {
-    await this.ensureCacheInitialized();
-    return { ...this.profileNames };
-  }
-  /**
-   * Update cache with a new profile name (call after deploy or profile set)
-   */
-  updateCacheEntry(appId, profileName) {
-    const normalizedId = appId.toLowerCase();
-    this.profileNames[normalizedId] = profileName;
-    updateProfileCacheEntry(this.environment, appId, profileName);
-  }
-  /**
-   * Ensure the profile cache is initialized
-   * Loads from disk cache if valid, otherwise fetches from API
-   */
-  async ensureCacheInitialized() {
-    if (this.cacheInitialized) {
-      return;
-    }
-    const cachedProfiles = getProfileCache(this.environment);
-    if (cachedProfiles) {
-      this.profileNames = cachedProfiles;
-      this.cacheInitialized = true;
-      return;
-    }
-    await this.fetchProfilesFromAPI();
-    this.cacheInitialized = true;
-  }
-  /**
-   * Fetch profile names from the remote API and update cache
-   */
-  async fetchProfilesFromAPI() {
-    if (!this.privateKey || !this.rpcUrl) {
-      this.profileNames = {};
-      return;
-    }
-    try {
-      const account = privateKeyToAccount(this.privateKey);
-      const { apps } = await getAllAppsByDeveloper(
-        this.rpcUrl,
-        this.environmentConfig,
-        account.address
-      );
-      if (apps.length === 0) {
-        this.profileNames = {};
-        setProfileCache(this.environment, {});
-        return;
-      }
-      const userApiClient = new UserApiClient(this.environmentConfig, this.privateKey, this.rpcUrl);
-      const appInfos = await getAppInfosChunked(userApiClient, apps);
-      const profiles = {};
-      for (const info of appInfos) {
-        if (info.profile?.name) {
-          const normalizedId = String(info.address).toLowerCase();
-          profiles[normalizedId] = info.profile.name;
-        }
-      }
-      this.profileNames = profiles;
-      setProfileCache(this.environment, profiles);
-    } catch (error) {
-      console.debug?.("Failed to fetch profiles from API:", error);
-      this.profileNames = {};
-    }
-  }
-};
-function createAppResolver(environment, environmentConfig, privateKey, rpcUrl) {
-  return new AppResolver(environment, environmentConfig, privateKey, rpcUrl);
-}
-
-// src/utils/prompts.ts
-function addHexPrefix(value) {
-  if (value.startsWith("0x")) {
-    return value;
-  }
-  return `0x${value}`;
-}
-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
-      );
-      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 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;
-}
-function validateAppProfile(profile) {
-  if (!profile.name || !profile.name.trim()) {
-    return "Profile name is required";
-  }
-  try {
-    validateAppName(profile.name);
-  } catch (err) {
-    return `Invalid profile name: ${err.message}`;
-  }
-  if (profile.website) {
-    const websiteErr = validateURL(profile.website);
-    if (websiteErr) {
-      return `Invalid website: ${websiteErr}`;
-    }
-  }
-  if (profile.description) {
-    const descErr = validateDescription(profile.description);
-    if (descErr) {
-      return `Invalid description: ${descErr}`;
-    }
-  }
-  if (profile.xURL) {
-    const xURLErr = validateXURL(profile.xURL);
-    if (xURLErr) {
-      return `Invalid X URL: ${xURLErr}`;
-    }
-  }
-  if (profile.imagePath) {
-    const imageErr = validateImagePath(profile.imagePath);
-    if (imageErr) {
-      return `Invalid image: ${imageErr}`;
-    }
-  }
-  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/profile/set.ts
-import chalk from "chalk";
-var ProfileSet = class _ProfileSet extends Command {
-  static description = "Set public profile information for an app";
-  static args = {
-    "app-id": Args.string({
-      description: "App ID or name to set profile for",
-      required: false
-    })
-  };
-  static flags = {
-    ...commonFlags,
-    name: Flags2.string({
-      description: "Profile name for the app",
-      required: false
-    }),
-    website: Flags2.string({
-      description: "Website URL",
-      required: false
-    }),
-    description: Flags2.string({
-      description: "App description",
-      required: false
-    }),
-    "x-url": Flags2.string({
-      description: "X (Twitter) URL",
-      required: false
-    }),
-    image: Flags2.string({
-      description: "Path to profile image (JPG/PNG, max 4MB)",
-      required: false
-    })
-  };
-  async run() {
-    const { args, flags } = await this.parse(_ProfileSet);
-    const environment = flags.environment || "sepolia";
-    const environmentConfig = getEnvironmentConfig2(environment);
-    const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
-    const privateKey = await getPrivateKeyInteractive(flags["private-key"]);
-    const resolver = createAppResolver(environment, environmentConfig, privateKey, rpcUrl);
-    const appId = await getOrPromptAppID({
-      appID: args["app-id"],
-      environment,
-      privateKey,
-      rpcUrl,
-      action: "set profile for"
-    });
-    this.log(`
-Setting profile for app: ${chalk.cyan(appId)}`);
-    let profile;
-    if (flags.name) {
-      profile = {
-        name: flags.name,
-        website: flags.website,
-        description: flags.description,
-        xURL: flags["x-url"],
-        imagePath: flags.image
-      };
-      const validationError = validateAppProfile(profile);
-      if (validationError) {
-        this.error(validationError);
-      }
-      this.log("\n\u{1F4CB} Profile Summary:");
-      this.log(`  Name:        ${profile.name}`);
-      if (profile.website) this.log(`  Website:     ${profile.website}`);
-      if (profile.description) this.log(`  Description: ${profile.description}`);
-      if (profile.xURL) this.log(`  X URL:       ${profile.xURL}`);
-      if (profile.imagePath) this.log(`  Image:       ${profile.imagePath}`);
-    } else {
-      this.log("\nEnter profile information:");
-      profile = await getAppProfileInteractive("", true);
-      if (!profile) {
-        this.log(`
-${chalk.gray("Profile setup cancelled")}`);
-        return;
-      }
-    }
-    this.log("\nUploading app profile...");
-    const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl);
-    try {
-      const response = await userApiClient.uploadAppProfile(
-        appId,
-        profile.name,
-        profile.website,
-        profile.description,
-        profile.xURL,
-        profile.imagePath
-      );
-      resolver.updateCacheEntry(appId, response.name);
-      invalidateProfileCache(environment);
-      this.log(`
-\u2705 ${chalk.green(`Profile updated successfully for app '${response.name}'`)}`);
-      this.log("\nUploaded Profile:");
-      this.log(`  Name:        ${response.name}`);
-      if (response.website) this.log(`  Website:     ${response.website}`);
-      if (response.description) this.log(`  Description: ${response.description}`);
-      if (response.xURL) this.log(`  X URL:       ${response.xURL}`);
-      if (response.imageURL) this.log(`  Image URL:   ${response.imageURL}`);
-    } catch (error) {
-      this.error(`Failed to upload profile: ${error.message}`);
-    }
-  }
-};
-export {
-  ProfileSet as default
-};
-//# sourceMappingURL=set.js.map