@layr-labs/ecloud-cli 1.0.0-devep7 → 1.0.0

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

@@ -2,7 +2,12 @@
 
 // src/commands/compute/app/upgrade.ts
 import { Command, Args, Flags as Flags2 } from "@oclif/core";
-import { getEnvironmentConfig as getEnvironmentConfig4, UserApiClient as UserApiClient3, isMainnet } from "@layr-labs/ecloud-sdk";
+import {
+  getEnvironmentConfig as getEnvironmentConfig4,
+  UserApiClient as UserApiClient4,
+  isMainnet,
+  WatchTimeoutError
+} from "@layr-labs/ecloud-sdk";
 
 // src/telemetry.ts
 import {
@@ -323,7 +328,7 @@ function listApps(environment) {
 
 // src/utils/version.ts
 function getCliVersion() {
-  return true ? "1.0.0-devep7" : "0.0.0";
+  return true ? "1.0.0" : "0.0.0";
 }
 function getClientId() {
   return `ecloud-cli/v${getCliVersion()}`;
@@ -360,7 +365,30 @@ function ensureInteractive(missingFlagHint) {
     );
   }
 }
-async function getDockerfileInteractive(dockerfilePath) {
+function isNonInteractive(flags) {
+  if (flags?.["non-interactive"]) return true;
+  if (process.env.CI === "true") return true;
+  return !process.stdin.isTTY;
+}
+function warnDefaulted(flagHint, chosen) {
+  console.warn(`Warning: ${flagHint} not set in non-interactive mode; defaulting to ${chosen}.`);
+}
+function collectMissingRequiredInputs(state, identityFlag) {
+  const missing = [];
+  const hasImageSource = !!state.imageRef || !!state.dockerfile || !!state.verifiable && !!state.repo && !!state.commit;
+  if (!hasImageSource) {
+    missing.push(
+      "an image source (one of: --image-ref, --dockerfile, or --verifiable with --repo and --commit)"
+    );
+  } else if (state.dockerfile && !state.imageRef && !state.verifiable) {
+    missing.push("--image-ref (registry destination for the built image)");
+  }
+  if (identityFlag === "name" && !state.name) {
+    missing.push("--name");
+  }
+  return missing;
+}
+async function getDockerfile(dockerfilePath, nonInteractive = false) {
   if (dockerfilePath) {
     return dockerfilePath;
   }
@@ -369,6 +397,10 @@ async function getDockerfileInteractive(dockerfilePath) {
   if (!fs3.existsSync(dockerfilePath_resolved)) {
     return "";
   }
+  if (nonInteractive) {
+    warnDefaulted("--dockerfile/--image-ref", `build from '${dockerfilePath_resolved}'`);
+    return dockerfilePath_resolved;
+  }
   ensureInteractive("--dockerfile or --image-ref");
   console.log(`
 Found Dockerfile in ${cwd}`);
@@ -786,13 +818,17 @@ async function getImageReferenceInteractive(imageRef, buildFromDockerfile = fals
   });
   return imageRefInput;
 }
-async function getEnvFileInteractive(envFilePath) {
+async function getEnvFile(envFilePath, nonInteractive = false) {
   if (envFilePath && fs3.existsSync(envFilePath)) {
     return envFilePath;
   }
   if (fs3.existsSync(".env")) {
     return ".env";
   }
+  if (nonInteractive) {
+    warnDefaulted("--env-file", "no env file");
+    return "";
+  }
   ensureInteractive("--env-file");
   console.log("\nEnvironment file not found.");
   console.log("Environment files contain variables like RPC_URL, etc.");
@@ -820,6 +856,7 @@ async function getEnvFileInteractive(envFilePath) {
       throw new Error(`Unexpected choice: ${choice}`);
   }
 }
+var DEFAULT_NONINTERACTIVE_SKU = "g1-standard-2s";
 function formatSkuChoice(it) {
   if (it.vcpus != null && it.memory_mb != null && it.monthly_price_usd != null && it.hourly_price_usd != null) {
     const tier = it.friendly_name ?? it.sku;
@@ -836,7 +873,7 @@ function formatSkuChoice(it) {
   }
   return `${it.sku} - ${it.description}`;
 }
-async function getInstanceTypeInteractive(instanceType, defaultSKU, availableTypes) {
+async function getInstanceType(instanceType, defaultSKU, availableTypes, nonInteractive = false) {
   if (instanceType) {
     const valid = availableTypes.find((t) => t.sku === instanceType);
     if (valid) {
@@ -845,6 +882,20 @@ async function getInstanceTypeInteractive(instanceType, defaultSKU, availableTyp
     const validSKUs = availableTypes.map((t) => t.sku).join(", ");
     throw new Error(`Invalid instance-type: ${instanceType} (must be one of: ${validSKUs})`);
   }
+  if (nonInteractive) {
+    if (defaultSKU) {
+      warnDefaulted("--instance-type", `current type '${defaultSKU}'`);
+      return defaultSKU;
+    }
+    if (availableTypes.some((t) => t.sku === DEFAULT_NONINTERACTIVE_SKU)) {
+      warnDefaulted("--instance-type", `'${DEFAULT_NONINTERACTIVE_SKU}'`);
+      return DEFAULT_NONINTERACTIVE_SKU;
+    }
+    const validSKUs = availableTypes.map((t) => t.sku).join(", ");
+    throw new Error(
+      `Cannot pick a default --instance-type in non-interactive mode: '${DEFAULT_NONINTERACTIVE_SKU}' not offered (available: ${validSKUs}). Provide --instance-type.`
+    );
+  }
   ensureInteractive("--instance-type");
   const isCurrentType = defaultSKU !== "";
   const hasPricing = availableTypes.some((t) => t.monthly_price_usd != null);
@@ -876,7 +927,7 @@ async function getInstanceTypeInteractive(instanceType, defaultSKU, availableTyp
   });
   return choice;
 }
-async function getLogSettingsInteractive(logVisibility) {
+async function getLogSettings(logVisibility, nonInteractive = false) {
   if (logVisibility) {
     switch (logVisibility) {
       case "public":
@@ -891,6 +942,10 @@ async function getLogSettingsInteractive(logVisibility) {
         );
     }
   }
+  if (nonInteractive) {
+    warnDefaulted("--log-visibility", "'private'");
+    return { logRedirect: "always", publicLogs: false };
+  }
   ensureInteractive("--log-visibility");
   const choice = await select({
     message: "Do you want to view your app's logs?",
@@ -1211,7 +1266,7 @@ Select an app to ${action}:`);
   }
   return addHexPrefix2(selected);
 }
-async function getResourceUsageMonitoringInteractive(resourceUsageMonitoring) {
+async function getResourceUsageMonitoring(resourceUsageMonitoring, nonInteractive = false) {
   if (resourceUsageMonitoring) {
     switch (resourceUsageMonitoring) {
       case "enable":
@@ -1223,6 +1278,10 @@ async function getResourceUsageMonitoringInteractive(resourceUsageMonitoring) {
         );
     }
   }
+  if (nonInteractive) {
+    warnDefaulted("--resource-usage-monitoring", "'disable'");
+    return "disable";
+  }
   ensureInteractive("--resource-usage-monitoring");
   const choice = await select({
     message: "Show resource usage (CPU/memory) for your app?",
@@ -1238,9 +1297,7 @@ async function confirm(prompt) {
 }
 async function confirmWithDefault(prompt, defaultValue = false) {
   if (!process.stdin.isTTY) {
-    throw new Error(
-      `Cannot confirm "${prompt}" in non-interactive mode. Use --force to skip confirmation prompts.`
-    );
+    return defaultValue;
   }
   return await inquirerConfirm({
     message: prompt,
@@ -1323,7 +1380,7 @@ var commonFlags = {
     required: false,
     description: "Deployment environment to use",
     env: "ECLOUD_ENV",
-    default: async () => getDefaultEnvironment() || (getBuildType3() === "dev" ? "sepolia-dev" : "sepolia")
+    default: async () => getDefaultEnvironment() || (getBuildType3() === "dev" ? "sepolia-dev" : "mainnet-alpha")
   }),
   "private-key": Flags.string({
     required: false,
@@ -1353,6 +1410,12 @@ var commonFlags = {
   nonce: Flags.string({
     required: false,
     description: 'Override transaction nonce (integer or "latest" to replace a stuck transaction)'
+  }),
+  "non-interactive": Flags.boolean({
+    required: false,
+    description: "Assume non-interactive mode: default safe prompts and error all-at-once on missing required inputs",
+    env: "ECLOUD_NON_INTERACTIVE",
+    default: false
   })
 };
 async function applyTxOverrides(estimate, flags, opts) {
@@ -1386,7 +1449,9 @@ async function applyTxOverrides(estimate, flags, opts) {
     } else {
       const parsed = Number(nonceStr);
       if (!Number.isInteger(parsed) || parsed < 0) {
-        throw new Error(`Invalid nonce: "${nonceStr}". Must be a non-negative integer or "latest".`);
+        throw new Error(
+          `Invalid nonce: "${nonceStr}". Must be a non-negative integer or "latest".`
+        );
       }
       nonce = parsed;
     }
@@ -1406,10 +1471,11 @@ import {
   createComputeModule,
   createBillingModule,
   createBuildModule,
+  createAdminModule,
   getEnvironmentConfig as getEnvironmentConfig3,
   requirePrivateKey
 } from "@layr-labs/ecloud-sdk";
-async function createComputeClient(flags) {
+async function createComputeClient(flags, options = {}) {
   flags = await validateCommonFlags(flags);
   const environment = flags.environment;
   const environmentConfig = getEnvironmentConfig3(environment);
@@ -1431,8 +1497,9 @@ async function createComputeClient(flags) {
     publicClient,
     environment,
     clientId: getClientId(),
-    skipTelemetry: true
+    skipTelemetry: true,
     // CLI already has telemetry, skip SDK telemetry
+    logger: options.logger
   });
 }
 async function createBuildClient(flags) {
@@ -1458,6 +1525,29 @@ async function createBuildClient(flags) {
   });
 }
 
+// src/utils/instanceTypes.ts
+import { UserApiClient as UserApiClient3 } from "@layr-labs/ecloud-sdk";
+async function fetchAvailableInstanceTypes(environment, environmentConfig, privateKey, rpcUrl) {
+  try {
+    const { publicClient, walletClient } = createViemClients({
+      privateKey,
+      rpcUrl,
+      environment
+    });
+    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");
+    }
+    return skuList.skus;
+  } catch (err) {
+    console.warn(`Failed to fetch instance types: ${err.message}`);
+    return [{ sku: "g1-standard-4t", description: "4 vCPUs, 16 GB memory, TDX" }];
+  }
+}
+
 // src/commands/compute/app/upgrade.ts
 import chalk2 from "chalk";
 
@@ -1619,8 +1709,63 @@ async function resolveDockerHubImageDigest(imageRef) {
   if (!/^sha256:[0-9a-f]{64}$/i.test(digest)) {
     throw new Error(`Unexpected digest format from Docker registry: ${digest}`);
   }
+  await assertImageHasAmd64(owner, repo, tag, token, imageRef);
   return digest;
 }
+var AMD64_ACCEPT = [
+  "application/vnd.oci.image.index.v1+json",
+  "application/vnd.docker.distribution.manifest.list.v2+json",
+  "application/vnd.oci.image.manifest.v1+json",
+  "application/vnd.docker.distribution.manifest.v2+json"
+].join(", ");
+async function assertImageHasAmd64(owner, repo, tag, token, imageRef) {
+  const base = `https://registry-1.docker.io/v2/${owner}/${repo}`;
+  const headers = { Authorization: `Bearer ${token}`, Accept: AMD64_ACCEPT };
+  const res = await fetch(`${base}/manifests/${encodeURIComponent(tag)}`, { headers });
+  if (!res.ok) {
+    const body = await safeReadText(res);
+    throw new Error(
+      `Failed to read manifest for ${imageRef} (${res.status}): ${body || res.statusText}`
+    );
+  }
+  const manifest = await res.json();
+  const isAmd64 = (os5, arch) => os5 === "linux" && arch === "amd64";
+  if (Array.isArray(manifest.manifests) && manifest.manifests.length > 0) {
+    const platforms = manifest.manifests.map(
+      (m) => m.platform ? `${m.platform.os}/${m.platform.architecture}` : "unknown"
+    );
+    if (manifest.manifests.some((m) => isAmd64(m.platform?.os, m.platform?.architecture))) {
+      return;
+    }
+    throw amd64Error(imageRef, platforms);
+  }
+  const configDigest = manifest.config?.digest;
+  if (!configDigest) {
+    throw amd64Error(imageRef, ["unknown (no platform info in manifest)"]);
+  }
+  const cfgRes = await fetch(`${base}/blobs/${configDigest}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!cfgRes.ok) {
+    throw amd64Error(imageRef, ["unknown (could not read image config)"]);
+  }
+  const cfg = await cfgRes.json();
+  if (isAmd64(cfg.os, cfg.architecture)) {
+    return;
+  }
+  throw amd64Error(imageRef, [`${cfg.os ?? "unknown"}/${cfg.architecture ?? "unknown"}`]);
+}
+function amd64Error(imageRef, platforms) {
+  return new Error(
+    `ecloud requires linux/amd64 images for TEE deployment.
+
+Image: ${imageRef}
+Found platform(s): ${platforms.join(", ")}
+Required platform: linux/amd64
+
+To fix: rebuild for linux/amd64 (e.g. docker buildx build --platform linux/amd64 ... --push), or use a verifiable build (--verifiable --repo <repo> --commit <sha>), which builds server-side.`
+  );
+}
 
 // src/utils/tls.ts
 import fs4 from "fs";
@@ -1685,12 +1830,45 @@ function mergeInlineEnvVars(envFilePath, inlineEnvVars) {
   return tmpFile;
 }
 
+// src/utils/exitCodes.ts
+import { InsufficientGasError } from "@layr-labs/ecloud-sdk";
+var EXIT_CODES = {
+  INVALID_INPUT: 2,
+  BUILD_FAILED: 3,
+  ONCHAIN_FAILED: 4
+};
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function stageFailure(operation, stage, err) {
+  const noun = operation === "deploy" ? "deployment" : "upgrade";
+  if (err instanceof InsufficientGasError) {
+    stage = "onchain";
+  }
+  switch (stage) {
+    case "invalid-input":
+      return { message: errorMessage(err), exit: EXIT_CODES.INVALID_INPUT };
+    case "build":
+      return {
+        message: `Build/push failed (no ${noun} was attempted): ${errorMessage(err)}`,
+        exit: EXIT_CODES.BUILD_FAILED
+      };
+    case "onchain":
+      return {
+        message: `On-chain ${noun} failed after the image was built and pushed: ${errorMessage(err)}
+The image is already pushed \u2014 re-running ${operation} will reuse it.`,
+        exit: EXIT_CODES.ONCHAIN_FAILED
+      };
+  }
+}
+
 // src/commands/compute/app/upgrade.ts
 var AppUpgrade = class _AppUpgrade extends Command {
   static description = "Upgrade existing deployment";
   static args = {
     "app-id": Args.string({
-      description: "App ID or name to upgrade",
+      description: "App ID or name to upgrade (env: ECLOUD_APP_ID)",
       required: false
     })
   };
@@ -1724,7 +1902,7 @@ var AppUpgrade = class _AppUpgrade extends Command {
     }),
     "log-visibility": Flags2.string({
       required: false,
-      description: "Log visibility setting: public, private, or off",
+      description: "Log visibility setting: public, private, or off (non-interactive default: private)",
       options: ["public", "private", "off"],
       env: "ECLOUD_LOG_VISIBILITY"
     }),
@@ -1735,7 +1913,7 @@ var AppUpgrade = class _AppUpgrade extends Command {
     }),
     "resource-usage-monitoring": Flags2.string({
       required: false,
-      description: "Resource usage monitoring: enable or disable",
+      description: "Resource usage monitoring: enable or disable (non-interactive default: disable)",
       options: ["enable", "disable"],
       env: "ECLOUD_RESOURCE_USAGE_MONITORING"
     }),
@@ -1773,19 +1951,50 @@ var AppUpgrade = class _AppUpgrade extends Command {
     }),
     force: Flags2.boolean({
       description: "Skip all confirmation prompts",
-      default: false
+      default: false,
+      env: "ECLOUD_FORCE"
+    }),
+    "watch-timeout": Flags2.integer({
+      description: "Maximum seconds to wait for the upgrade to complete before returning a recovery hint (default: 600)",
+      env: "ECLOUD_WATCH_TIMEOUT_SECONDS"
     })
   };
   async run() {
     return withTelemetry(this, async () => {
       const { args, flags } = await this.parse(_AppUpgrade);
+      const appIdInput = args["app-id"] ?? process.env.ECLOUD_APP_ID;
+      const nonInteractive = isNonInteractive(flags);
+      if (nonInteractive) {
+        const missing = collectMissingRequiredInputs(
+          {
+            imageRef: flags["image-ref"],
+            dockerfile: flags.dockerfile,
+            verifiable: flags.verifiable,
+            repo: flags.repo,
+            commit: flags.commit
+          },
+          "app-id"
+        );
+        if (!appIdInput) {
+          missing.push("app-id (positional arg or ECLOUD_APP_ID)");
+        }
+        if (missing.length > 0) {
+          const { message, exit } = stageFailure(
+            "upgrade",
+            "invalid-input",
+            `Missing required input(s) for non-interactive upgrade:
+  - ${missing.join("\n  - ")}`
+          );
+          this.error(message, { exit });
+        }
+      }
       const compute = await createComputeClient(flags);
       const environment = flags.environment;
       const environmentConfig = getEnvironmentConfig4(environment);
       const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
       const privateKey = flags["private-key"];
       const appID = await getOrPromptAppID({
-        appID: args["app-id"],
+        appID: appIdInput,
         environment,
         privateKey,
         rpcUrl,
@@ -1846,7 +2055,7 @@ var AppUpgrade = class _AppUpgrade extends Command {
           buildContextPath: flags["build-context"],
           dependencies: flags["build-dependencies"]
         } : await promptVerifiableGitSourceInputs();
-        envFilePath = await getEnvFileInteractive(flags["env-file"]);
+        envFilePath = await getEnvFile(flags["env-file"], nonInteractive);
         const includeTlsCaddyfile = isTlsEnabledFromEnvFile(envFilePath);
         if (includeTlsCaddyfile && !inputs.caddyfilePath) {
           inputs.caddyfilePath = "Caddyfile";
@@ -1906,10 +2115,11 @@ var AppUpgrade = class _AppUpgrade extends Command {
         }
       }
       const isVerifiable = verifiableMode !== "none";
-      const dockerfilePath = isVerifiable ? "" : await getDockerfileInteractive(flags.dockerfile);
+      const deployExistingImageRef = !!flags["image-ref"] && !flags.dockerfile;
+      const dockerfilePath = isVerifiable || deployExistingImageRef ? "" : await getDockerfile(flags.dockerfile, nonInteractive);
       const buildFromDockerfile = dockerfilePath !== "";
       const imageRef = verifiableImageUrl ? verifiableImageUrl : await getImageReferenceInteractive(flags["image-ref"], buildFromDockerfile);
-      envFilePath = envFilePath ?? await getEnvFileInteractive(flags["env-file"]);
+      envFilePath = envFilePath ?? await getEnvFile(flags["env-file"], nonInteractive);
       if (flags.env && flags.env.length > 0) {
         envFilePath = mergeInlineEnvVars(envFilePath, flags.env);
       }
@@ -1920,7 +2130,7 @@ var AppUpgrade = class _AppUpgrade extends Command {
       });
       let currentInstanceType = "";
       try {
-        const userApiClient = new UserApiClient3(environmentConfig, walletClient, publicClient, {
+        const userApiClient = new UserApiClient4(environmentConfig, walletClient, publicClient, {
           clientId: getClientId()
         });
         const infos = await userApiClient.getInfos([appID], 1);
@@ -1935,33 +2145,43 @@ var AppUpgrade = class _AppUpgrade extends Command {
         privateKey,
         rpcUrl
       );
-      const instanceType = await getInstanceTypeInteractive(
+      const instanceType = await getInstanceType(
         flags["instance-type"],
         currentInstanceType,
-        availableTypes
+        availableTypes,
+        nonInteractive
       );
-      const logSettings = await getLogSettingsInteractive(
-        flags["log-visibility"]
+      const logSettings = await getLogSettings(
+        flags["log-visibility"],
+        nonInteractive
       );
-      const resourceUsageMonitoring = await getResourceUsageMonitoringInteractive(
-        flags["resource-usage-monitoring"]
+      const resourceUsageMonitoring = await getResourceUsageMonitoring(
+        flags["resource-usage-monitoring"],
+        nonInteractive
       );
       const logVisibility = logSettings.publicLogs ? "public" : logSettings.logRedirect ? "private" : "off";
-      const { prepared, gasEstimate } = verifiableMode === "git" ? await compute.app.prepareUpgradeFromVerifiableBuild(appID, {
-        imageRef,
-        imageDigest: verifiableImageDigest,
-        envFile: envFilePath,
-        instanceType,
-        logVisibility,
-        resourceUsageMonitoring
-      }) : await compute.app.prepareUpgrade(appID, {
-        dockerfile: dockerfilePath,
-        imageRef,
-        envFile: envFilePath,
-        instanceType,
-        logVisibility,
-        resourceUsageMonitoring
-      });
+      let prepared;
+      let gasEstimate;
+      try {
+        ({ prepared, gasEstimate } = verifiableMode === "git" ? await compute.app.prepareUpgradeFromVerifiableBuild(appID, {
+          imageRef,
+          imageDigest: verifiableImageDigest,
+          envFile: envFilePath,
+          instanceType,
+          logVisibility,
+          resourceUsageMonitoring
+        }) : await compute.app.prepareUpgrade(appID, {
+          dockerfile: dockerfilePath,
+          imageRef,
+          envFile: envFilePath,
+          instanceType,
+          logVisibility,
+          resourceUsageMonitoring
+        }));
+      } catch (err) {
+        const { message, exit } = stageFailure("upgrade", "build", err);
+        this.error(message, { exit });
+      }
       const finalTx = await applyTxOverrides(gasEstimate, flags, { publicClient, address });
       if (flags["max-fee-per-gas"] || flags["max-priority-fee"]) {
         this.log(
@@ -1984,8 +2204,39 @@ ${chalk2.gray(`Upgrade cancelled`)}`);
           return;
         }
       }
-      const res = await compute.app.executeUpgrade(prepared, finalTx);
-      await compute.app.watchUpgrade(res.appId);
+      let res;
+      try {
+        res = await compute.app.executeUpgrade(prepared, finalTx);
+      } catch (err) {
+        const { message, exit } = stageFailure("upgrade", "onchain", err);
+        this.error(message, { exit });
+      }
+      try {
+        await compute.app.watchUpgrade(res.appId, { timeoutSeconds: flags["watch-timeout"] });
+      } catch (err) {
+        if (err instanceof WatchTimeoutError) {
+          this.log("");
+          this.log(
+            chalk2.yellow(
+              `Timed out after ${err.elapsedSeconds}s waiting for upgrade to complete (last status: ${err.lastStatus ?? "unknown"}).`
+            )
+          );
+          this.log(chalk2.gray("The on-chain transaction was submitted; the orchestrator may"));
+          this.log(chalk2.gray("still be processing. To check the current status, run:"));
+          this.log("");
+          this.log(`  ${chalk2.cyan(`ecloud compute app info ${res.appId}`)}`);
+          this.log("");
+          this.log(chalk2.gray(`appId:  ${res.appId}`));
+          this.log(chalk2.gray(`txHash: ${res.txHash}`));
+          this.log(
+            chalk2.gray(
+              `(override the watch deadline with ECLOUD_WATCH_TIMEOUT_SECONDS, currently ${err.timeoutSeconds}s)`
+            )
+          );
+          this.exit(1);
+        }
+        throw err;
+      }
       try {
         const cwd = process.env.INIT_CWD || process.cwd();
         setLinkedAppForDirectory(environment, cwd, res.appId);
@@ -2003,7 +2254,7 @@ ${chalk2.gray(`Upgrade cancelled`)}`);
             rpcUrl,
             environment
           });
-          const userApiClient = new UserApiClient3(environmentConfig, walletClient2, publicClient2, {
+          const userApiClient = new UserApiClient4(environmentConfig, walletClient2, publicClient2, {
             clientId: getClientId()
           });
           const infos = await userApiClient.getInfos([res.appId], 1);
@@ -2032,26 +2283,6 @@ Note: "Running" means the container started. Verify your app is serving traffic
     });
   }
 };
-async function fetchAvailableInstanceTypes(environment, environmentConfig, privateKey, rpcUrl) {
-  try {
-    const { publicClient, walletClient } = createViemClients({
-      privateKey,
-      rpcUrl,
-      environment
-    });
-    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");
-    }
-    return skuList.skus;
-  } catch (err) {
-    console.warn(`Failed to fetch instance types: ${err.message}`);
-    return [{ sku: "g1-standard-4t", description: "4 vCPUs, 16 GB memory, TDX" }];
-  }
-}
 export {
   AppUpgrade as default
 };