@layr-labs/ecloud-cli 0.2.0-dev → 0.2.0-dev.1

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

@@ -2,15 +2,7 @@
 
 // src/commands/compute/app/deploy.ts
 import { Command, Flags as Flags2 } from "@oclif/core";
-import {
-  getEnvironmentConfig as getEnvironmentConfig3,
-  UserApiClient as UserApiClient3,
-  isMainnet,
-  prepareDeploy,
-  prepareDeployFromVerifiableBuild,
-  executeDeploy,
-  watchDeployment
-} from "@layr-labs/ecloud-sdk";
+import { getEnvironmentConfig as getEnvironmentConfig3, UserApiClient as UserApiClient3, isMainnet } from "@layr-labs/ecloud-sdk";
 
 // src/telemetry.ts
 import {
@@ -72,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;
@@ -117,8 +132,8 @@ function createCLITelemetryClient() {
   const environment = createAppEnvironment(userUUID);
   const telemetryEnabled = getGlobalTelemetryPreference();
   return createTelemetryClient(environment, "ecloud-cli", {
-    telemetryEnabled: telemetryEnabled === true
-    // Only enabled if explicitly set to true
+    telemetryEnabled: telemetryEnabled !== false
+    // Enabled by default, disabled only if explicitly set to false
   });
 }
 async function withTelemetry(command, action) {
@@ -162,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";
@@ -257,7 +273,7 @@ function findAvailableName(environment, baseName) {
 
 // src/utils/version.ts
 function getCliVersion() {
-  return true ? "0.2.0-dev" : "0.0.0";
+  return true ? "0.2.0-dev.1" : "0.0.0";
 }
 function getClientId() {
   return `ecloud-cli/v${getCliVersion()}`;
@@ -646,9 +662,9 @@ async function getImageReferenceInteractive(imageRef, buildFromDockerfile = fals
   });
   return imageRefInput;
 }
-async function getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName) {
-  const baseName = suggestedBaseName || extractAppNameFromImage(imageRef);
-  const suggestedName = findAvailableName(environment, baseName);
+async function getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName, skipDefaultName) {
+  const baseName = skipDefaultName ? void 0 : suggestedBaseName || extractAppNameFromImage(imageRef);
+  const suggestedName = baseName ? findAvailableName(environment, baseName) : void 0;
   while (true) {
     console.log("\nApp name selection:");
     const name = await input({
@@ -671,16 +687,16 @@ async function getAvailableAppNameInteractive(environment, imageRef, suggestedBa
     console.log(`Suggested alternative: ${newSuggested}`);
   }
 }
-async function getOrPromptAppName(appName, environment, imageRef, suggestedBaseName) {
+async function getOrPromptAppName(appName, environment, imageRef, suggestedBaseName, skipDefaultName) {
   if (appName) {
     validateAppName(appName);
     if (isAppNameAvailable(environment, appName)) {
       return appName;
     }
     console.log(`Warning: App name '${appName}' is already taken.`);
-    return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName);
+    return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName, skipDefaultName);
   }
-  return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName);
+  return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName, skipDefaultName);
 }
 async function getEnvFileInteractive(envFilePath) {
   if (envFilePath && fs3.existsSync(envFilePath)) {
@@ -1109,7 +1125,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,
@@ -1128,9 +1145,6 @@ var commonFlags = {
   })
 };
 async function validateCommonFlags(flags, options) {
-  if (!flags["environment"]) {
-    flags["environment"] = getDefaultEnvironment();
-  }
   flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
   if (options?.requirePrivateKey !== false) {
     flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
@@ -1138,9 +1152,6 @@ async function validateCommonFlags(flags, options) {
   return flags;
 }
 
-// src/commands/compute/app/deploy.ts
-import chalk from "chalk";
-
 // src/client.ts
 import {
   createComputeModule,
@@ -1150,6 +1161,27 @@ import {
   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
+  });
+}
 async function createBuildClient(flags) {
   flags = await validateCommonFlags(flags, { requirePrivateKey: false });
   return createBuildModule({
@@ -1162,6 +1194,9 @@ async function createBuildClient(flags) {
   });
 }
 
+// src/commands/compute/app/deploy.ts
+import chalk from "chalk";
+
 // src/utils/build.ts
 function formatSourceLink(repoUrl, gitRef) {
   const normalizedRepo = repoUrl.replace(/\.git$/, "");
@@ -1424,16 +1459,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 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"];
       let buildClient;
       const getBuildClient = async () => {
         if (buildClient) return buildClient;
@@ -1446,6 +1476,7 @@ var AppDeploy = class _AppDeploy extends Command {
       let verifiableImageUrl;
       let verifiableImageDigest;
       let suggestedAppBaseName;
+      let skipDefaultAppName = false;
       let verifiableMode = "none";
       let envFilePath;
       const suggestAppBaseNameFromRepoUrl = (repoUrl) => {
@@ -1549,7 +1580,7 @@ var AppDeploy = class _AppDeploy extends Command {
         }
         verifiableImageUrl = imageRef2;
         verifiableImageDigest = digest;
-        suggestedAppBaseName = suggestAppBaseNameFromRepoUrl(verify.repoUrl);
+        skipDefaultAppName = true;
         for (const line of formatVerifiableBuildSummary({
           buildId: verify.buildId,
           imageUrl: imageRef2,
@@ -1570,7 +1601,8 @@ var AppDeploy = class _AppDeploy extends Command {
         flags.name,
         environment,
         imageRef,
-        suggestedAppBaseName
+        suggestedAppBaseName,
+        skipDefaultAppName
       );
       envFilePath = envFilePath ?? await getEnvFileInteractive(flags["env-file"]);
       const availableTypes = await fetchAvailableInstanceTypes(
@@ -1591,37 +1623,23 @@ var AppDeploy = class _AppDeploy extends Command {
         flags["resource-usage-monitoring"]
       );
       const logVisibility = logSettings.publicLogs ? "public" : logSettings.logRedirect ? "private" : "off";
-      const { prepared, gasEstimate } = isVerifiable ? await prepareDeployFromVerifiableBuild(
-        {
-          privateKey,
-          rpcUrl,
-          environment,
-          imageRef,
-          imageDigest: verifiableImageDigest,
-          envFilePath,
-          appName,
-          instanceType,
-          logVisibility,
-          resourceUsageMonitoring,
-          skipTelemetry: true
-        },
-        logger
-      ) : await prepareDeploy(
-        {
-          privateKey,
-          rpcUrl,
-          environment,
-          dockerfilePath,
-          imageRef,
-          envFilePath,
-          appName,
-          instanceType,
-          logVisibility,
-          resourceUsageMonitoring,
-          skipTelemetry: true
-        },
-        logger
-      );
+      const { prepared, gasEstimate } = isVerifiable ? await compute.app.prepareDeployFromVerifiableBuild({
+        name: appName,
+        imageRef,
+        imageDigest: verifiableImageDigest,
+        envFile: envFilePath,
+        instanceType,
+        logVisibility,
+        resourceUsageMonitoring
+      }) : 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)) {
@@ -1632,16 +1650,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;
@@ -1660,47 +1672,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) {
+        this.debug(`Failed to link directory to app: ${err.message}`);
+      }
       this.log(
         `
 \u2705 ${chalk.green(`App deployed successfully ${chalk.bold(`(id: ${res.appId}, ip: ${ipAddress})`)}`)}`