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

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

@@ -0,0 +1,845 @@
+#!/usr/bin/env node
+
+// src/commands/compute/app/status.ts
+import { Command, Args, Flags as Flags2 } from "@oclif/core";
+import { getEnvironmentConfig as getEnvironmentConfig4, UserApiClient as UserApiClient3, WatchTimeoutError } from "@layr-labs/ecloud-sdk";
+
+// src/flags.ts
+import { Flags } from "@oclif/core";
+import { getBuildType as getBuildType2 } from "@layr-labs/ecloud-sdk";
+
+// src/utils/prompts.ts
+import { input, select, password, confirm as inquirerConfirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+import { isAddress as isAddress2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import {
+  getEnvironmentConfig as getEnvironmentConfig2,
+  getAvailableEnvironments,
+  getAllAppsByDeveloper as getAllAppsByDeveloper2,
+  getCategoryDescriptions,
+  fetchTemplateCatalog,
+  PRIMARY_LANGUAGES,
+  validateAppName,
+  validateImageReference,
+  validateFilePath,
+  validatePrivateKeyFormat,
+  extractAppNameFromImage,
+  UserApiClient as UserApiClient2
+} from "@layr-labs/ecloud-sdk";
+
+// src/utils/appResolver.ts
+import { isAddress } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import {
+  UserApiClient,
+  getAllAppsByDeveloper
+} from "@layr-labs/ecloud-sdk";
+
+// src/utils/viemClients.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  getEnvironmentConfig,
+  addHexPrefix,
+  createViemClients as sdkCreateViemClients,
+  getChainFromID
+} from "@layr-labs/ecloud-sdk";
+function createViemClients(options) {
+  const privateKey = addHexPrefix(options.privateKey);
+  const environmentConfig = getEnvironmentConfig(options.environment);
+  const rpcUrl = options.rpcUrl || environmentConfig.defaultRPCURL;
+  const chain = getChainFromID(environmentConfig.chainID);
+  const { publicClient, walletClient } = sdkCreateViemClients({
+    privateKey,
+    rpcUrl,
+    chainId: environmentConfig.chainID
+  });
+  const account = privateKeyToAccount(privateKey);
+  return {
+    publicClient,
+    walletClient,
+    chain,
+    address: account.address
+  };
+}
+
+// src/utils/globalConfig.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { load as loadYaml, dump as dumpYaml } from "js-yaml";
+import { getBuildType } from "@layr-labs/ecloud-sdk";
+import * as crypto from "crypto";
+var GLOBAL_CONFIG_FILE = "config.yaml";
+var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function getGlobalConfigDir() {
+  const configHome = process.env.XDG_CONFIG_HOME;
+  let baseDir;
+  if (configHome && path.isAbsolute(configHome)) {
+    baseDir = configHome;
+  } else {
+    baseDir = path.join(os.homedir(), ".config");
+  }
+  const buildType = getBuildType();
+  const buildSuffix = buildType === "dev" ? "-dev" : "";
+  const configDirName = `ecloud${buildSuffix}`;
+  return path.join(baseDir, configDirName);
+}
+function getGlobalConfigPath() {
+  return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE);
+}
+function loadGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {
+      first_run: true
+    };
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = loadYaml(content);
+    return config || { first_run: true };
+  } catch {
+    return {
+      first_run: true
+    };
+  }
+}
+function saveGlobalConfig(config) {
+  const configPath = getGlobalConfigPath();
+  const configDir = path.dirname(configPath);
+  fs.mkdirSync(configDir, { recursive: true, mode: 493 });
+  const content = dumpYaml(config, { lineWidth: -1 });
+  fs.writeFileSync(configPath, content, { mode: 420 });
+}
+function normalizeDirectoryPath(directoryPath) {
+  const resolved = path.resolve(directoryPath);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function getLinkedAppForDirectory(environment, directoryPath) {
+  if (!directoryPath) {
+    return null;
+  }
+  const config = loadGlobalConfig();
+  const links = config.directory_links?.[environment];
+  if (!links) {
+    return null;
+  }
+  const normalizedPath = normalizeDirectoryPath(directoryPath);
+  const appId = links[normalizedPath];
+  return appId || null;
+}
+function getDefaultEnvironment() {
+  const config = loadGlobalConfig();
+  return config.default_environment;
+}
+function getProfileCache(environment) {
+  const config = loadGlobalConfig();
+  const cacheEntry = config.profile_cache?.[environment];
+  if (!cacheEntry) {
+    return null;
+  }
+  const now = Date.now();
+  if (now - cacheEntry.updated_at > PROFILE_CACHE_TTL_MS) {
+    return null;
+  }
+  return cacheEntry.profiles;
+}
+function setProfileCache(environment, profiles) {
+  const config = loadGlobalConfig();
+  if (!config.profile_cache) {
+    config.profile_cache = {};
+  }
+  config.profile_cache[environment] = {
+    updated_at: Date.now(),
+    profiles
+  };
+  saveGlobalConfig(config);
+}
+
+// src/utils/appNames.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import { load as loadYaml2, dump as dumpYaml2 } from "js-yaml";
+var CONFIG_DIR = path2.join(os2.homedir(), ".eigenx");
+var APPS_DIR = path2.join(CONFIG_DIR, "apps");
+var APP_REGISTRY_VERSION = "1.0.0";
+function getAppRegistryPath(environment) {
+  return path2.join(APPS_DIR, `${environment}.yaml`);
+}
+function loadAppRegistry(environment) {
+  const filePath = getAppRegistryPath(environment);
+  if (!fs2.existsSync(filePath)) {
+    return {
+      version: APP_REGISTRY_VERSION,
+      apps: {}
+    };
+  }
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const registry = loadYaml2(content);
+    if (!registry.apps) {
+      registry.apps = {};
+    }
+    return registry;
+  } catch {
+    return {
+      version: APP_REGISTRY_VERSION,
+      apps: {}
+    };
+  }
+}
+function listApps(environment) {
+  const registry = loadAppRegistry(environment);
+  const result = {};
+  for (const [name, app] of Object.entries(registry.apps)) {
+    if (app?.app_id) {
+      result[name] = String(app.app_id);
+    }
+  }
+  return result;
+}
+
+// src/utils/version.ts
+function getCliVersion() {
+  return true ? "1.0.0-dev.8" : "0.0.0";
+}
+function getClientId() {
+  return `ecloud-cli/v${getCliVersion()}`;
+}
+
+// src/utils/appResolver.ts
+var CHUNK_SIZE = 10;
+async function getAppInfosChunked(userApiClient, appIds, addressCount) {
+  if (appIds.length === 0) {
+    return [];
+  }
+  const chunks = [];
+  for (let i = 0; i < appIds.length; i += CHUNK_SIZE) {
+    chunks.push(appIds.slice(i, i + CHUNK_SIZE));
+  }
+  const chunkResults = await Promise.all(
+    chunks.map((chunk) => userApiClient.getInfos(chunk, addressCount))
+  );
+  return chunkResults.flat();
+}
+
+// src/utils/prompts.ts
+import { execSync } from "child_process";
+function addHexPrefix2(value) {
+  if (value.startsWith("0x")) {
+    return value;
+  }
+  return `0x${value}`;
+}
+function ensureInteractive(missingFlagHint) {
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      `Cannot prompt in non-interactive mode. Provide ${missingFlagHint} via CLI flags or environment variables.`
+    );
+  }
+}
+function getCurrentProjectPath() {
+  return process.env.INIT_CWD || process.cwd();
+}
+var ContractAppStatusStarted = 1;
+var ContractAppStatusStopped = 2;
+var ContractAppStatusTerminated = 3;
+var ContractAppStatusSuspended = 4;
+function getContractStatusString(status) {
+  switch (status) {
+    case ContractAppStatusStarted:
+      return "Started";
+    case ContractAppStatusStopped:
+      return "Stopped";
+    case ContractAppStatusTerminated:
+      return "Terminated";
+    case ContractAppStatusSuspended:
+      return "Suspended";
+    default:
+      return "Unknown";
+  }
+}
+function getStatusPriority(status, isExited) {
+  if (isExited) {
+    return 1;
+  }
+  switch (status) {
+    case ContractAppStatusStarted:
+      return 0;
+    case ContractAppStatusStopped:
+      return 2;
+    case ContractAppStatusTerminated:
+      return 3;
+    default:
+      return 4;
+  }
+}
+function formatAppDisplay(environmentName, appID, profileName) {
+  if (profileName) {
+    return `${profileName} (${environmentName}:${appID})`;
+  }
+  return `${environmentName}:${appID}`;
+}
+async function getOrPromptAppID(appIDOrOptions, environment) {
+  let options;
+  if (environment !== void 0) {
+    options = {
+      appID: appIDOrOptions,
+      environment
+    };
+  } else if (appIDOrOptions && typeof appIDOrOptions === "object" && "environment" in appIDOrOptions) {
+    options = appIDOrOptions;
+  } else {
+    options = {
+      appID: appIDOrOptions,
+      environment: "sepolia"
+    };
+  }
+  if (options.appID) {
+    const normalized = typeof options.appID === "string" ? addHexPrefix2(options.appID) : options.appID;
+    if (isAddress2(normalized)) {
+      return normalized;
+    }
+    const profileCache = getProfileCache(options.environment);
+    if (profileCache) {
+      const searchName = options.appID.toLowerCase();
+      for (const [appId, name] of Object.entries(profileCache)) {
+        if (name.toLowerCase() === searchName) {
+          return appId;
+        }
+      }
+    }
+    const apps = listApps(options.environment);
+    const foundAppID = apps[options.appID];
+    if (foundAppID) {
+      return addHexPrefix2(foundAppID);
+    }
+    throw new Error(
+      `App name '${options.appID}' not found in environment '${options.environment}'. Name lookup uses a local cache that may be stale. Try using the app ID (0x...) directly, or run 'ecloud compute app list' to refresh the cache.`
+    );
+  }
+  ensureInteractive("app-id argument");
+  return getAppIDInteractive(options);
+}
+async function getAppIDInteractive(options) {
+  const action = options.action || "view";
+  const environment = options.environment || "sepolia";
+  const environmentConfig = getEnvironmentConfig2(environment);
+  if (!options.privateKey || !options.rpcUrl) {
+    return getAppIDInteractiveFromRegistry(environment, action);
+  }
+  console.log(`
+Select an app to ${action}:
+`);
+  const privateKeyHex = addHexPrefix2(options.privateKey);
+  const account = privateKeyToAccount3(privateKeyHex);
+  const developerAddr = account.address;
+  const { publicClient, walletClient } = createViemClients({
+    privateKey: options.privateKey,
+    rpcUrl: options.rpcUrl,
+    environment
+  });
+  const { apps, appConfigs } = await getAllAppsByDeveloper2(
+    publicClient,
+    environmentConfig,
+    developerAddr
+  );
+  if (apps.length === 0) {
+    throw new Error("no apps found for your address");
+  }
+  const profileNames = {};
+  let cachedProfiles = getProfileCache(environment);
+  if (!cachedProfiles) {
+    try {
+      const userApiClient = new UserApiClient2(environmentConfig, walletClient, publicClient, {
+        clientId: getClientId()
+      });
+      const appInfos = await getAppInfosChunked(userApiClient, apps);
+      const freshProfiles = {};
+      for (const info of appInfos) {
+        if (info.profile?.name) {
+          const normalizedId = String(info.address).toLowerCase();
+          freshProfiles[normalizedId] = info.profile.name;
+        }
+      }
+      setProfileCache(environment, freshProfiles);
+      cachedProfiles = freshProfiles;
+    } catch {
+      cachedProfiles = {};
+    }
+  }
+  for (const [appId, name] of Object.entries(cachedProfiles)) {
+    profileNames[appId.toLowerCase()] = name;
+  }
+  const localApps = listApps(environment);
+  for (const [name, appID] of Object.entries(localApps)) {
+    const normalizedID = String(appID).toLowerCase();
+    if (!profileNames[normalizedID]) {
+      profileNames[normalizedID] = name;
+    }
+  }
+  const isEligible = (status) => {
+    switch (action) {
+      case "view":
+      case "view info for":
+      case "view releases for":
+      case "set profile for":
+        return true;
+      case "start":
+        return status === ContractAppStatusStopped || status === ContractAppStatusSuspended;
+      case "stop":
+        return status === ContractAppStatusStarted;
+      default:
+        return status !== ContractAppStatusTerminated && status !== ContractAppStatusSuspended;
+    }
+  };
+  const appItems = [];
+  for (let i = 0; i < apps.length; i++) {
+    const appAddr = apps[i];
+    const config = appConfigs[i];
+    const status = config.status;
+    if (!isEligible(status)) {
+      continue;
+    }
+    const statusStr = getContractStatusString(status);
+    const profileName = profileNames[String(appAddr).toLowerCase()] || "";
+    const displayName = formatAppDisplay(environmentConfig.name, appAddr, profileName);
+    appItems.push({
+      addr: appAddr,
+      display: `${displayName} - ${statusStr}`,
+      status,
+      index: i
+    });
+  }
+  const linkedAppId = getLinkedAppForDirectory(environment, getCurrentProjectPath());
+  const normalizedLinkedAppId = linkedAppId ? linkedAppId.toLowerCase() : "";
+  appItems.sort((a, b) => {
+    if (normalizedLinkedAppId) {
+      const aLinked = String(a.addr).toLowerCase() === normalizedLinkedAppId;
+      const bLinked = String(b.addr).toLowerCase() === normalizedLinkedAppId;
+      if (aLinked && !bLinked) {
+        return -1;
+      }
+      if (bLinked && !aLinked) {
+        return 1;
+      }
+    }
+    const aPriority = getStatusPriority(a.status, false);
+    const bPriority = getStatusPriority(b.status, false);
+    if (aPriority !== bPriority) {
+      return aPriority - bPriority;
+    }
+    return b.index - a.index;
+  });
+  if (appItems.length === 0) {
+    switch (action) {
+      case "start":
+        throw new Error("no startable apps found - only Stopped apps can be started");
+      case "stop":
+        throw new Error("no running apps found - only Running apps can be stopped");
+      default:
+        throw new Error("no active apps found");
+    }
+  }
+  const choices = appItems.map((item) => ({
+    name: item.display,
+    value: item.addr
+  }));
+  const selected = await select({
+    message: "Select app:",
+    choices
+  });
+  return selected;
+}
+async function getAppIDInteractiveFromRegistry(environment, action) {
+  const allApps = {};
+  const cachedProfiles = getProfileCache(environment);
+  if (cachedProfiles) {
+    for (const [appId, name] of Object.entries(cachedProfiles)) {
+      allApps[name] = appId;
+    }
+  }
+  const localApps = listApps(environment);
+  for (const [name, appId] of Object.entries(localApps)) {
+    if (!allApps[name]) {
+      allApps[name] = appId;
+    }
+  }
+  if (Object.keys(allApps).length === 0) {
+    console.log("\nNo apps found in registry.");
+    console.log("You can enter an app ID (address) or app name.");
+    console.log();
+    const appIDInput = await input({
+      message: "Enter app ID or name:",
+      default: "",
+      validate: (value) => {
+        if (!value) {
+          return "App ID or name cannot be empty";
+        }
+        const normalized2 = addHexPrefix2(value);
+        if (isAddress2(normalized2)) {
+          return true;
+        }
+        return "Invalid app ID address";
+      }
+    });
+    const normalized = addHexPrefix2(appIDInput);
+    if (isAddress2(normalized)) {
+      return normalized;
+    }
+    throw new Error(`Invalid app ID address: ${appIDInput}`);
+  }
+  const entries = Object.entries(allApps);
+  const linkedAppId = getLinkedAppForDirectory(environment, getCurrentProjectPath());
+  if (linkedAppId) {
+    const linkedIndex = entries.findIndex(
+      ([, appId]) => String(appId).toLowerCase() === linkedAppId.toLowerCase()
+    );
+    if (linkedIndex > 0) {
+      const [linkedEntry] = entries.splice(linkedIndex, 1);
+      entries.unshift(linkedEntry);
+    }
+  }
+  const choices = entries.map(([name, appID]) => {
+    const displayName = `${name} (${appID})`;
+    return { name: displayName, value: appID };
+  });
+  choices.push({ name: "Enter custom app ID or name", value: "custom" });
+  console.log(`
+Select an app to ${action}:`);
+  const selected = await select({
+    message: "Choose app:",
+    choices
+  });
+  if (selected === "custom") {
+    const appIDInput = await input({
+      message: "Enter app ID or name:",
+      default: "",
+      validate: (value) => {
+        if (!value) {
+          return "App ID or name cannot be empty";
+        }
+        const normalized2 = addHexPrefix2(value);
+        if (isAddress2(normalized2)) {
+          return true;
+        }
+        if (allApps[value]) {
+          return true;
+        }
+        return "Invalid app ID or name not found";
+      }
+    });
+    const normalized = addHexPrefix2(appIDInput);
+    if (isAddress2(normalized)) {
+      return normalized;
+    }
+    const foundAppID = allApps[appIDInput];
+    if (foundAppID) {
+      return addHexPrefix2(foundAppID);
+    }
+    throw new Error(`Failed to resolve app ID from input: ${appIDInput}`);
+  }
+  return addHexPrefix2(selected);
+}
+async function getPrivateKeyInteractive(privateKey) {
+  if (privateKey) {
+    if (!validatePrivateKeyFormat(privateKey)) {
+      throw new Error("Invalid private key format");
+    }
+    return privateKey;
+  }
+  const { getPrivateKeyWithSource } = await import("@layr-labs/ecloud-sdk");
+  const result = await getPrivateKeyWithSource({ privateKey: void 0 });
+  if (result) {
+    return result.key;
+  }
+  ensureInteractive("--private-key or ECLOUD_PRIVATE_KEY");
+  const key = await password({
+    message: "Enter private key:",
+    mask: true,
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Private key is required";
+      }
+      if (!validatePrivateKeyFormat(value)) {
+        return "Invalid private key format (must be 64 hex characters, optionally prefixed with 0x)";
+      }
+      return true;
+    }
+  });
+  return key.trim();
+}
+async function getEnvironmentInteractive(environment) {
+  if (environment) {
+    getEnvironmentConfig2(environment);
+    return environment;
+  }
+  ensureInteractive("--environment or ECLOUD_ENV");
+  const availableEnvs = getAvailableEnvironments();
+  let defaultEnv;
+  const configDefaultEnv = getDefaultEnvironment();
+  if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
+    try {
+      getEnvironmentConfig2(configDefaultEnv);
+      defaultEnv = configDefaultEnv;
+    } catch {
+    }
+  }
+  const choices = [];
+  if (availableEnvs.includes("sepolia")) {
+    choices.push({ name: "sepolia - Ethereum Sepolia testnet", value: "sepolia" });
+  }
+  if (availableEnvs.includes("sepolia-dev")) {
+    choices.push({ name: "sepolia-dev - Ethereum Sepolia testnet (dev)", value: "sepolia-dev" });
+  }
+  if (availableEnvs.includes("mainnet-alpha")) {
+    choices.push({
+      name: "mainnet-alpha - Ethereum mainnet (\u26A0\uFE0F  uses real funds)",
+      value: "mainnet-alpha"
+    });
+  }
+  if (choices.length === 0) {
+    throw new Error("No environments available in this build");
+  }
+  const env = await select({
+    message: "Select environment:",
+    choices,
+    default: defaultEnv
+  });
+  return env;
+}
+var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
+
+// src/flags.ts
+import { formatEther, parseGwei } from "viem";
+var commonFlags = {
+  environment: Flags.string({
+    required: false,
+    description: "Deployment environment to use",
+    env: "ECLOUD_ENV",
+    default: async () => getDefaultEnvironment() || (getBuildType2() === "dev" ? "sepolia-dev" : "mainnet-alpha")
+  }),
+  "private-key": Flags.string({
+    required: false,
+    description: "Private key for signing transactions",
+    env: "ECLOUD_PRIVATE_KEY"
+  }),
+  "rpc-url": Flags.string({
+    required: false,
+    description: "RPC URL to connect to blockchain",
+    env: "ECLOUD_RPC_URL"
+  }),
+  verbose: Flags.boolean({
+    required: false,
+    description: "Enable verbose logging (default: false)",
+    default: false
+  }),
+  "max-fee-per-gas": Flags.string({
+    required: false,
+    description: "Override max fee per gas in gwei (e.g., 50)",
+    env: "ECLOUD_MAX_FEE_PER_GAS"
+  }),
+  "max-priority-fee": Flags.string({
+    required: false,
+    description: "Override max priority fee per gas in gwei (e.g., 5)",
+    env: "ECLOUD_MAX_PRIORITY_FEE"
+  }),
+  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 validateCommonFlags(flags, options) {
+  flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
+  if (options?.requirePrivateKey !== false) {
+    flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
+  }
+  return flags;
+}
+
+// src/client.ts
+import {
+  createComputeModule,
+  createBillingModule,
+  createBuildModule,
+  createAdminModule,
+  getEnvironmentConfig as getEnvironmentConfig3,
+  requirePrivateKey
+} from "@layr-labs/ecloud-sdk";
+async function createComputeClient(flags, options = {}) {
+  flags = await validateCommonFlags(flags);
+  const environment = flags.environment;
+  const environmentConfig = getEnvironmentConfig3(environment);
+  const rpcUrl = flags["rpc-url"] || environmentConfig.defaultRPCURL;
+  const { key: privateKey, source } = await requirePrivateKey({
+    privateKey: flags["private-key"]
+  });
+  if (flags.verbose) {
+    console.log(`Using private key from: ${source}`);
+  }
+  const { walletClient, publicClient } = createViemClients({
+    privateKey,
+    rpcUrl,
+    environment
+  });
+  return createComputeModule({
+    verbose: flags.verbose,
+    walletClient,
+    publicClient,
+    environment,
+    clientId: getClientId(),
+    skipTelemetry: true,
+    // CLI already has telemetry, skip SDK telemetry
+    logger: options.logger
+  });
+}
+
+// src/commands/compute/app/status.ts
+import chalk2 from "chalk";
+var AppStatus = class _AppStatus extends Command {
+  static description = "Show an app's current status. Use --wait to block until it settles instead of polling `app info` in a loop.";
+  static examples = [
+    "<%= config.bin %> compute app status 0xabc...",
+    "<%= config.bin %> compute app status 0xabc... --json",
+    "<%= config.bin %> compute app status 0xabc... --wait",
+    "ECLOUD_WATCH_TIMEOUT_SECONDS=120 <%= config.bin %> compute app status 0xabc... --wait"
+  ];
+  static args = {
+    "app-id": Args.string({
+      description: "App ID or name (env: ECLOUD_APP_ID)",
+      required: false
+    })
+  };
+  static flags = {
+    ...commonFlags,
+    wait: Flags2.boolean({
+      description: "Block until the app reaches a terminal status (Running/Stopped) or the watch timeout elapses, instead of returning immediately",
+      default: false
+    }),
+    "watch-timeout": Flags2.integer({
+      description: "With --wait: maximum seconds to wait before returning a recovery hint (default: 600)",
+      env: "ECLOUD_WATCH_TIMEOUT_SECONDS"
+    }),
+    json: Flags2.boolean({
+      description: "Output machine-readable JSON ({ appId, status })",
+      default: false
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_AppStatus);
+    const validatedFlags = await validateCommonFlags(flags);
+    const environment = validatedFlags.environment;
+    const environmentConfig = getEnvironmentConfig4(environment);
+    const rpcUrl = validatedFlags["rpc-url"] || environmentConfig.defaultRPCURL;
+    const privateKey = validatedFlags["private-key"];
+    const appID = await getOrPromptAppID({
+      appID: args["app-id"] ?? process.env.ECLOUD_APP_ID,
+      environment,
+      privateKey,
+      rpcUrl,
+      action: "check status of"
+    });
+    const { publicClient, walletClient } = createViemClients({
+      privateKey,
+      rpcUrl,
+      environment
+    });
+    const userApiClient = new UserApiClient3(environmentConfig, walletClient, publicClient, {
+      clientId: getClientId()
+    });
+    const initialStatus = await this.readStatus(userApiClient, appID);
+    if (flags.wait && isTransitionalStatus(initialStatus)) {
+      const compute = await createComputeClient(
+        validatedFlags,
+        flags.json ? { logger: stderrLogger } : {}
+      );
+      try {
+        await compute.app.watchDeployment(appID, {
+          timeoutSeconds: flags["watch-timeout"]
+        });
+      } catch (err) {
+        if (err instanceof WatchTimeoutError) {
+          if (!flags.json) {
+            this.warn(
+              `Timed out after ${err.elapsedSeconds}s waiting for ${appID}. Check 'ecloud compute app info ${appID}' or the orchestrator logs.`
+            );
+          }
+        } else {
+          throw err;
+        }
+      }
+      const finalStatus = await this.readStatus(userApiClient, appID);
+      this.emit(appID, finalStatus, flags.json);
+      return;
+    }
+    this.emit(appID, initialStatus, flags.json);
+  }
+  /** Fetch the current status for an app, defaulting to "Unknown". */
+  async readStatus(userApiClient, appID) {
+    const statuses = await userApiClient.getStatuses([appID]);
+    return statuses[0]?.status || "Unknown";
+  }
+  /** Write the status as JSON (machine-readable) or a formatted line. */
+  emit(appID, status, json) {
+    if (json) {
+      this.log(JSON.stringify({ appId: appID, status }));
+      return;
+    }
+    this.log(`${chalk2.bold(appID)}: ${formatStatus(status)}`);
+  }
+};
+var TRANSITIONAL_STATUSES = /* @__PURE__ */ new Set([
+  "created",
+  "deploying",
+  "upgrading",
+  "resuming",
+  "stopping",
+  "terminating"
+]);
+function isTransitionalStatus(status) {
+  return TRANSITIONAL_STATUSES.has(status.toLowerCase());
+}
+var stderrLogger = {
+  debug: (...args) => console.error(...args),
+  info: (...args) => console.error(...args),
+  warn: (...args) => console.error(...args),
+  error: (...args) => console.error(...args)
+};
+function formatStatus(status) {
+  switch (status.toLowerCase()) {
+    case "running":
+    case "started":
+      return chalk2.green(status);
+    case "failed":
+    case "terminated":
+      return chalk2.red(status);
+    case "stopped":
+    case "suspended":
+      return chalk2.yellow(status);
+    default:
+      return status;
+  }
+}
+export {
+  AppStatus as default
+};
+//# sourceMappingURL=status.js.map