@layr-labs/ecloud-cli 1.0.0-dev.6 → 1.0.0-dev.8

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 getEnvironmentConfig4, UserApiClient as UserApiClient3, isMainnet } from "@layr-labs/ecloud-sdk";
+import { getEnvironmentConfig as getEnvironmentConfig4, isMainnet, WatchTimeoutError } from "@layr-labs/ecloud-sdk";
 
 // src/telemetry.ts
 import {
@@ -304,7 +304,7 @@ function findAvailableName(environment, baseName) {
 
 // src/utils/version.ts
 function getCliVersion() {
-  return true ? "1.0.0-dev.6" : "0.0.0";
+  return true ? "1.0.0-dev.8" : "0.0.0";
 }
 function getClientId() {
   return `ecloud-cli/v${getCliVersion()}`;
@@ -319,7 +319,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;
   }
@@ -328,6 +351,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}`);
@@ -784,13 +811,17 @@ async function getOrPromptAppName(appName, environment, imageRef, suggestedBaseN
   }
   return getAvailableAppNameInteractive(environment, imageRef, suggestedBaseName, skipDefaultName);
 }
-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.");
@@ -818,6 +849,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;
@@ -834,7 +866,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) {
@@ -843,6 +875,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);
@@ -874,7 +920,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":
@@ -889,6 +935,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?",
@@ -909,7 +959,7 @@ async function getLogSettingsInteractive(logVisibility) {
       throw new Error(`Unexpected choice: ${choice}`);
   }
 }
-async function getResourceUsageMonitoringInteractive(resourceUsageMonitoring) {
+async function getResourceUsageMonitoring(resourceUsageMonitoring, nonInteractive = false) {
   if (resourceUsageMonitoring) {
     switch (resourceUsageMonitoring) {
       case "enable":
@@ -921,6 +971,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?",
@@ -936,9 +990,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,
@@ -1257,7 +1309,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,
@@ -1287,6 +1339,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) {
@@ -1320,7 +1378,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;
     }
@@ -1344,7 +1404,7 @@ import {
   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);
@@ -1366,8 +1426,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) {
@@ -1393,6 +1454,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/deploy.ts
 import chalk2 from "chalk";
 
@@ -1554,8 +1638,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";
@@ -1620,6 +1759,39 @@ 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/deploy.ts
 var AppDeploy = class _AppDeploy extends Command {
   static description = "Deploy new app";
@@ -1653,7 +1825,7 @@ var AppDeploy = class _AppDeploy 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"
     }),
@@ -1669,7 +1841,7 @@ var AppDeploy = class _AppDeploy 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"
     }),
@@ -1723,12 +1895,40 @@ var AppDeploy = class _AppDeploy 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 app to start before returning a recovery hint (default: 600)",
+      env: "ECLOUD_WATCH_TIMEOUT_SECONDS"
     })
   };
   async run() {
     return withTelemetry(this, async () => {
       const { flags } = await this.parse(_AppDeploy);
+      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,
+            name: flags.name
+          },
+          "name"
+        );
+        if (missing.length > 0) {
+          const { message, exit } = stageFailure(
+            "deploy",
+            "invalid-input",
+            `Missing required input(s) for non-interactive deploy:
+  - ${missing.join("\n  - ")}`
+          );
+          this.error(message, { exit });
+        }
+      }
       const compute = await createComputeClient(flags);
       const environment = flags.environment;
       const environmentConfig = getEnvironmentConfig4(environment);
@@ -1831,7 +2031,7 @@ Warning: Wallet ${chalk2.bold(address)} has zero balance on ${environment}.`
           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";
@@ -1893,7 +2093,8 @@ Warning: Wallet ${chalk2.bold(address)} has zero balance on ${environment}.`
         }
       }
       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);
       const appName = await getOrPromptAppName(
@@ -1903,7 +2104,7 @@ Warning: Wallet ${chalk2.bold(address)} has zero balance on ${environment}.`
         suggestedAppBaseName,
         skipDefaultAppName
       );
-      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);
       }
