@layr-labs/ecloud-sdk 0.1.0-rc.1 → 0.1.0

package/dist/index.cjs

@@ -30,17 +30,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  NoopClient: () => NoopClient,
   PRIMARY_LANGUAGES: () => PRIMARY_LANGUAGES,
+  PostHogClient: () => PostHogClient,
   UserApiClient: () => UserApiClient,
+  addMetric: () => addMetric,
+  addMetricWithDimensions: () => addMetricWithDimensions,
   assertValidFilePath: () => assertValidFilePath,
   assertValidImageReference: () => assertValidImageReference,
   assertValidPrivateKey: () => assertValidPrivateKey,
+  checkERC7702Delegation: () => checkERC7702Delegation,
   createApp: () => createApp,
-  createAppModule: () => createAppModule,
+  createAppEnvironment: () => createAppEnvironment,
   createBillingModule: () => createBillingModule,
+  createComputeModule: () => createComputeModule,
   createECloudClient: () => createECloudClient,
+  createMetricsContext: () => createMetricsContext,
+  createTelemetryClient: () => createTelemetryClient,
   deleteLegacyPrivateKey: () => deleteLegacyPrivateKey,
   deletePrivateKey: () => deletePrivateKey,
+  emitMetrics: () => emitMetrics,
   encodeStartAppData: () => encodeStartAppData,
   encodeStopAppData: () => encodeStopAppData,
   encodeTerminateAppData: () => encodeTerminateAppData,
