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

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

@@ -0,0 +1,675 @@
+#!/usr/bin/env node
+
+// src/commands/compute/app/start.ts
+import { Command, Args } from "@oclif/core";
+
+// src/client.ts
+import {
+  createAppModule,
+  createBillingModule,
+  getEnvironmentConfig as getEnvironmentConfig2,
+  requirePrivateKey,
+  getPrivateKeyWithSource
+} 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 getDefaultEnvironment() {
+  const config = loadGlobalConfig();
+  return config.default_environment;
+}
+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" : "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}`;
+}
+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 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: getPrivateKeyWithSource2 } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource2({ privateKey: void 0 });
+  if (result) {
+    return result.key;
+  }
+  const key = await password({
+    message: "Enter private key:",
+    mask: true,
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Private key is required";
+      }
+      if (!validatePrivateKeyFormat(value)) {
+        return "Invalid private key format (must be 64 hex characters, optionally prefixed with 0x)";
+      }
+      return true;
+    }
+  });
+  return key.trim();
+}
+async function getEnvironmentInteractive(environment) {
+  if (environment) {
+    try {
+      getEnvironmentConfig(environment);
+      if (!isEnvironmentAvailable(environment)) {
+        throw new Error(`Environment ${environment} is not available in this build`);
+      }
+      return environment;
+    } catch {
+    }
+  }
+  const availableEnvs = getAvailableEnvironments();
+  let defaultEnv;
+  const configDefaultEnv = getDefaultEnvironment();
+  if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
+    try {
+      getEnvironmentConfig(configDefaultEnv);
+      defaultEnv = configDefaultEnv;
+    } catch {
+    }
+  }
+  const choices = [];
+  if (availableEnvs.includes("sepolia")) {
+    choices.push({ name: "sepolia - Ethereum Sepolia testnet", value: "sepolia" });
+  }
+  if (availableEnvs.includes("sepolia-dev")) {
+    choices.push({ name: "sepolia-dev - Ethereum Sepolia testnet (dev)", value: "sepolia-dev" });
+  }
+  if (availableEnvs.includes("mainnet-alpha")) {
+    choices.push({
+      name: "mainnet-alpha - Ethereum mainnet (\u26A0\uFE0F  uses real funds)",
+      value: "mainnet-alpha"
+    });
+  }
+  if (choices.length === 0) {
+    throw new Error("No environments available in this build");
+  }
+  const env = await select({
+    message: "Select environment:",
+    choices,
+    default: defaultEnv
+  });
+  return env;
+}
+var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
+
+// src/flags.ts
+var commonFlags = {
+  environment: Flags.string({
+    required: false,
+    description: "Deployment environment to use",
+    env: "ECLOUD_ENV"
+  }),
+  "private-key": Flags.string({
+    required: false,
+    description: "Private key for signing transactions",
+    env: "ECLOUD_PRIVATE_KEY"
+  }),
+  "rpc-url": Flags.string({
+    required: false,
+    description: "RPC URL to connect to blockchain",
+    env: "ECLOUD_RPC_URL"
+  }),
+  verbose: Flags.boolean({
+    required: false,
+    description: "Enable verbose logging (default: false)",
+    default: false
+  })
+};
+async function validateCommonFlags(flags) {
+  if (!flags["environment"]) {
+    flags["environment"] = getDefaultEnvironment();
+  }
+  flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
+  flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
+  return flags;
+}
+
+// src/client.ts
+async function createAppClient(flags) {
+  flags = await validateCommonFlags(flags);
+  const environment = flags.environment;
+  const environmentConfig = getEnvironmentConfig2(environment);
+  const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
+  const { key: privateKey, source } = await requirePrivateKey({
+    privateKey: flags["private-key"]
+  });
+  if (flags.verbose) {
+    console.log(`Using private key from: ${source}`);
+  }
+  return createAppModule({
+    verbose: flags.verbose,
+    privateKey,
+    rpcUrl,
+    environment,
+    clientId: getClientId()
+  });
+}
+
+// src/commands/compute/app/start.ts
+import {
+  getEnvironmentConfig as getEnvironmentConfig3,
+  estimateTransactionGas,
+  encodeStartAppData,
+  isMainnet
+} from "@layr-labs/ecloud-sdk";
+import chalk from "chalk";
+var AppLifecycleStart = class _AppLifecycleStart extends Command {
+  static description = "Start stopped app (start GCP instance)";
+  static args = {
+    "app-id": Args.string({
+      description: "App ID or name to start",
+      required: false
+    })
+  };
+  static flags = {
+    ...commonFlags
+  };
+  async run() {
+    const { args, flags } = await this.parse(_AppLifecycleStart);
+    const app = await createAppClient(flags);
+    const environment = flags.environment || "sepolia";
+    const environmentConfig = getEnvironmentConfig3(environment);
+    const rpcUrl = flags.rpcUrl || environmentConfig.defaultRPCURL;
+    const privateKey = flags["private-key"] || await getPrivateKeyInteractive(environment);
+    const appId = await getOrPromptAppID({
+      appID: args["app-id"],
+      environment: flags["environment"],
+      privateKey,
+      rpcUrl,
+      action: "start"
+    });
+    const callData = encodeStartAppData(appId);
+    const estimate = await estimateTransactionGas({
+      privateKey,
+      rpcUrl,
+      environmentConfig,
+      to: environmentConfig.appControllerAddress,
+      data: callData
+    });
+    if (isMainnet(environmentConfig)) {
+      const confirmed = await confirm(`This will cost up to ${estimate.maxCostEth} ETH. Continue?`);
+      if (!confirmed) {
+        this.log(`
+${chalk.gray(`Start cancelled`)}`);
+        return;
+      }
+    }
+    const res = await app.start(appId, {
+      gas: {
+        maxFeePerGas: estimate.maxFeePerGas,
+        maxPriorityFeePerGas: estimate.maxPriorityFeePerGas
+      }
+    });
+    if (!res.tx) {
+      this.log(`
+${chalk.gray(`Start failed`)}`);
+    } else {
+      this.log(`
+\u2705 ${chalk.green(`App started successfully`)}`);
+    }
+  }
+};
+export {
+  AppLifecycleStart as default
+};
+//# sourceMappingURL=start.js.map