@@ -1913,38 +2114,48 @@ Warning: Wallet ${chalk2.bold(address)} has zero balance on ${environment}.`
         privateKey,
         rpcUrl
       );
-      const instanceType = await getInstanceTypeInteractive(
+      const instanceType = await getInstanceType(
         flags["instance-type"],
         "",
-        // No default for new deployments
-        availableTypes
+        // No pinned default for new deployments; non-interactive falls back to g1-standard-2s
+        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.prepareDeployFromVerifiableBuild({
-        name: appName,
-        imageRef,
-        imageDigest: verifiableImageDigest,
-        envFile: envFilePath,
-        instanceType,
-        logVisibility,
-        resourceUsageMonitoring,
-        billTo: "developer"
-      }) : await compute.app.prepareDeploy({
-        name: appName,
-        dockerfile: dockerfilePath,
-        imageRef,
-        envFile: envFilePath,
-        instanceType,
-        logVisibility,
-        resourceUsageMonitoring,
-        billTo: "developer"
-      });
+      let prepared;
+      let gasEstimate;
+      try {
+        ({ prepared, gasEstimate } = verifiableMode === "git" ? await compute.app.prepareDeployFromVerifiableBuild({
+          name: appName,
+          imageRef,
+          imageDigest: verifiableImageDigest,
+          envFile: envFilePath,
+          instanceType,
+          logVisibility,
+          resourceUsageMonitoring,
+          billTo: "developer"
+        }) : await compute.app.prepareDeploy({
+          name: appName,
+          dockerfile: dockerfilePath,
+          imageRef,
+          envFile: envFilePath,
+          instanceType,
+          logVisibility,
+          resourceUsageMonitoring,
+          billTo: "developer"
+        }));
+      } catch (err) {
+        const { message, exit } = stageFailure("deploy", "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(
@@ -1967,7 +2178,13 @@ ${chalk2.gray(`Deployment cancelled`)}`);
           return;
         }
       }
-      const res = await compute.app.executeDeploy(prepared, finalTx);
+      let res;
+      try {
+        res = await compute.app.executeDeploy(prepared, finalTx);
+      } catch (err) {
+        const { message, exit } = stageFailure("deploy", "onchain", err);
+        this.error(message, { exit });
+      }
       if (!flags["skip-profile"]) {
         const hasProfileFlags = flags.website || flags.description || flags["x-url"] || flags.image;
         let profile = null;
@@ -2010,7 +2227,42 @@ ${chalk2.gray(`Deployment cancelled`)}`);
           }
         }
       }
-      const ipAddress = await compute.app.watchDeployment(res.appId);
+      let ipAddress;
+      try {
+        ipAddress = await compute.app.watchDeployment(res.appId, {
+          timeoutSeconds: flags["watch-timeout"]
+        });
+      } catch (watchErr) {
+        if (watchErr instanceof WatchTimeoutError) {
+          this.log(
+            `
+${chalk2.yellow("\u26A0")} ${chalk2.yellow(
+              `Deployment did not reach Running within ${watchErr.elapsedSeconds}s (last status: ${watchErr.lastStatus ?? "unknown"}).`
+            )}`
+          );
+          this.log(
+            chalk2.gray(
+              `The deploy transaction succeeded, but the orchestrator hasn't reported the app as Running yet.`
+            )
+          );
+          this.log(chalk2.gray(`  appId:  ${res.appId}`));
+          if (res.txHash) {
+            this.log(chalk2.gray(`  txHash: ${res.txHash}`));
+          }
+          this.log(
+            chalk2.gray(
+              `Check progress later with: ${chalk2.cyan(`ecloud compute app info ${res.appId}`)}`
+            )
+          );
+          this.log(
+            chalk2.gray(
+              `Override the watch timeout with the ${chalk2.cyan("ECLOUD_WATCH_TIMEOUT_SECONDS")} environment variable.`
+            )
+          );
+          this.exit(1);
+        }
+        throw watchErr;
+      }
       try {
         const cwd = process.env.INIT_CWD || process.cwd();
         setLinkedAppForDirectory(environment, cwd, res.appId);
@@ -2036,26 +2288,6 @@ Note: "Running" means the container started \u2014 verify it 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 {
   AppDeploy as default
 };