@layr-labs/ecloud-cli 0.2.0 → 0.2.2-dev

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

@@ -2,7 +2,7 @@
 
 // src/commands/compute/app/deploy.ts
 import { Command, Flags as Flags2 } from "@oclif/core";
-import { getEnvironmentConfig as getEnvironmentConfig3, UserApiClient as UserApiClient3, isMainnet } from "@layr-labs/ecloud-sdk";
+import { getEnvironmentConfig as getEnvironmentConfig4, UserApiClient as UserApiClient3, isMainnet } from "@layr-labs/ecloud-sdk";
 
 // src/telemetry.ts
 import {
@@ -185,9 +185,9 @@ 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 { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 import {
-  getEnvironmentConfig,
+  getEnvironmentConfig as getEnvironmentConfig2,
   getAvailableEnvironments,
   isEnvironmentAvailable,
   getAllAppsByDeveloper as getAllAppsByDeveloper2,
@@ -204,12 +204,43 @@ import {
 
 // src/utils/appResolver.ts
 import { isAddress } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 import {
   UserApiClient,
   getAllAppsByDeveloper
 } from "@layr-labs/ecloud-sdk";
 
+// src/utils/viemClients.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  getEnvironmentConfig,
+  addHexPrefix,
+  createViemClients as sdkCreateViemClients,
+  getChainFromID
+} from "@layr-labs/ecloud-sdk";
+function createViemClients(options) {
+  const privateKey = addHexPrefix(options.privateKey);
+  const environmentConfig = getEnvironmentConfig(options.environment);
+  const rpcUrl = options.rpcUrl || environmentConfig.defaultRPCURL;
+  const chain = getChainFromID(environmentConfig.chainID);
+  const { publicClient, walletClient } = sdkCreateViemClients({
+    privateKey,
+    rpcUrl,
+    chainId: environmentConfig.chainID
+  });
+  const account = privateKeyToAccount(privateKey);
+  return {
+    publicClient,
+    walletClient,
+    chain,
+    address: account.address
+  };
+}
+
 // src/utils/appNames.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -273,7 +304,7 @@ function findAvailableName(environment, baseName) {
 
 // src/utils/version.ts
 function getCliVersion() {
-  return true ? "0.2.0" : "0.0.0";
+  return true ? "0.2.2-dev" : "0.0.0";
 }
 function getClientId() {
   return `ecloud-cli/v${getCliVersion()}`;
@@ -694,7 +725,12 @@ async function getOrPromptAppName(appName, environment, imageRef, suggestedBaseN
       return appName;
     }
     console.log(`Warning: App name '${appName}' is already taken.`);
-    return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName, skipDefaultName);
+    return getAvailableAppNameInteractive(
+      environment,
+      imageRef,
+      suggestedBaseName,
+      skipDefaultName
+    );
   }
   return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName, skipDefaultName);
 }
