@layr-labs/ecloud-cli 0.1.1 → 0.1.2

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

@@ -2,14 +2,7 @@
 
 // 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";
+import { getEnvironmentConfig as getEnvironmentConfig3, isMainnet, UserApiClient as UserApiClient3 } from "@layr-labs/ecloud-sdk";
 
 // src/telemetry.ts
 import {
@@ -71,6 +64,29 @@ 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 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;
@@ -161,6 +177,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";
@@ -256,7 +273,7 @@ function findAvailableName(environment, baseName) {
 
 // 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()}`;
@@ -710,8 +727,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;
   }
@@ -730,6 +747,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_DESCRIPTION_LENGTH = 1e3;
 var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
 var VALID_IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png"];
@@ -957,7 +1018,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,
@@ -975,6 +1037,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/deploy.ts
 import chalk from "chalk";
@@ -1045,16 +1142,11 @@ var AppDeploy = class _AppDeploy extends Command {
   async run() {
     return withTelemetry(this, async () => {
       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 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 dockerfilePath = await getDockerfileInteractive(flags.dockerfile);
       const buildFromDockerfile = dockerfilePath !== "";
       const imageRef = await getImageReferenceInteractive(flags["image-ref"], buildFromDockerfile);
@@ -1078,22 +1170,15 @@ var AppDeploy = class _AppDeploy extends Command {
         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,
-          skipTelemetry: true
-        },
-        logger
-      );
+      const { prepared, gasEstimate } = await compute.app.prepareDeploy({
+        name: appName,
+        dockerfile: dockerfilePath,
+        imageRef,
+        envFile: envFilePath,
+        instanceType,
+        logVisibility,
+        resourceUsageMonitoring
+      });
       this.log(`
 Estimated transaction cost: ${chalk.cyan(gasEstimate.maxCostEth)} ETH`);
       if (isMainnet(environmentConfig)) {
@@ -1104,16 +1189,10 @@ ${chalk.gray(`Deployment cancelled`)}`);
           return;
         }
       }
-      const res = await executeDeploy(
-        prepared,
-        {
-          maxFeePerGas: gasEstimate.maxFeePerGas,
-          maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
-        },
-        logger,
-        true
-        // skipTelemetry
-      );
+      const res = await compute.app.executeDeploy(prepared, {
+        maxFeePerGas: gasEstimate.maxFeePerGas,
+        maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
+      });
       if (!flags["skip-profile"]) {
         const hasProfileFlags = flags.website || flags.description || flags["x-url"] || flags.image;
         let profile = null;
@@ -1132,47 +1211,35 @@ ${chalk.gray(`Deployment cancelled`)}`);
           try {
             profile = await getAppProfileInteractive(appName, true) || null;
           } catch {
-            logger.debug("Profile collection skipped or cancelled");
+            if (flags.verbose) {
+              this.log("Profile collection skipped or cancelled");
+            }
           }
         }
         if (profile) {
-          logger.info("Uploading app profile...");
+          this.log("Uploading app profile...");
           try {
-            const userApiClient = new UserApiClient3(
-              environmentConfig,
-              privateKey,
-              rpcUrl,
-              getClientId()
-            );
-            await userApiClient.uploadAppProfile(
-              res.appId,
-              profile.name,
-              profile.website,
-              profile.description,
-              profile.xURL,
-              profile.imagePath
-            );
-            logger.info("\u2713 Profile uploaded successfully");
+            await compute.app.setProfile(res.appId, profile);
+            this.log("\u2713 Profile uploaded successfully");
             try {
               invalidateProfileCache(environment);
             } catch (cacheErr) {
-              logger.debug(`Failed to invalidate profile cache: ${cacheErr.message}`);
+              if (flags.verbose) {
+                this.log(`Failed to invalidate profile cache: ${cacheErr.message}`);
+              }
             }
           } catch (uploadErr) {
-            logger.warn(`Failed to upload profile: ${uploadErr.message}`);
+            this.warn(`Failed to upload profile: ${uploadErr.message}`);
           }
         }
       }
-      const ipAddress = await watchDeployment(
-        res.appId,
-        privateKey,
-        rpcUrl,
-        environment,
-        logger,
-        getClientId(),
-        true
-        // skipTelemetry - CLI already has telemetry
-      );
+      const ipAddress = await compute.app.watchDeployment(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 deployed successfully ${chalk.bold(`(id: ${res.appId}, ip: ${ipAddress})`)}`)}`