@@ -64,11 +73,14 @@ __export(index_exports, {
   getEnvironmentConfig: () => getEnvironmentConfig,
   getLegacyKeys: () => getLegacyKeys,
   getLegacyPrivateKey: () => getLegacyPrivateKey,
+  getPostHogAPIKey: () => getPostHogAPIKey,
+  getPostHogEndpoint: () => getPostHogEndpoint,
   getPrivateKey: () => getPrivateKey,
   getPrivateKeyWithSource: () => getPrivateKeyWithSource,
   getTemplate: () => getTemplate,
   isEnvironmentAvailable: () => isEnvironmentAvailable,
   isMainnet: () => isMainnet,
+  isNoopClient: () => isNoopClient,
   isSubscriptionActive: () => isSubscriptionActive,
   keyExists: () => keyExists,
   listStoredKeys: () => listStoredKeys,
@@ -98,11 +110,12 @@ __export(index_exports, {
   validateUpgradeParams: () => validateUpgradeParams,
   validateXURL: () => validateXURL,
   watchDeployment: () => watchDeployment,
-  watchUpgrade: () => watchUpgrade
+  watchUpgrade: () => watchUpgrade,
+  withSDKTelemetry: () => withSDKTelemetry
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/client/modules/app/index.ts
+// src/client/modules/compute/app/index.ts
 var import_viem9 = require("viem");
 
 // src/client/common/config/environment.ts
@@ -337,10 +350,10 @@ async function checkIfImageAlreadyLayeredForECloud(docker, imageTag) {
     return false;
   }
 }
-async function pullDockerImage(docker, imageTag, platform = "linux/amd64", logger) {
+async function pullDockerImage(docker, imageTag, platform2 = "linux/amd64", logger) {
   logger?.info?.(`Pulling image ${imageTag}...`);
   return new Promise((resolve2, reject) => {
-    docker.pull(imageTag, { platform }, (err, stream) => {
+    docker.pull(imageTag, { platform: platform2 }, (err, stream) => {
       if (err) {
         reject(new Error(`Failed to pull image ${imageTag}: ${err.message}`));
         return;
@@ -936,9 +949,9 @@ function extractDigestFromMultiPlatform(manifest, imageRef) {
   const platforms = [];
   for (const m of manifest.manifests) {
     if (m.platform) {
-      const platform = `${m.platform.os}/${m.platform.architecture}`;
-      platforms.push(platform);
-      if (platform === DOCKER_PLATFORM) {
+      const platform2 = `${m.platform.os}/${m.platform.architecture}`;
+      platforms.push(platform2);
+      if (platform2 === DOCKER_PLATFORM) {
         const digest = hexStringToBytes32(m.digest);
         const registry = extractRegistryName(imageRef);
         return {
@@ -953,7 +966,7 @@ function extractDigestFromMultiPlatform(manifest, imageRef) {
 }
 async function extractDigestFromSinglePlatform(manifest, imageRef) {
   try {
-    const { stdout } = await execFile("docker", ["inspect", imageRef], {
+    const { stdout } = await execFileAsync("docker", ["inspect", imageRef], {
       maxBuffer: 10 * 1024 * 1024
     });
     const inspectData = JSON.parse(stdout);
@@ -976,8 +989,8 @@ async function extractDigestFromSinglePlatform(manifest, imageRef) {
       }
       throw new Error(`Could not determine platform for ${imageRef}`);
     }
-    const platform = `${config.os}/${config.architecture}`;
-    if (platform === DOCKER_PLATFORM) {
+    const platform2 = `${config.os}/${config.architecture}`;
+    if (platform2 === DOCKER_PLATFORM) {
       let digest;
       if (inspectData[0].RepoDigests && inspectData[0].RepoDigests.length > 0) {
         const repoDigest = inspectData[0].RepoDigests[0];
@@ -994,7 +1007,7 @@ async function extractDigestFromSinglePlatform(manifest, imageRef) {
         platform: DOCKER_PLATFORM
       };
     }
-    throw createPlatformErrorMessage(imageRef, [platform]);
+    throw createPlatformErrorMessage(imageRef, [platform2]);
   } catch (error) {
     if (error.message.includes("platform")) {
       throw error;
@@ -1217,7 +1230,7 @@ Please verify the image exists: docker manifest inspect ${finalImageRef}`
   } else {
     logger.info("Continuing without environment file");
   }
-  publicEnv["EIGEN_MACHINE_TYPE"] = instanceType;
+  publicEnv["EIGEN_MACHINE_TYPE_PUBLIC"] = instanceType;
   logger.info(`Instance type: ${instanceType}`);
   logger.info("Encrypting environment variables...");
   const { encryptionKey } = getKMSKeysForEnvironment(
@@ -2354,13 +2367,13 @@ async function executeBatch(options, logger) {
     );
     executeBatchData = (0, import_viem.concat)([selector, encodedParams]);
   }
-  const isDelegated = await checkERC7702Delegation(
+  const isDelegated2 = await checkERC7702Delegation(
     publicClient,
     account.address,
     environmentConfig.erc7702DelegatorAddress
   );
   let authorizationList = [];
-  if (!isDelegated) {
+  if (!isDelegated2) {
     const transactionNonce = await publicClient.getTransactionCount({
       address: account.address,
       blockTag: "pending"
@@ -2512,7 +2525,7 @@ var CanViewAppLogsPermission = "0x2fd3f2fe";
 var CanViewSensitiveAppInfoPermission = "0x0e67b22f";
 var CanUpdateAppProfilePermission = "0x036fef61";
 function getDefaultClientId() {
-  const version = true ? "0.1.0-rc.1" : "0.0.0";
+  const version = true ? "0.1.0" : "0.0.0";
   return `ecloud-sdk/v${version}`;
 }
 var UserApiClient = class {
@@ -4768,6 +4781,21 @@ async function getBlockTimestamps(rpcUrl, environmentConfig, blockNumbers) {
   }
   return timestamps;
 }
+async function isDelegated(options) {
+  const { privateKey, rpcUrl, environmentConfig } = options;
+  const privateKeyHex = addHexPrefix(privateKey);
+  const account = (0, import_accounts2.privateKeyToAccount)(privateKeyHex);
+  const chain = getChainFromID(environmentConfig.chainID);
+  const publicClient = (0, import_viem5.createPublicClient)({
+    chain,
+    transport: (0, import_viem5.http)(rpcUrl)
+  });
+  return checkERC7702Delegation(
+    publicClient,
+    account.address,
+    environmentConfig.erc7702DelegatorAddress
+  );
+}
 async function undelegate(options, logger) {
   const { privateKey, rpcUrl, environmentConfig } = options;
   const privateKeyHex = addHexPrefix(privateKey);
@@ -4900,7 +4928,7 @@ async function watchUntilUpgradeComplete(options, logger) {
       if (status === APP_STATUS_STOPPED && ip) {
         logger.info("App upgrade complete.");
         logger.info(`Status: ${status}`);
-        logger.info(`To start the app, run: eigenx app start ${appId}`);
+        logger.info(`To start the app, run: ecloud compute app start ${appId}`);
         return true;
       }
     }
@@ -4910,7 +4938,7 @@ async function watchUntilUpgradeComplete(options, logger) {
     if (status === APP_STATUS_STOPPED && ip && hasChanged) {
       logger.info("App upgrade complete.");
       logger.info(`Status: ${status}`);
-      logger.info(`To start the app, run: eigenx app start ${appId}`);
+      logger.info(`To start the app, run: ecloud compute app start ${appId}`);
       return true;
     }
     if (status === APP_STATUS_RUNNING && ip && hasChanged) {
@@ -5309,7 +5337,202 @@ function validatePrivateKey(key) {
   }
 }
 
-// src/client/modules/app/deploy.ts
+// src/client/common/telemetry/noop.ts
+var NoopClient = class {
+  /**
+   * AddMetric implements the TelemetryClient interface
+   */
+  async addMetric(_metric) {
+  }
+  /**
+   * Close implements the TelemetryClient interface
+   */
+  async close() {
+  }
+};
+function isNoopClient(client) {
+  return client instanceof NoopClient;
+}
+
+// src/client/common/telemetry/posthog.ts
+var import_posthog_node = require("posthog-node");
+var PostHogClient = class {
+  constructor(environment, namespace, apiKey, endpoint) {
+    this.namespace = namespace;
+    this.appEnvironment = environment;
+    const host = endpoint || "https://us.i.posthog.com";
+    this.client = new import_posthog_node.PostHog(apiKey, {
+      host,
+      flushAt: 1,
+      // Flush immediately for CLI/SDK usage
+      flushInterval: 0
+      // Disable interval flushing
+    });
+    this.client.identify({
+      distinctId: environment.userUUID,
+      properties: {
+        os: environment.os,
+        arch: environment.arch,
+        ...environment.cliVersion ? { cliVersion: environment.cliVersion } : {}
+      }
+    });
+  }
+  /**
+   * AddMetric implements the TelemetryClient interface
+   */
+  async addMetric(metric) {
+    try {
+      const props = {
+        name: metric.name,
+        value: metric.value
+      };
+      for (const [k, v] of Object.entries(metric.dimensions)) {
+        props[k] = v;
+      }
+      this.client.capture({
+        distinctId: this.appEnvironment.userUUID,
+        event: this.namespace,
+        properties: props
+      });
+    } catch {
+    }
+  }
+  /**
+   * Close implements the TelemetryClient interface
+   */
+  async close() {
+    try {
+      this.client.shutdown();
+    } catch {
+    }
+  }
+};
+function getPostHogAPIKey() {
+  if (process.env.ECLOUD_POSTHOG_KEY) {
+    return process.env.ECLOUD_POSTHOG_KEY;
+  }
+  return true ? "phc_BiKfywNft5iBI8N7MxmuVCkb4GGZj4mDFXYPmOPUAI8" : void 0;
+}
+function getPostHogEndpoint() {
+  return process.env.ECLOUD_POSTHOG_ENDPOINT || "https://us.i.posthog.com";
+}
+
+// src/client/common/telemetry/index.ts
+var os2 = __toESM(require("os"), 1);
+
+// src/client/common/telemetry/metricsContext.ts
+function createMetricsContext() {
+  return {
+    startTime: /* @__PURE__ */ new Date(),
+    metrics: [],
+    properties: {}
+  };
+}
+function addMetric(context, name, value) {
+  addMetricWithDimensions(context, name, value, {});
+}
+function addMetricWithDimensions(context, name, value, dimensions) {
+  context.metrics.push({
+    name,
+    value,
+    dimensions
+  });
+}
+
+// src/client/common/telemetry/index.ts
+function createTelemetryClient(environment, namespace, options) {
+  const telemetryEnabled = options?.telemetryEnabled === true;
+  if (!telemetryEnabled) {
+    return new NoopClient();
+  }
+  const resolvedApiKey = options?.apiKey || getPostHogAPIKey();
+  if (!resolvedApiKey) {
+    return new NoopClient();
+  }
+  const endpoint = options?.endpoint || getPostHogEndpoint();
+  try {
+    return new PostHogClient(environment, namespace, resolvedApiKey, endpoint);
+  } catch {
+    return new NoopClient();
+  }
+}
+function createAppEnvironment(userUUID, cliVersion, osOverride, archOverride) {
+  return {
+    userUUID,
+    cliVersion,
+    os: osOverride || os2.platform(),
+    arch: archOverride || os2.arch()
+  };
+}
+async function emitMetrics(client, context) {
+  if (isNoopClient(client)) {
+    return;
+  }
+  for (const metric of context.metrics) {
+    const dimensions = {
+      ...metric.dimensions,
+      ...context.properties
+    };
+    const metricWithProperties = {
+      ...metric,
+      dimensions
+    };
+    try {
+      await client.addMetric(metricWithProperties);
+    } catch {
+    }
+  }
+}
+
+// src/client/common/telemetry/wrapper.ts
+var import_crypto = require("crypto");
+function generateRandomUUID() {
+  return (0, import_crypto.randomUUID)();
+}
+async function withSDKTelemetry(options, action) {
+  if (options.skipTelemetry) {
+    return action();
+  }
+  const userUUID = options.userUUID || generateRandomUUID();
+  const environment = createAppEnvironment(userUUID);
+  const client = createTelemetryClient(environment, "ecloud-sdk", {
+    telemetryEnabled: options.telemetryEnabled,
+    apiKey: options.apiKey,
+    endpoint: options.endpoint
+  });
+  const metrics = createMetricsContext();
+  metrics.properties["source"] = "ecloud-sdk";
+  metrics.properties["function"] = options.functionName;
+  if (options.properties) {
+    Object.assign(metrics.properties, options.properties);
+  }
+  addMetric(metrics, "Count", 1);
+  let actionError;
+  let result;
+  try {
+    result = await action();
+    return result;
+  } catch (err) {
+    actionError = err instanceof Error ? err : new Error(String(err));
+    throw err;
+  } finally {
+    const resultValue = actionError ? "Failure" : "Success";
+    const dimensions = {};
+    if (actionError) {
+      dimensions["error"] = actionError.message;
+    }
+    addMetricWithDimensions(metrics, resultValue, 1, dimensions);
+    const duration = Date.now() - metrics.startTime.getTime();
+    addMetric(metrics, "DurationMilliseconds", duration);
+    try {
+      await emitMetrics(client, metrics);
+      await client.close();
+    } catch {
+    }
+  }
+}
+
+// src/client/modules/compute/app/deploy.ts
 function validateDeployOptions(options) {
   if (!options.privateKey) {
     throw new Error("privateKey is required for deployment");
@@ -5336,84 +5559,95 @@ function validateDeployOptions(options) {
   validateLogVisibility(options.logVisibility);
 }
 async function deploy(options, logger = defaultLogger) {
-  validateDeployOptions(options);
-  const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
-  const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
-  logger.debug("Performing preflight checks...");
-  const preflightCtx = await doPreflightChecks(
-    {
-      privateKey: options.privateKey,
-      rpcUrl: options.rpcUrl,
-      environment: options.environment
-    },
-    logger
-  );
-  logger.debug("Checking quota availability...");
-  await checkQuotaAvailable(preflightCtx);
-  logger.debug("Checking Docker...");
-  await ensureDockerIsRunning();
-  const dockerfilePath = options.dockerfilePath || "";
-  const imageRef = options.imageRef || "";
-  const appName = options.appName;
-  const envFilePath = options.envFilePath || "";
-  const instanceType = options.instanceType;
-  const salt = generateRandomSalt();
-  logger.debug(`Generated salt: ${Buffer.from(salt).toString("hex")}`);
-  logger.debug("Calculating app ID...");
-  const appIDToBeDeployed = await calculateAppID(
-    preflightCtx.privateKey,
-    options.rpcUrl || preflightCtx.rpcUrl,
-    preflightCtx.environmentConfig,
-    salt
-  );
-  logger.info(``);
-  logger.info(`App ID: ${appIDToBeDeployed}`);
-  logger.info(``);
-  logger.info("Preparing release...");
-  const { release, finalImageRef } = await prepareRelease(
-    {
-      dockerfilePath,
-      imageRef,
-      envFilePath,
-      logRedirect,
-      resourceUsageAllow,
-      instanceType,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: appIDToBeDeployed
-    },
-    logger
-  );
-  logger.info("Deploying on-chain...");
-  const deployResult = await deployApp(
+  return withSDKTelemetry(
     {
-      privateKey: preflightCtx.privateKey,
-      rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
-      environmentConfig: preflightCtx.environmentConfig,
-      salt,
-      release,
-      publicLogs,
-      imageRef: finalImageRef,
-      gas: options.gas
-    },
-    logger
-  );
-  logger.info("Waiting for app to start...");
-  const ipAddress = await watchUntilRunning(
-    {
-      privateKey: preflightCtx.privateKey,
-      rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: deployResult.appId
+      functionName: "deploy",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        environment: options.environment || "sepolia"
+      }
     },
-    logger
+    async () => {
+      validateDeployOptions(options);
+      const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
+      const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
+      logger.debug("Performing preflight checks...");
+      const preflightCtx = await doPreflightChecks(
+        {
+          privateKey: options.privateKey,
+          rpcUrl: options.rpcUrl,
+          environment: options.environment
+        },
+        logger
+      );
+      logger.debug("Checking quota availability...");
+      await checkQuotaAvailable(preflightCtx);
+      logger.debug("Checking Docker...");
+      await ensureDockerIsRunning();
+      const dockerfilePath = options.dockerfilePath || "";
+      const imageRef = options.imageRef || "";
+      const appName = options.appName;
+      const envFilePath = options.envFilePath || "";
+      const instanceType = options.instanceType;
+      const salt = generateRandomSalt();
+      logger.debug(`Generated salt: ${Buffer.from(salt).toString("hex")}`);
+      logger.debug("Calculating app ID...");
+      const appIDToBeDeployed = await calculateAppID(
+        preflightCtx.privateKey,
+        options.rpcUrl || preflightCtx.rpcUrl,
+        preflightCtx.environmentConfig,
+        salt
+      );
+      logger.info(``);
+      logger.info(`App ID: ${appIDToBeDeployed}`);
+      logger.info(``);
+      logger.info("Preparing release...");
+      const { release, finalImageRef } = await prepareRelease(
+        {
+          dockerfilePath,
+          imageRef,
+          envFilePath,
+          logRedirect,
+          resourceUsageAllow,
+          instanceType,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appIDToBeDeployed
+        },
+        logger
+      );
+      logger.info("Deploying on-chain...");
+      const deployResult = await deployApp(
+        {
+          privateKey: preflightCtx.privateKey,
+          rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+          environmentConfig: preflightCtx.environmentConfig,
+          salt,
+          release,
+          publicLogs,
+          imageRef: finalImageRef,
+          gas: options.gas
+        },
+        logger
+      );
+      logger.info("Waiting for app to start...");
+      const ipAddress = await watchUntilRunning(
+        {
+          privateKey: preflightCtx.privateKey,
+          rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: deployResult.appId
+        },
+        logger
+      );
+      return {
+        appId: deployResult.appId,
+        txHash: deployResult.txHash,
+        appName,
+        imageRef: finalImageRef,
+        ipAddress
+      };
+    }
   );
-  return {
-    appId: deployResult.appId,
-    txHash: deployResult.txHash,
-    appName,
-    imageRef: finalImageRef,
-    ipAddress
-  };
 }
 async function checkQuotaAvailable(preflightCtx) {
   const rpcUrl = preflightCtx.rpcUrl;
@@ -5427,7 +5661,7 @@ async function checkQuotaAvailable(preflightCtx) {
   }
   if (maxQuota === 0) {
     throw new Error(
-      "no app quota available. Run 'npx ecloud billing subscribe' to enable app deployment"
+      "no app quota available. Run 'ecloud billing subscribe' to enable app deployment"
     );
   }
   let activeCount;
@@ -5448,107 +5682,137 @@ function generateRandomSalt() {
   return salt;
 }
 async function prepareDeploy(options, logger = defaultLogger) {
-  validateDeployOptions(options);
-  const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
-  const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
-  logger.debug("Performing preflight checks...");
-  const preflightCtx = await doPreflightChecks(
+  return withSDKTelemetry(
     {
-      privateKey: options.privateKey,
-      rpcUrl: options.rpcUrl,
-      environment: options.environment
-    },
-    logger
-  );
-  logger.debug("Checking quota availability...");
-  await checkQuotaAvailable(preflightCtx);
-  logger.debug("Checking Docker...");
-  await ensureDockerIsRunning();
-  const dockerfilePath = options.dockerfilePath || "";
-  const imageRef = options.imageRef || "";
-  const appName = options.appName;
-  const envFilePath = options.envFilePath || "";
-  const instanceType = options.instanceType;
-  const salt = generateRandomSalt();
-  logger.debug(`Generated salt: ${Buffer.from(salt).toString("hex")}`);
-  logger.debug("Calculating app ID...");
-  const appIDToBeDeployed = await calculateAppID(
-    preflightCtx.privateKey,
-    options.rpcUrl || preflightCtx.rpcUrl,
-    preflightCtx.environmentConfig,
-    salt
-  );
-  logger.info(``);
-  logger.info(`App ID: ${appIDToBeDeployed}`);
-  logger.info(``);
-  logger.info("Preparing release...");
-  const { release, finalImageRef } = await prepareRelease(
-    {
-      dockerfilePath,
-      imageRef,
-      envFilePath,
-      logRedirect,
-      resourceUsageAllow,
-      instanceType,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: appIDToBeDeployed
+      functionName: "prepareDeploy",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        environment: options.environment || "sepolia"
+      }
     },
-    logger
+    async () => {
+      validateDeployOptions(options);
+      const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
+      const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
+      logger.debug("Performing preflight checks...");
+      const preflightCtx = await doPreflightChecks(
+        {
+          privateKey: options.privateKey,
+          rpcUrl: options.rpcUrl,
+          environment: options.environment
+        },
+        logger
+      );
+      logger.debug("Checking quota availability...");
+      await checkQuotaAvailable(preflightCtx);
+      logger.debug("Checking Docker...");
+      await ensureDockerIsRunning();
+      const dockerfilePath = options.dockerfilePath || "";
+      const imageRef = options.imageRef || "";
+      const appName = options.appName;
+      const envFilePath = options.envFilePath || "";
+      const instanceType = options.instanceType;
+      const salt = generateRandomSalt();
+      logger.debug(`Generated salt: ${Buffer.from(salt).toString("hex")}`);
+      logger.debug("Calculating app ID...");
+      const appIDToBeDeployed = await calculateAppID(
+        preflightCtx.privateKey,
+        options.rpcUrl || preflightCtx.rpcUrl,
+        preflightCtx.environmentConfig,
+        salt
+      );
+      logger.info(``);
+      logger.info(`App ID: ${appIDToBeDeployed}`);
+      logger.info(``);
+      logger.info("Preparing release...");
+      const { release, finalImageRef } = await prepareRelease(
+        {
+          dockerfilePath,
+          imageRef,
+          envFilePath,
+          logRedirect,
+          resourceUsageAllow,
+          instanceType,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appIDToBeDeployed
+        },
+        logger
+      );
+      logger.debug("Preparing deploy batch...");
+      const batch = await prepareDeployBatch(
+        {
+          privateKey: preflightCtx.privateKey,
+          rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+          environmentConfig: preflightCtx.environmentConfig,
+          salt,
+          release,
+          publicLogs
+        },
+        logger
+      );
+      logger.debug("Estimating gas...");
+      const gasEstimate = await estimateBatchGas({
+        publicClient: batch.publicClient,
+        environmentConfig: batch.environmentConfig,
+        executions: batch.executions
+      });
+      return {
+        prepared: {
+          batch,
+          appName,
+          imageRef: finalImageRef,
+          preflightCtx: {
+            privateKey: preflightCtx.privateKey,
+            rpcUrl: preflightCtx.rpcUrl,
+            environmentConfig: preflightCtx.environmentConfig
+          }
+        },
+        gasEstimate
+      };
+    }
   );
-  logger.debug("Preparing deploy batch...");
-  const batch = await prepareDeployBatch(
+}
+async function executeDeploy(prepared, gas, logger = defaultLogger, skipTelemetry) {
+  return withSDKTelemetry(
     {
-      privateKey: preflightCtx.privateKey,
-      rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
-      environmentConfig: preflightCtx.environmentConfig,
-      salt,
-      release,
-      publicLogs
+      functionName: "executeDeploy",
+      skipTelemetry
     },
-    logger
+    async () => {
+      logger.info("Deploying on-chain...");
+      const { appId, txHash } = await executeDeployBatch(prepared.batch, gas, logger);
+      return {
+        appId,
+        txHash,
+        appName: prepared.appName,
+        imageRef: prepared.imageRef
+      };
+    }
   );
-  logger.debug("Estimating gas...");
-  const gasEstimate = await estimateBatchGas({
-    publicClient: batch.publicClient,
-    environmentConfig: batch.environmentConfig,
-    executions: batch.executions
-  });
-  return {
-    prepared: {
-      batch,
-      appName,
-      imageRef: finalImageRef,
-      preflightCtx: {
-        privateKey: preflightCtx.privateKey,
-        rpcUrl: preflightCtx.rpcUrl,
-        environmentConfig: preflightCtx.environmentConfig
-      }
-    },
-    gasEstimate
-  };
-}
-async function executeDeploy(prepared, gas, logger = defaultLogger) {
-  logger.info("Deploying on-chain...");
-  const { appId, txHash } = await executeDeployBatch(prepared.batch, gas, logger);
-  return {
-    appId,
-    txHash,
-    appName: prepared.appName,
-    imageRef: prepared.imageRef
-  };
 }
-async function watchDeployment(appId, privateKey, rpcUrl, environment, logger = defaultLogger, clientId) {
-  const environmentConfig = getEnvironmentConfig(environment);
-  logger.info("Waiting for app to start...");
-  return watchUntilRunning(
+async function watchDeployment(appId, privateKey, rpcUrl, environment, logger = defaultLogger, clientId, skipTelemetry) {
+  return withSDKTelemetry(
     {
-      privateKey,
-      rpcUrl,
-      environmentConfig,
-      appId,
-      clientId
+      functionName: "watchDeployment",
+      skipTelemetry,
+      properties: {
+        environment
+      }
     },
-    logger
+    async () => {
+      const environmentConfig = getEnvironmentConfig(environment);
+      logger.info("Waiting for app to start...");
+      return watchUntilRunning(
+        {
+          privateKey,
+          rpcUrl,
+          environmentConfig,
+          appId,
+          clientId
+        },
+        logger
+      );
+    }
   );
 }
 
@@ -5577,7 +5841,7 @@ async function checkAppLogPermission(preflightCtx, appAddress, logger) {
   }
 }
 
-// src/client/modules/app/upgrade.ts
+// src/client/modules/compute/app/upgrade.ts
 function validateUpgradeOptions(options) {
   if (!options.privateKey) {
     throw new Error("privateKey is required for upgrade");
@@ -5605,163 +5869,204 @@ function validateUpgradeOptions(options) {
   return resolvedAppID;
 }
 async function upgrade(options, logger = defaultLogger) {
-  logger.debug("Performing preflight checks...");
-  const preflightCtx = await doPreflightChecks(
-    {
-      privateKey: options.privateKey,
-      rpcUrl: options.rpcUrl,
-      environment: options.environment
-    },
-    logger
-  );
-  const appID = validateUpgradeOptions(options);
-  const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
-  const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
-  logger.debug("Checking Docker...");
-  await ensureDockerIsRunning();
-  const dockerfilePath = options.dockerfilePath || "";
-  const imageRef = options.imageRef || "";
-  const envFilePath = options.envFilePath || "";
-  const instanceType = options.instanceType;
-  logger.info("Preparing release...");
-  const { release, finalImageRef } = await prepareRelease(
-    {
-      dockerfilePath,
-      imageRef,
-      envFilePath,
-      logRedirect,
-      resourceUsageAllow,
-      instanceType,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: appID
-    },
-    logger
-  );
-  logger.debug("Checking current log permission state...");
-  const currentlyPublic = await checkAppLogPermission(preflightCtx, appID, logger);
-  const needsPermissionChange = currentlyPublic !== publicLogs;
-  logger.info("Upgrading on-chain...");
-  const txHash = await upgradeApp(
+  return withSDKTelemetry(
     {
-      privateKey: preflightCtx.privateKey,
-      rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: appID,
-      release,
-      publicLogs,
-      needsPermissionChange,
-      imageRef: finalImageRef,
-      gas: options.gas
-    },
-    logger
-  );
-  logger.info("Waiting for upgrade to complete...");
-  await watchUntilUpgradeComplete(
-    {
-      privateKey: preflightCtx.privateKey,
-      rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: appID
+      functionName: "upgrade",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        environment: options.environment || "sepolia"
+      }
     },
-    logger
+    async () => {
+      logger.debug("Performing preflight checks...");
+      const preflightCtx = await doPreflightChecks(
+        {
+          privateKey: options.privateKey,
+          rpcUrl: options.rpcUrl,
+          environment: options.environment
+        },
+        logger
+      );
+      const appID = validateUpgradeOptions(options);
+      const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
+      const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
+      logger.debug("Checking Docker...");
+      await ensureDockerIsRunning();
+      const dockerfilePath = options.dockerfilePath || "";
+      const imageRef = options.imageRef || "";
+      const envFilePath = options.envFilePath || "";
+      const instanceType = options.instanceType;
+      logger.info("Preparing release...");
+      const { release, finalImageRef } = await prepareRelease(
+        {
+          dockerfilePath,
+          imageRef,
+          envFilePath,
+          logRedirect,
+          resourceUsageAllow,
+          instanceType,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appID
+        },
+        logger
+      );
+      logger.debug("Checking current log permission state...");
+      const currentlyPublic = await checkAppLogPermission(preflightCtx, appID, logger);
+      const needsPermissionChange = currentlyPublic !== publicLogs;
+      logger.info("Upgrading on-chain...");
+      const txHash = await upgradeApp(
+        {
+          privateKey: preflightCtx.privateKey,
+          rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appID,
+          release,
+          publicLogs,
+          needsPermissionChange,
+          imageRef: finalImageRef,
+          gas: options.gas
+        },
+        logger
+      );
+      logger.info("Waiting for upgrade to complete...");
+      await watchUntilUpgradeComplete(
+        {
+          privateKey: preflightCtx.privateKey,
+          rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appID
+        },
+        logger
+      );
+      return {
+        appId: appID,
+        imageRef: finalImageRef,
+        txHash
+      };
+    }
   );
-  return {
-    appId: appID,
-    imageRef: finalImageRef,
-    txHash
-  };
 }
 async function prepareUpgrade(options, logger = defaultLogger) {
-  logger.debug("Performing preflight checks...");
-  const preflightCtx = await doPreflightChecks(
+  return withSDKTelemetry(
     {
-      privateKey: options.privateKey,
-      rpcUrl: options.rpcUrl,
-      environment: options.environment
+      functionName: "prepareUpgrade",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        environment: options.environment || "sepolia"
+      }
     },
-    logger
+    async () => {
+      logger.debug("Performing preflight checks...");
+      const preflightCtx = await doPreflightChecks(
+        {
+          privateKey: options.privateKey,
+          rpcUrl: options.rpcUrl,
+          environment: options.environment
+        },
+        logger
+      );
+      const appID = validateUpgradeOptions(options);
+      const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
+      const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
+      logger.debug("Checking Docker...");
+      await ensureDockerIsRunning();
+      const dockerfilePath = options.dockerfilePath || "";
+      const imageRef = options.imageRef || "";
+      const envFilePath = options.envFilePath || "";
+      const instanceType = options.instanceType;
+      logger.info("Preparing release...");
+      const { release, finalImageRef } = await prepareRelease(
+        {
+          dockerfilePath,
+          imageRef,
+          envFilePath,
+          logRedirect,
+          resourceUsageAllow,
+          instanceType,
+          environmentConfig: preflightCtx.environmentConfig,
+          appId: appID
+        },
+        logger
+      );
+      logger.debug("Checking current log permission state...");
+      const currentlyPublic = await checkAppLogPermission(preflightCtx, appID, logger);
+      const needsPermissionChange = currentlyPublic !== publicLogs;
+      logger.debug("Preparing upgrade batch...");
+      const batch = await prepareUpgradeBatch({
+        privateKey: preflightCtx.privateKey,
+        rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
+        environmentConfig: preflightCtx.environmentConfig,
+        appId: appID,
+        release,
+        publicLogs,
+        needsPermissionChange
+      });
+      logger.debug("Estimating gas...");
+      const gasEstimate = await estimateBatchGas({
+        publicClient: batch.publicClient,
+        environmentConfig: batch.environmentConfig,
+        executions: batch.executions
+      });
+      return {
+        prepared: {
+          batch,
+          appId: appID,
+          imageRef: finalImageRef,
+          preflightCtx: {
+            privateKey: preflightCtx.privateKey,
+            rpcUrl: preflightCtx.rpcUrl,
+            environmentConfig: preflightCtx.environmentConfig
+          }
+        },
+        gasEstimate
+      };
+    }
   );
-  const appID = validateUpgradeOptions(options);
-  const { logRedirect, publicLogs } = validateLogVisibility(options.logVisibility);
-  const resourceUsageAllow = validateResourceUsageMonitoring(options.resourceUsageMonitoring);
-  logger.debug("Checking Docker...");
-  await ensureDockerIsRunning();
-  const dockerfilePath = options.dockerfilePath || "";
-  const imageRef = options.imageRef || "";
-  const envFilePath = options.envFilePath || "";
-  const instanceType = options.instanceType;
-  logger.info("Preparing release...");
-  const { release, finalImageRef } = await prepareRelease(
+}
+async function executeUpgrade(prepared, gas, logger = defaultLogger, skipTelemetry) {
+  return withSDKTelemetry(
     {
-      dockerfilePath,
-      imageRef,
-      envFilePath,
-      logRedirect,
-      resourceUsageAllow,
-      instanceType,
-      environmentConfig: preflightCtx.environmentConfig,
-      appId: appID
+      functionName: "executeUpgrade",
+      skipTelemetry
     },
-    logger
+    async () => {
+      logger.info("Upgrading on-chain...");
+      const txHash = await executeUpgradeBatch(prepared.batch, gas, logger);
+      return {
+        appId: prepared.appId,
+        imageRef: prepared.imageRef,
+        txHash
+      };
+    }
   );
-  logger.debug("Checking current log permission state...");
-  const currentlyPublic = await checkAppLogPermission(preflightCtx, appID, logger);
-  const needsPermissionChange = currentlyPublic !== publicLogs;
-  logger.debug("Preparing upgrade batch...");
-  const batch = await prepareUpgradeBatch({
-    privateKey: preflightCtx.privateKey,
-    rpcUrl: options.rpcUrl || preflightCtx.rpcUrl,
-    environmentConfig: preflightCtx.environmentConfig,
-    appId: appID,
-    release,
-    publicLogs,
-    needsPermissionChange
-  });
-  logger.debug("Estimating gas...");
-  const gasEstimate = await estimateBatchGas({
-    publicClient: batch.publicClient,
-    environmentConfig: batch.environmentConfig,
-    executions: batch.executions
-  });
-  return {
-    prepared: {
-      batch,
-      appId: appID,
-      imageRef: finalImageRef,
-      preflightCtx: {
-        privateKey: preflightCtx.privateKey,
-        rpcUrl: preflightCtx.rpcUrl,
-        environmentConfig: preflightCtx.environmentConfig
-      }
-    },
-    gasEstimate
-  };
-}
-async function executeUpgrade(prepared, gas, logger = defaultLogger) {
-  logger.info("Upgrading on-chain...");
-  const txHash = await executeUpgradeBatch(prepared.batch, gas, logger);
-  return {
-    appId: prepared.appId,
-    imageRef: prepared.imageRef,
-    txHash
-  };
 }
-async function watchUpgrade(appId, privateKey, rpcUrl, environment, logger = defaultLogger, clientId) {
-  const environmentConfig = getEnvironmentConfig(environment);
-  logger.info("Waiting for upgrade to complete...");
-  await watchUntilUpgradeComplete(
+async function watchUpgrade(appId, privateKey, rpcUrl, environment, logger = defaultLogger, clientId, skipTelemetry) {
+  return withSDKTelemetry(
     {
-      privateKey,
-      rpcUrl,
-      environmentConfig,
-      appId,
-      clientId
+      functionName: "watchUpgrade",
+      skipTelemetry,
+      properties: {
+        environment
+      }
     },
-    logger
+    async () => {
+      const environmentConfig = getEnvironmentConfig(environment);
+      logger.info("Waiting for upgrade to complete...");
+      await watchUntilUpgradeComplete(
+        {
+          privateKey,
+          rpcUrl,
+          environmentConfig,
+          appId,
+          clientId
+        },
+        logger
+      );
+    }
   );
 }
 
-// src/client/modules/app/create.ts
+// src/client/modules/compute/app/create.ts
 var fs7 = __toESM(require("fs"), 1);
 var path7 = __toESM(require("path"), 1);
 
@@ -5854,7 +6159,7 @@ function getCategoryDescriptions(catalog, language) {
 // src/client/common/templates/git.ts
 var fs5 = __toESM(require("fs"), 1);
 var path5 = __toESM(require("path"), 1);
-var os2 = __toESM(require("os"), 1);
+var os3 = __toESM(require("os"), 1);
 var import_child_process2 = require("child_process");
 var import_util4 = require("util");
 var execAsync2 = (0, import_util4.promisify)(import_child_process2.exec);
@@ -5893,9 +6198,9 @@ async function fetchTemplateSubdirectory(repoURL, ref, subPath, targetDir, logge
   }
   let tempDir;
   try {
-    tempDir = fs5.mkdtempSync(path5.join(os2.tmpdir(), "eigenx-template-"));
+    tempDir = fs5.mkdtempSync(path5.join(os3.tmpdir(), "eigenx-template-"));
   } catch {
-    const homeDir = os2.homedir();
+    const homeDir = os3.homedir();
     const fallbackBase = path5.join(homeDir, ".eigenx", "tmp");
     fs5.mkdirSync(fallbackBase, { recursive: true });
     tempDir = fs5.mkdtempSync(path5.join(fallbackBase, "eigenx-template-"));
@@ -6043,7 +6348,7 @@ Before deploying, you'll need:
 ## Deployment
 
 \`\`\`bash
-eigenx app deploy username/image-name
+ecloud compute app deploy username/image-name
 \`\`\`
 
 The CLI will automatically detect the \`Dockerfile\` and build your app before deploying.
@@ -6051,13 +6356,13 @@ The CLI will automatically detect the \`Dockerfile\` and build your app before d
 ## Management & Monitoring
 
 \`\`\`bash
-npx ecloud app list                    # List all apps
-npx ecloud app info [app-name]         # Get app details
-npx ecloud app logs [app-name]         # View logs
-npx ecloud app start [app-name]        # Start stopped app
-npx ecloud app stop [app-name]         # Stop running app
-npx ecloud app terminate [app-name]    # Terminate app
-npx ecloud app upgrade [app-name] [image] # Update deployment
+ecloud compute app list                    # List all apps
+ecloud compute app info [app-name]         # Get app details
+ecloud compute app logs [app-name]         # View logs
+ecloud compute app start [app-name]        # Start stopped app
+ecloud compute app stop [app-name]         # Stop running app
+ecloud compute app terminate [app-name]    # Terminate app
+ecloud compute app upgrade [app-name] [image] # Update deployment
 \`\`\`
 `;
 }
@@ -6072,7 +6377,7 @@ async function updateProjectFile(projectDir, filename, oldString, newString, log
   fs6.writeFileSync(filePath, newContent, { mode: 420 });
 }
 
-// src/client/modules/app/create.ts
+// src/client/modules/compute/app/create.ts
 var PRIMARY_LANGUAGES = ["typescript", "golang", "rust", "python"];
 function validateProjectName(name) {
   if (!name) {
@@ -6113,30 +6418,41 @@ async function getAvailableTemplates(language) {
   }));
 }
 async function createApp(options, logger = defaultLogger) {
-  validateProjectName(options.name || "");
-  validateLanguage(options.language || "");
-  const cfg = await gatherProjectConfig(
+  return withSDKTelemetry(
     {
-      ...options,
-      name: options.name,
-      language: options.language
+      functionName: "createApp",
+      skipTelemetry: options.skipTelemetry,
+      properties: {
+        language: options.language || ""
+      }
     },
-    logger
-  );
-  if (fs7.existsSync(cfg.name)) {
-    throw new Error(`Directory ${cfg.name} already exists`);
-  }
-  fs7.mkdirSync(cfg.name, { mode: 493 });
-  try {
-    await populateProjectFromTemplate(cfg, options, logger);
-    if (cfg.subPath && cfg.language && cfg.templateEntry) {
-      await postProcessTemplate(cfg.name, cfg.language, cfg.templateEntry, logger);
+    async () => {
+      validateProjectName(options.name || "");
+      validateLanguage(options.language || "");
+      const cfg = await gatherProjectConfig(
+        {
+          ...options,
+          name: options.name,
+          language: options.language
+        },
+        logger
+      );
+      if (fs7.existsSync(cfg.name)) {
+        throw new Error(`Directory ${cfg.name} already exists`);
+      }
+      fs7.mkdirSync(cfg.name, { mode: 493 });
+      try {
+        await populateProjectFromTemplate(cfg, options, logger);
+        if (cfg.subPath && cfg.language && cfg.templateEntry) {
+          await postProcessTemplate(cfg.name, cfg.language, cfg.templateEntry, logger);
+        }
+        logger.info(`Successfully created ${cfg.language || "project"} project: ${cfg.name}`);
+      } catch (error) {
+        fs7.rmSync(cfg.name, { recursive: true, force: true });
+        throw error;
+      }
     }
-    logger.info(`Successfully created ${cfg.language || "project"} project: ${cfg.name}`);
-  } catch (error) {
-    fs7.rmSync(cfg.name, { recursive: true, force: true });
-    throw error;
-  }
+  );
 }
 async function gatherProjectConfig(options, logger) {
   const cfg = {
@@ -6224,7 +6540,7 @@ async function copyDirectory2(src, dst) {
   }
 }
 
-// src/client/modules/app/logs.ts
+// src/client/modules/compute/app/logs.ts
 var import_chalk = __toESM(require("chalk"), 1);
 var AppStatusCreated = "Created";
 var AppStatusDeploying = "Deploying";
@@ -6306,93 +6622,107 @@ async function watchLogs(appID, userApiClient, initialLogs) {
   }
   console.log("\nStopped watching");
 }
-async function logs(options, logger = defaultLogger) {
-  console.log();
-  if (!options.appID) {
-    throw new Error("appID is required for viewing logs");
-  }
-  const environment = options.environment || "sepolia";
-  const environmentConfig = getEnvironmentConfig(environment);
-  const rpcUrl = options.rpcUrl || environmentConfig.defaultRPCURL;
-  if (!rpcUrl) {
-    throw new Error("RPC URL is required for authenticated requests");
-  }
-  const appID = validateAppID(options.appID);
-  const formattedApp = formatAppDisplay(environmentConfig.name, appID, "");
-  const userApiClient = new UserApiClient(
-    environmentConfig,
-    options.privateKey,
-    rpcUrl,
-    options.clientId
-  );
-  let logsText;
-  let logsError = null;
-  try {
-    logsText = await userApiClient.getLogs(appID);
-  } catch (err) {
-    logsError = err;
-    logsText = "";
-  }
-  const watchMode = options.watch || false;
-  if (logsError || logsText.trim() === "") {
-    if (watchMode) {
-      logger.info("\nWaiting for logs to become available...");
+async function logs(options, logger = defaultLogger, skipTelemetry = false) {
+  const skipTelemetryFlag = skipTelemetry || options.skipTelemetry || false;
+  return withSDKTelemetry(
+    {
+      functionName: "logs",
+      skipTelemetry: skipTelemetryFlag,
+      properties: { environment: options.environment || "sepolia" }
+    },
+    async () => {
       console.log();
-      await watchLogs(appID, userApiClient, "");
-      return;
-    }
-    try {
-      const statuses = await userApiClient.getStatuses([appID]);
-      if (statuses.length > 0) {
-        const status = statuses[0].status;
-        switch (status) {
-          case AppStatusCreated:
-          case AppStatusDeploying:
-            logger.info(
-              `${formattedApp} is currently being provisioned. Logs will be available once deployment is complete.`
-            );
-            return;
-          case AppStatusUpgrading:
-            logger.info(
-              `${formattedApp} is currently upgrading. Logs will be available once upgrade is complete.`
-            );
-            return;
-          case AppStatusResuming:
-            logger.info(`${formattedApp} is currently resuming. Logs will be available shortly.`);
-            return;
-          case AppStatusStopping:
-            logger.info(`${formattedApp} is currently stopping. Logs may be limited.`);
-            return;
-          case AppStatusStopped:
-          case AppStatusTerminating:
-          case AppStatusTerminated:
-          case AppStatusSuspended:
-            logger.info(`${formattedApp} is ${status.toLowerCase()}. Logs are not available.`);
-            return;
-          case AppStatusFailed:
-            logger.info(`${formattedApp} has failed. Check the app status for more information.`);
-            return;
+      if (!options.appID) {
+        throw new Error("appID is required for viewing logs");
+      }
+      const environment = options.environment || "sepolia";
+      const environmentConfig = getEnvironmentConfig(environment);
+      const rpcUrl = options.rpcUrl || environmentConfig.defaultRPCURL;
+      if (!rpcUrl) {
+        throw new Error("RPC URL is required for authenticated requests");
+      }
+      const appID = validateAppID(options.appID);
+      const formattedApp = formatAppDisplay(environmentConfig.name, appID, "");
+      const userApiClient = new UserApiClient(
+        environmentConfig,
+        options.privateKey,
+        rpcUrl,
+        options.clientId
+      );
+      let logsText;
+      let logsError = null;
+      try {
+        logsText = await userApiClient.getLogs(appID);
+      } catch (err) {
+        logsError = err;
+        logsText = "";
+      }
+      const watchMode = options.watch || false;
+      if (logsError || logsText.trim() === "") {
+        if (watchMode) {
+          logger.info("\nWaiting for logs to become available...");
+          console.log();
+          await watchLogs(appID, userApiClient, "");
+          return;
+        }
+        try {
+          const statuses = await userApiClient.getStatuses([appID]);
+          if (statuses.length > 0) {
+            const status = statuses[0].status;
+            switch (status) {
+              case AppStatusCreated:
+              case AppStatusDeploying:
+                logger.info(
+                  `${formattedApp} is currently being provisioned. Logs will be available once deployment is complete.`
+                );
+                return;
+              case AppStatusUpgrading:
+                logger.info(
+                  `${formattedApp} is currently upgrading. Logs will be available once upgrade is complete.`
+                );
+                return;
+              case AppStatusResuming:
+                logger.info(
+                  `${formattedApp} is currently resuming. Logs will be available shortly.`
+                );
+                return;
+              case AppStatusStopping:
+                logger.info(`${formattedApp} is currently stopping. Logs may be limited.`);
+                return;
+              case AppStatusStopped:
+              case AppStatusTerminating:
+              case AppStatusTerminated:
+              case AppStatusSuspended:
+                logger.info(`${formattedApp} is ${status.toLowerCase()}. Logs are not available.`);
+                return;
+              case AppStatusFailed:
+                logger.info(
+                  `${formattedApp} has failed. Check the app status for more information.`
+                );
+                return;
+            }
+          }
+        } catch {
+        }
+        if (logsError) {
+          throw new Error(
+            `Failed to get logs, you can watch for logs by calling this command with the --watch flag (or --w): ${logsError.message}`
+          );
         }
+        throw new Error(
+          "Failed to get logs, you can watch for logs by calling this command with the --watch flag (or --w): empty logs"
+        );
       }
-    } catch {
-    }
-    if (logsError) {
-      throw new Error(
-        `Failed to get logs, you can watch for logs by calling this command with the --watch flag (or --w): ${logsError.message}`
-      );
+      console.log(logsText);
+      if (!watchMode) {
+        return;
+      }
+      await watchLogs(appID, userApiClient, logsText);
     }
-    throw new Error(
-      "Failed to get logs, you can watch for logs by calling this command with the --watch flag (or --w): empty logs"
-    );
-  }
-  console.log(logsText);
-  if (!watchMode) {
-    return;
-  }
-  await watchLogs(appID, userApiClient, logsText);
+  );
 }
 
-// src/client/modules/app/index.ts
+// src/client/modules/compute/app/index.ts
 var CONTROLLER_ABI = (0, import_viem9.parseAbi)([
   "function startApp(address appId)",
   "function stopApp(address appId)",
@@ -6421,6 +6751,7 @@ function encodeTerminateAppData(appId) {
 }
 function createAppModule(ctx) {
   const privateKey = addHexPrefix(ctx.privateKey);
+  const skipTelemetry = ctx.skipTelemetry || false;
   const environment = getEnvironmentConfig(ctx.environment);
   const logger = getLogger(ctx.verbose);
   return {
@@ -6483,89 +6814,145 @@ function createAppModule(ctx) {
           environment: ctx.environment,
           clientId: ctx.clientId
         },
-        logger
+        logger,
+        skipTelemetry
+        // Skip if called from CLI
       );
     },
     async start(appId, opts) {
-      const pendingMessage = `Starting app ${appId}...`;
-      const data = (0, import_viem9.encodeFunctionData)({
-        abi: CONTROLLER_ABI,
-        functionName: "startApp",
-        args: [appId]
-      });
-      const tx = await sendAndWaitForTransaction(
+      return withSDKTelemetry(
         {
-          privateKey,
-          rpcUrl: ctx.rpcUrl,
-          environmentConfig: environment,
-          to: environment.appControllerAddress,
-          data,
-          pendingMessage,
-          txDescription: "StartApp",
-          gas: opts?.gas
+          functionName: "start",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { environment: ctx.environment }
         },
-        logger
+        async () => {
+          const pendingMessage = `Starting app ${appId}...`;
+          const data = (0, import_viem9.encodeFunctionData)({
+            abi: CONTROLLER_ABI,
+            functionName: "startApp",
+            args: [appId]
+          });
+          const tx = await sendAndWaitForTransaction(
+            {
+              privateKey,
+              rpcUrl: ctx.rpcUrl,
+              environmentConfig: environment,
+              to: environment.appControllerAddress,
+              data,
+              pendingMessage,
+              txDescription: "StartApp",
+              gas: opts?.gas
+            },
+            logger
+          );
+          return { tx };
+        }
       );
-      return { tx };
     },
     async stop(appId, opts) {
-      const pendingMessage = `Stopping app ${appId}...`;
-      const data = (0, import_viem9.encodeFunctionData)({
-        abi: CONTROLLER_ABI,
-        functionName: "stopApp",
-        args: [appId]
-      });
-      const tx = await sendAndWaitForTransaction(
+      return withSDKTelemetry(
         {
-          privateKey,
-          rpcUrl: ctx.rpcUrl,
-          environmentConfig: environment,
-          to: environment.appControllerAddress,
-          data,
-          pendingMessage,
-          txDescription: "StopApp",
-          gas: opts?.gas
+          functionName: "stop",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { environment: ctx.environment }
         },
-        logger
+        async () => {
+          const pendingMessage = `Stopping app ${appId}...`;
+          const data = (0, import_viem9.encodeFunctionData)({
+            abi: CONTROLLER_ABI,
+            functionName: "stopApp",
+            args: [appId]
+          });
+          const tx = await sendAndWaitForTransaction(
+            {
+              privateKey,
+              rpcUrl: ctx.rpcUrl,
+              environmentConfig: environment,
+              to: environment.appControllerAddress,
+              data,
+              pendingMessage,
+              txDescription: "StopApp",
+              gas: opts?.gas
+            },
+            logger
+          );
+          return { tx };
+        }
       );
-      return { tx };
     },
     async terminate(appId, opts) {
-      const pendingMessage = `Terminating app ${appId}...`;
-      const data = (0, import_viem9.encodeFunctionData)({
-        abi: CONTROLLER_ABI,
-        functionName: "terminateApp",
-        args: [appId]
-      });
-      const tx = await sendAndWaitForTransaction(
+      return withSDKTelemetry(
         {
-          privateKey,
-          rpcUrl: ctx.rpcUrl,
-          environmentConfig: environment,
-          to: environment.appControllerAddress,
-          data,
-          pendingMessage,
-          txDescription: "TerminateApp",
-          gas: opts?.gas
+          functionName: "terminate",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { environment: ctx.environment }
         },
-        logger
+        async () => {
+          const pendingMessage = `Terminating app ${appId}...`;
+          const data = (0, import_viem9.encodeFunctionData)({
+            abi: CONTROLLER_ABI,
+            functionName: "terminateApp",
+            args: [appId]
+          });
+          const tx = await sendAndWaitForTransaction(
+            {
+              privateKey,
+              rpcUrl: ctx.rpcUrl,
+              environmentConfig: environment,
+              to: environment.appControllerAddress,
+              data,
+              pendingMessage,
+              txDescription: "TerminateApp",
+              gas: opts?.gas
+            },
+            logger
+          );
+          return { tx };
+        }
       );
-      return { tx };
+    },
+    async isDelegated() {
+      return isDelegated({
+        privateKey,
+        rpcUrl: ctx.rpcUrl,
+        environmentConfig: environment
+      });
     },
     async undelegate() {
-      const tx = await undelegate(
+      return withSDKTelemetry(
         {
-          privateKey,
-          rpcUrl: ctx.rpcUrl,
-          environmentConfig: environment
+          functionName: "undelegate",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { environment: ctx.environment }
         },
-        logger
+        async () => {
+          const tx = await undelegate(
+            {
+              privateKey,
+              rpcUrl: ctx.rpcUrl,
+              environmentConfig: environment
+            },
+            logger
+          );
+          return { tx };
+        }
       );
-      return { tx };
     }
   };
 }
 
+// src/client/modules/compute/index.ts
+function createComputeModule(config) {
+  return {
+    app: createAppModule(config)
+  };
+}
+
 // src/client/common/utils/billingapi.ts
 var import_axios2 = __toESM(require("axios"), 1);
 var import_accounts5 = require("viem/accounts");
@@ -6641,63 +7028,93 @@ Please check:
 
 // src/client/modules/billing/index.ts
 function createBillingModule(config) {
-  const { verbose = false } = config;
+  const { verbose = false, skipTelemetry = false } = config;
   const privateKey = addHexPrefix(config.privateKey);
   const logger = getLogger(verbose);
   const billingEnvConfig = getBillingEnvironmentConfig(getBuildType());
   const billingApi = new BillingApiClient(billingEnvConfig, privateKey);
   return {
     async subscribe(opts) {
-      const productId = opts?.productId || "compute";
-      logger.debug(`Checking existing subscription for ${productId}...`);
-      const currentStatus = await billingApi.getSubscription(productId);
-      if (isSubscriptionActive(currentStatus.subscriptionStatus)) {
-        logger.debug(`Subscription already active: ${currentStatus.subscriptionStatus}`);
-        return {
-          type: "already_active",
-          status: currentStatus.subscriptionStatus
-        };
-      }
-      if (currentStatus.subscriptionStatus === "past_due" || currentStatus.subscriptionStatus === "unpaid") {
-        logger.debug(`Subscription has payment issue: ${currentStatus.subscriptionStatus}`);
-        return {
-          type: "payment_issue",
-          status: currentStatus.subscriptionStatus,
-          portalUrl: currentStatus.portalUrl
-        };
-      }
-      logger.debug(`Creating subscription for ${productId}...`);
-      const result = await billingApi.createSubscription(productId);
-      logger.debug(`Checkout URL: ${result.checkoutUrl}`);
-      return {
-        type: "checkout_created",
-        checkoutUrl: result.checkoutUrl
-      };
+      return withSDKTelemetry(
+        {
+          functionName: "subscribe",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Checking existing subscription for ${productId}...`);
+          const currentStatus = await billingApi.getSubscription(productId);
+          if (isSubscriptionActive(currentStatus.subscriptionStatus)) {
+            logger.debug(`Subscription already active: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "already_active",
+              status: currentStatus.subscriptionStatus
+            };
+          }
+          if (currentStatus.subscriptionStatus === "past_due" || currentStatus.subscriptionStatus === "unpaid") {
+            logger.debug(`Subscription has payment issue: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "payment_issue",
+              status: currentStatus.subscriptionStatus,
+              portalUrl: currentStatus.portalUrl
+            };
+          }
+          logger.debug(`Creating subscription for ${productId}...`);
+          const result = await billingApi.createSubscription(productId);
+          logger.debug(`Checkout URL: ${result.checkoutUrl}`);
+          return {
+            type: "checkout_created",
+            checkoutUrl: result.checkoutUrl
+          };
+        }
+      );
     },
     async getStatus(opts) {
-      const productId = opts?.productId || "compute";
-      logger.debug(`Fetching subscription status for ${productId}...`);
-      const result = await billingApi.getSubscription(productId);
-      logger.debug(`Subscription status: ${result.subscriptionStatus}`);
-      return result;
+      return withSDKTelemetry(
+        {
+          functionName: "getStatus",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Fetching subscription status for ${productId}...`);
+          const result = await billingApi.getSubscription(productId);
+          logger.debug(`Subscription status: ${result.subscriptionStatus}`);
+          return result;
+        }
+      );
     },
     async cancel(opts) {
-      const productId = opts?.productId || "compute";
-      logger.debug(`Checking subscription status for ${productId}...`);
-      const currentStatus = await billingApi.getSubscription(productId);
-      if (!isSubscriptionActive(currentStatus.subscriptionStatus)) {
-        logger.debug(`No active subscription to cancel: ${currentStatus.subscriptionStatus}`);
-        return {
-          type: "no_active_subscription",
-          status: currentStatus.subscriptionStatus
-        };
-      }
-      logger.debug(`Canceling subscription for ${productId}...`);
-      await billingApi.cancelSubscription(productId);
-      logger.debug(`Subscription canceled successfully`);
-      return {
-        type: "canceled"
-      };
+      return withSDKTelemetry(
+        {
+          functionName: "cancel",
+          skipTelemetry,
+          // Skip if called from CLI
+          properties: { productId: opts?.productId || "compute" }
+        },
+        async () => {
+          const productId = opts?.productId || "compute";
+          logger.debug(`Checking subscription status for ${productId}...`);
+          const currentStatus = await billingApi.getSubscription(productId);
+          if (!isSubscriptionActive(currentStatus.subscriptionStatus)) {
+            logger.debug(`No active subscription to cancel: ${currentStatus.subscriptionStatus}`);
+            return {
+              type: "no_active_subscription",
+              status: currentStatus.subscriptionStatus
+            };
+          }
+          logger.debug(`Canceling subscription for ${productId}...`);
+          await billingApi.cancelSubscription(productId);
+          logger.debug(`Subscription canceled successfully`);
+          return {
+            type: "canceled"
+          };
+        }
+      );
     }
   };
 }
@@ -6981,7 +7398,7 @@ function createECloudClient(cfg) {
     );
   }
   return {
-    app: createAppModule({
+    compute: createComputeModule({
       rpcUrl,
       verbose: cfg.verbose,
       privateKey: cfg.privateKey,
@@ -6995,17 +7412,26 @@ function createECloudClient(cfg) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NoopClient,
   PRIMARY_LANGUAGES,
+  PostHogClient,
   UserApiClient,
+  addMetric,
+  addMetricWithDimensions,
   assertValidFilePath,
   assertValidImageReference,
   assertValidPrivateKey,
+  checkERC7702Delegation,
   createApp,
-  createAppModule,
+  createAppEnvironment,
   createBillingModule,
+  createComputeModule,
   createECloudClient,
+  createMetricsContext,
+  createTelemetryClient,
   deleteLegacyPrivateKey,
   deletePrivateKey,
+  emitMetrics,
   encodeStartAppData,
   encodeStopAppData,
   encodeTerminateAppData,
@@ -7029,11 +7455,14 @@ function createECloudClient(cfg) {
   getEnvironmentConfig,
   getLegacyKeys,
   getLegacyPrivateKey,
+  getPostHogAPIKey,
+  getPostHogEndpoint,
   getPrivateKey,
   getPrivateKeyWithSource,
   getTemplate,
   isEnvironmentAvailable,
   isMainnet,
+  isNoopClient,
   isSubscriptionActive,
   keyExists,
   listStoredKeys,
@@ -7063,6 +7492,7 @@ function createECloudClient(cfg) {
   validateUpgradeParams,
   validateXURL,
   watchDeployment,
-  watchUpgrade
+  watchUpgrade,
+  withSDKTelemetry
 });
 //# sourceMappingURL=index.cjs.map