@layr-labs/ecloud-cli 0.1.1 → 0.1.2

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

@@ -2,14 +2,7 @@
 
 // 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";
+import { getEnvironmentConfig as getEnvironmentConfig3, isMainnet, UserApiClient as UserApiClient3 } from "@layr-labs/ecloud-sdk";
 
 // src/telemetry.ts
 import {
@@ -71,6 +64,42 @@ function saveGlobalConfig(config) {
   const content = dumpYaml(config, { lineWidth: -1 });
   fs.writeFileSync(configPath, content, { mode: 420 });
 }
+function normalizeDirectoryPath(directoryPath) {
+  const resolved = path.resolve(directoryPath);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function getLinkedAppForDirectory(environment, directoryPath) {
+  if (!directoryPath) {
+    return null;
+  }
+  const config = loadGlobalConfig();
+  const links = config.directory_links?.[environment];
+  if (!links) {
+    return null;
+  }
+  const normalizedPath = normalizeDirectoryPath(directoryPath);
+  const appId = links[normalizedPath];
+  return appId || null;
+}
+function setLinkedAppForDirectory(environment, directoryPath, appId) {
+  if (!directoryPath || !environment) {
+    return;
+  }
+  const config = loadGlobalConfig();
+  if (!config.directory_links) {
+    config.directory_links = {};
+  }
+  if (!config.directory_links[environment]) {
+    config.directory_links[environment] = {};
+  }
+  const normalizedPath = normalizeDirectoryPath(directoryPath);
+  config.directory_links[environment][normalizedPath] = appId.toLowerCase();
+  saveGlobalConfig(config);
+}
 function getDefaultEnvironment() {
   const config = loadGlobalConfig();
   return config.default_environment;
@@ -172,6 +201,7 @@ async function withTelemetry(command, action) {
 
 // src/flags.ts
 import { Flags } from "@oclif/core";
+import { getBuildType as getBuildType3 } from "@layr-labs/ecloud-sdk";
 
 // src/utils/prompts.ts
 import { input, select, password, confirm as inquirerConfirm } from "@inquirer/prompts";
@@ -250,7 +280,7 @@ function listApps(environment) {
 
 // src/utils/version.ts
 function getCliVersion() {
-  return true ? "0.1.1" : "0.0.0";
+  return true ? "0.1.2" : "0.0.0";
 }
 function getClientId() {
   return `ecloud-cli/v${getCliVersion()}`;
@@ -445,6 +475,9 @@ function getDefaultAppName() {
     return "myapp";
   }
 }
+function getCurrentProjectPath() {
+  return process.env.INIT_CWD || process.cwd();
+}
 function suggestImageReference(registry, imageName, tag) {
   imageName = imageName.toLowerCase().replace(/_/g, "-");
   if (!tag) {
@@ -819,7 +852,19 @@ Select an app to ${action}:
       index: i
     });
   }
+  const linkedAppId = getLinkedAppForDirectory(environment, getCurrentProjectPath());
+  const normalizedLinkedAppId = linkedAppId ? linkedAppId.toLowerCase() : "";
   appItems.sort((a, b) => {
+    if (normalizedLinkedAppId) {
+      const aLinked = String(a.addr).toLowerCase() === normalizedLinkedAppId;
+      const bLinked = String(b.addr).toLowerCase() === normalizedLinkedAppId;
+      if (aLinked && !bLinked) {
+        return -1;
+      }
+      if (bLinked && !aLinked) {
+        return 1;
+      }
+    }
     const aPriority = getStatusPriority(a.status, false);
     const bPriority = getStatusPriority(b.status, false);
     if (aPriority !== bPriority) {
@@ -885,7 +930,18 @@ async function getAppIDInteractiveFromRegistry(environment, action) {
     }
     throw new Error(`Invalid app ID address: ${appIDInput}`);
   }
-  const choices = Object.entries(allApps).map(([name, appID]) => {
+  const entries = Object.entries(allApps);
+  const linkedAppId = getLinkedAppForDirectory(environment, getCurrentProjectPath());
+  if (linkedAppId) {
+    const linkedIndex = entries.findIndex(
+      ([, appId]) => String(appId).toLowerCase() === linkedAppId.toLowerCase()
+    );
+    if (linkedIndex > 0) {
+      const [linkedEntry] = entries.splice(linkedIndex, 1);
+      entries.unshift(linkedEntry);
+    }
+  }
+  const choices = entries.map(([name, appID]) => {
     const displayName = `${name} (${appID})`;
     return { name: displayName, value: appID };
   });
@@ -963,8 +1019,8 @@ async function getPrivateKeyInteractive(privateKey) {
     }
     return privateKey;
   }
-  const { getPrivateKeyWithSource } = await import("@layr-labs/ecloud-sdk");
-  const result = await getPrivateKeyWithSource({ privateKey: void 0 });
+  const { getPrivateKeyWithSource: getPrivateKeyWithSource2 } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource2({ privateKey: void 0 });
   if (result) {
     return result.key;
   }
@@ -983,6 +1039,50 @@ async function getPrivateKeyInteractive(privateKey) {
   });
   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
@@ -990,7 +1090,8 @@ var commonFlags = {
   environment: Flags.string({
     required: false,
     description: "Deployment environment to use",
-    env: "ECLOUD_ENV"
+    env: "ECLOUD_ENV",
+    default: async () => getDefaultEnvironment() || (getBuildType3() === "dev" ? "sepolia-dev" : "sepolia")
   }),
   "private-key": Flags.string({
     required: false,
@@ -1008,6 +1109,41 @@ var commonFlags = {
     default: false
   })
 };
+async function validateCommonFlags(flags) {
+  flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
+  flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
+  return flags;
+}
+
+// src/client.ts
+import {
+  createComputeModule,
+  createBillingModule,
+  getEnvironmentConfig as getEnvironmentConfig2,
+  requirePrivateKey,
+  getPrivateKeyWithSource
+} from "@layr-labs/ecloud-sdk";
+async function createComputeClient(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 createComputeModule({
+    verbose: flags.verbose,
+    privateKey,
+    rpcUrl,
+    environment,
+    clientId: getClientId(),
+    skipTelemetry: true
+    // CLI already has telemetry, skip SDK telemetry
+  });
+}
 
 // src/commands/compute/app/upgrade.ts
 import chalk from "chalk";
@@ -1058,16 +1194,11 @@ var AppUpgrade = class _AppUpgrade extends Command {
   async run() {
     return withTelemetry(this, async () => {
       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 compute = await createComputeClient(flags);
+      const environment = flags.environment;
+      const environmentConfig = getEnvironmentConfig3(environment);
       const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
-      const privateKey = await getPrivateKeyInteractive(flags["private-key"]);
+      const privateKey = flags["private-key"];
       const appID = await getOrPromptAppID({
         appID: args["app-id"],
         environment,
@@ -1110,22 +1241,14 @@ var AppUpgrade = class _AppUpgrade extends Command {
         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,
-          skipTelemetry: true
-        },
-        logger
-      );
+      const { prepared, gasEstimate } = await compute.app.prepareUpgrade(appID, {
+        dockerfile: dockerfilePath,
+        imageRef,
+        envFile: envFilePath,
+        instanceType,
+        logVisibility,
+        resourceUsageMonitoring
+      });
       this.log(`
 Estimated transaction cost: ${chalk.cyan(gasEstimate.maxCostEth)} ETH`);
       if (isMainnet(environmentConfig)) {
@@ -1136,17 +1259,17 @@ ${chalk.gray(`Upgrade cancelled`)}`);
           return;
         }
       }
-      const res = await executeUpgrade(
-        prepared,
-        {
-          maxFeePerGas: gasEstimate.maxFeePerGas,
-          maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
-        },
-        logger,
-        true
-        // skipTelemetry
-      );
-      await watchUpgrade(res.appId, privateKey, rpcUrl, environment, logger, getClientId(), true);
+      const res = await compute.app.executeUpgrade(prepared, {
+        maxFeePerGas: gasEstimate.maxFeePerGas,
+        maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
+      });
+      await compute.app.watchUpgrade(res.appId);
+      try {
+        const cwd = process.env.INIT_CWD || process.cwd();
+        setLinkedAppForDirectory(environment, cwd, res.appId);
+      } catch (err) {
+        logger.debug(`Failed to link directory to app: ${err.message}`);
+      }
       this.log(
         `
 \u2705 ${chalk.green(`App upgraded successfully ${chalk.bold(`(id: ${res.appId}, image: ${res.imageRef})`)}`)}`