@@ -857,7 +893,7 @@ async function getPrivateKeyInteractive(privateKey) {
 async function getEnvironmentInteractive(environment) {
   if (environment) {
     try {
-      getEnvironmentConfig(environment);
+      getEnvironmentConfig2(environment);
       if (!isEnvironmentAvailable(environment)) {
         throw new Error(`Environment ${environment} is not available in this build`);
       }
@@ -870,7 +906,7 @@ async function getEnvironmentInteractive(environment) {
   const configDefaultEnv = getDefaultEnvironment();
   if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
     try {
-      getEnvironmentConfig(configDefaultEnv);
+      getEnvironmentConfig2(configDefaultEnv);
       defaultEnv = configDefaultEnv;
     } catch {
     }
@@ -973,12 +1009,14 @@ async function getAppProfileInteractive(defaultName = "", allowRetry = true) {
     const description = await getAppDescriptionInteractive();
     const xURL = await getAppXURLInteractive();
     const imagePath = await getAppImageInteractive();
+    const { image, imageName } = imagePathToBlob(imagePath);
     const profile = {
       name,
       website,
       description,
       xURL,
-      imagePath
+      image,
+      imageName
     };
     console.log("\n" + formatProfileForDisplay(profile));
     const confirmed = await inquirerConfirm({
@@ -1113,12 +1151,25 @@ function formatProfileForDisplay(profile) {
     output += `  X URL:       ${profile.xURL}
 `;
   }
-  if (profile.imagePath) {
-    output += `  Image:       ${profile.imagePath}
+  if (profile.imageName) {
+    output += `  Image:       ${profile.imageName}
 `;
   }
   return output;
 }
+function imagePathToBlob(imagePath) {
+  if (!imagePath) {
+    return { image: void 0, imageName: void 0 };
+  }
+  try {
+    const fileBuffer = fs3.readFileSync(imagePath);
+    const imageName = path3.basename(imagePath);
+    return { image: new Blob([fileBuffer]), imageName };
+  } catch (err) {
+    console.error(`Failed to read image file: ${err}`);
+    return { image: void 0, imageName: void 0 };
+  }
+}
 
 // src/flags.ts
 var commonFlags = {
@@ -1157,14 +1208,14 @@ import {
   createComputeModule,
   createBillingModule,
   createBuildModule,
-  getEnvironmentConfig as getEnvironmentConfig2,
+  getEnvironmentConfig as getEnvironmentConfig3,
   requirePrivateKey,
   getPrivateKeyWithSource
 } from "@layr-labs/ecloud-sdk";
 async function createComputeClient(flags) {
   flags = await validateCommonFlags(flags);
   const environment = flags.environment;
-  const environmentConfig = getEnvironmentConfig2(environment);
+  const environmentConfig = getEnvironmentConfig3(environment);
   const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
   const { key: privateKey, source } = await requirePrivateKey({
     privateKey: flags["private-key"]
@@ -1172,10 +1223,15 @@ async function createComputeClient(flags) {
   if (flags.verbose) {
     console.log(`Using private key from: ${source}`);
   }
-  return createComputeModule({
-    verbose: flags.verbose,
+  const { walletClient, publicClient } = createViemClients({
     privateKey,
     rpcUrl,
+    environment
+  });
+  return createComputeModule({
+    verbose: flags.verbose,
+    walletClient,
+    publicClient,
     environment,
     clientId: getClientId(),
     skipTelemetry: true
@@ -1184,10 +1240,21 @@ async function createComputeClient(flags) {
 }
 async function createBuildClient(flags) {
   flags = await validateCommonFlags(flags, { requirePrivateKey: false });
+  const environment = flags.environment || "mainnet";
+  const environmentConfig = getEnvironmentConfig3(environment);
+  const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
+  let walletClient;
+  if (flags["private-key"]) {
+    walletClient = createViemClients({
+      privateKey: flags["private-key"],
+      rpcUrl,
+      environment
+    }).walletClient;
+  }
   return createBuildModule({
     verbose: flags.verbose,
-    privateKey: flags["private-key"],
-    environment: flags.environment,
+    walletClient,
+    environment,
     clientId: getClientId(),
     skipTelemetry: true
     // CLI already has telemetry, skip SDK telemetry
@@ -1272,6 +1339,17 @@ async function runVerifiableBuildAndVerify(client, request, options = {}) {
   return { build, verified: verify };
 }
 
+// src/utils/dashboard.ts
+var DASHBOARD_URLS = {
+  "sepolia-dev": "https://compute-dashboard-sepolia-dev.vercel.app",
+  sepolia: "https://verify-sepolia.eigencloud.xyz",
+  "mainnet-alpha": "https://verify.eigencloud.xyz"
+};
+function getDashboardUrl(environment, appAddress) {
+  const baseUrl = DASHBOARD_URLS[environment] || DASHBOARD_URLS["sepolia"];
+  return `${baseUrl}/app/${appAddress}`;
+}
+
 // src/utils/dockerhub.ts
 var DOCKERHUB_OWNER = "eigenlayer";
 var DOCKERHUB_REPO = "eigencloud-containers";
@@ -1454,6 +1532,11 @@ var AppDeploy = class _AppDeploy extends Command {
     "build-dependencies": Flags2.string({
       description: "Dependency digests for verifiable build (git source mode) (sha256:...)",
       multiple: true
+    }),
+    "build-caddyfile": Flags2.string({
+      description: "Optional path to Caddyfile inside the repo (relative to build context). If omitted, auto-detected from env file TLS settings",
+      required: false,
+      env: "ECLOUD_BUILD_CADDYFILE"
     })
   };
   async run() {
@@ -1461,7 +1544,7 @@ var AppDeploy = class _AppDeploy extends Command {
       const { flags } = await this.parse(_AppDeploy);
       const compute = await createComputeClient(flags);
       const environment = flags.environment;
-      const environmentConfig = getEnvironmentConfig3(environment);
+      const environmentConfig = getEnvironmentConfig4(environment);
       const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
       const privateKey = flags["private-key"];
       let buildClient;
@@ -1528,7 +1611,7 @@ var AppDeploy = class _AppDeploy extends Command {
           repoUrl: flags.repo,
           gitRef: flags.commit,
           dockerfilePath: flags["build-dockerfile"],
-          caddyfilePath: void 0,
+          caddyfilePath: flags["build-caddyfile"],
           buildContextPath: flags["build-context"],
           dependencies: flags["build-dependencies"]
         } : await promptVerifiableGitSourceInputs();
@@ -1650,20 +1733,19 @@ ${chalk.gray(`Deployment cancelled`)}`);
           return;
         }
       }
-      const res = await compute.app.executeDeploy(prepared, {
-        maxFeePerGas: gasEstimate.maxFeePerGas,
-        maxPriorityFeePerGas: gasEstimate.maxPriorityFeePerGas
-      });
+      const res = await compute.app.executeDeploy(prepared, gasEstimate);
       if (!flags["skip-profile"]) {
         const hasProfileFlags = flags.website || flags.description || flags["x-url"] || flags.image;
         let profile = null;
         if (hasProfileFlags) {
+          const { image, imageName } = imagePathToBlob(flags.image);
           profile = {
             name: appName,
             website: flags.website,
             description: flags.description,
             xURL: flags["x-url"],
-            imagePath: flags.image
+            image,
+            imageName
           };
         } else {
           this.log(
@@ -1705,12 +1787,25 @@ ${chalk.gray(`Deployment cancelled`)}`);
         `
 \u2705 ${chalk.green(`App deployed successfully ${chalk.bold(`(id: ${res.appId}, ip: ${ipAddress})`)}`)}`
       );
+      const dashboardUrl = getDashboardUrl(environment, res.appId);
+      this.log(`
+${chalk.gray("View your app:")} ${chalk.blue.underline(dashboardUrl)}`);
     });
   }
 };
 async function fetchAvailableInstanceTypes(environmentConfig, privateKey, rpcUrl) {
   try {
-    const userApiClient = new UserApiClient3(environmentConfig, privateKey, rpcUrl, getClientId());
+    const { publicClient, walletClient } = createViemClients({
+      privateKey,
+      rpcUrl,
+      environment: environmentConfig.name
+    });
+    const userApiClient = new UserApiClient3(
+      environmentConfig,
+      walletClient,
+      publicClient,
+      { clientId: getClientId() }
+    );
     const skuList = await userApiClient.getSKUs();
     if (skuList.skus.length === 0) {
       throw new Error("No instance types available from server");