@phala/cloud 0.2.1-beta.3 → 0.2.1

package/dist/index.mjs

@@ -333,7 +333,11 @@ function formatStructuredError(error, options) {
 }
 
 // src/client.ts
-var SUPPORTED_API_VERSIONS = ["2025-05-31", "2025-10-28"];
+var SUPPORTED_API_VERSIONS = [
+  "2025-10-28",
+  "2026-01-21"
+];
+var DEFAULT_API_VERSION = "2026-01-21";
 var logger = debug("phala::api-client");
 function formatHeaders(headers) {
   return Object.entries(headers).map(([key, value]) => `    -H "${key}: ${value}"`).join("\n");
@@ -357,17 +361,19 @@ function formatResponse(status, statusText, headers, body) {
     bodyStr
   ].filter(Boolean).join("\n");
 }
-var Client = class {
+var Client = class _Client {
   constructor(config = {}) {
     this.emitter = mitt();
-    const resolvedConfig = {
+    const resolvedApiKey = config.apiKey || process?.env?.PHALA_CLOUD_API_KEY;
+    const resolvedBaseURL = config.baseURL || process?.env?.PHALA_CLOUD_API_PREFIX || "https://cloud-api.phala.network/api/v1";
+    const version = config.version && SUPPORTED_API_VERSIONS.includes(config.version) ? config.version : DEFAULT_API_VERSION;
+    this.config = {
       ...config,
-      apiKey: config.apiKey || process?.env?.PHALA_CLOUD_API_KEY,
-      baseURL: config.baseURL || process?.env?.PHALA_CLOUD_API_PREFIX || "https://cloud-api.phala.network/api/v1"
+      apiKey: resolvedApiKey,
+      baseURL: resolvedBaseURL,
+      version
     };
-    const version = resolvedConfig.version && SUPPORTED_API_VERSIONS.includes(resolvedConfig.version) ? resolvedConfig.version : SUPPORTED_API_VERSIONS[SUPPORTED_API_VERSIONS.length - 1];
-    this.config = resolvedConfig;
-    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = resolvedConfig;
+    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = this.config;
     const requestHeaders = {
       "X-Phala-Version": version,
       "Content-Type": "application/json"
@@ -426,8 +432,8 @@ var Client = class {
       },
       // Generic handlers for response error (similar to request.ts)
       onResponseError: ({ request, response, options }) => {
-        console.warn(`HTTP ${response.status}: ${response.url}`);
         if (logger.enabled) {
+          console.warn(`HTTP ${response.status}: ${response.url}`);
           const method = options.method || "GET";
           const url = typeof request === "string" ? request : request.url;
           logger(
@@ -463,6 +469,49 @@ var Client = class {
     this.emitter.on(type, wrappedHandler);
   }
   // ===== Direct methods (throw on error) =====
+  /**
+   * Generic request method (throws PhalaCloudError on error)
+   */
+  async request(url, options) {
+    try {
+      const method = options?.method || "GET";
+      return await this.fetchInstance(url, {
+        ...options,
+        method
+      });
+    } catch (error) {
+      const requestError = this.convertToRequestError(error);
+      const phalaCloudError = this.emitError(requestError);
+      throw phalaCloudError;
+    }
+  }
+  /**
+   * Generic request method that returns the full response (status + headers + data)
+   *
+   * Unlike other direct methods, this does NOT throw for non-2xx HTTP statuses.
+   * It only throws for network/transport/unexpected errors.
+   */
+  async requestFull(url, options) {
+    try {
+      const method = options?.method || "GET";
+      const response = await this.fetchInstance.raw(url, {
+        ...options,
+        method,
+        ignoreResponseError: true
+      });
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: response._data,
+        ok: response.ok
+      };
+    } catch (error) {
+      const requestError = this.convertToRequestError(error);
+      const phalaCloudError = this.emitError(requestError);
+      throw phalaCloudError;
+    }
+  }
   /**
    * Perform GET request (throws PhalaCloudError on error)
    */
@@ -613,6 +662,34 @@ var Client = class {
   async safeDelete(request, options) {
     return this.safeRequest(() => this.delete(request, options));
   }
+  /**
+   * Safe wrapper around the generic request method (returns SafeResult)
+   */
+  async safeRequestMethod(url, options) {
+    return this.safeRequest(() => this.request(url, options));
+  }
+  /**
+   * Safe wrapper around requestFull (returns SafeResult)
+   */
+  async safeRequestFull(url, options) {
+    return this.safeRequest(() => this.requestFull(url, options));
+  }
+  /**
+   * Create a new client with a different API version
+   *
+   * @example
+   * ```typescript
+   * const client = createClient(); // defaults to 2026-01-21
+   * const legacyClient = client.withVersion("2025-10-28");
+   * const data = await getCvmInfo(legacyClient, { id: "xxx" });
+   * ```
+   */
+  withVersion(version) {
+    return new _Client({
+      ...this.config,
+      version
+    });
+  }
   /**
    * Extend client with additional actions
    *
@@ -640,8 +717,113 @@ function createClient(config = {}) {
   return new Client(config);
 }
 
-// src/actions/get_current_user.ts
+// src/credentials/current_user_v20260121.ts
 import { z as z2 } from "zod";
+var UserInfoSchema = z2.object({
+  username: z2.string(),
+  email: z2.string(),
+  role: z2.enum(["admin", "user"]),
+  avatar: z2.string(),
+  email_verified: z2.boolean(),
+  totp_enabled: z2.boolean(),
+  has_backup_codes: z2.boolean(),
+  flag_has_password: z2.boolean()
+}).passthrough();
+var WorkspaceInfoSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  slug: z2.string().nullable(),
+  tier: z2.string(),
+  role: z2.string(),
+  avatar: z2.string().nullable().optional()
+}).passthrough();
+var CreditsInfoSchema = z2.object({
+  balance: z2.string().or(z2.number()),
+  granted_balance: z2.string().or(z2.number()),
+  is_post_paid: z2.boolean(),
+  outstanding_amount: z2.string().or(z2.number()).nullable()
+}).passthrough();
+var CurrentUserV20260121Schema = z2.object({
+  user: UserInfoSchema,
+  workspace: WorkspaceInfoSchema,
+  credits: CreditsInfoSchema
+}).passthrough();
+
+// src/credentials/current_user_v20251028.ts
+import { z as z3 } from "zod";
+var CurrentUserV20251028Schema = z3.object({
+  username: z3.string(),
+  email: z3.string(),
+  credits: z3.number(),
+  granted_credits: z3.number(),
+  avatar: z3.string(),
+  team_name: z3.string(),
+  team_tier: z3.string()
+}).passthrough();
+
+// src/actions/get_current_user.ts
+function getSchemaForVersion(version) {
+  return version === "2025-10-28" ? CurrentUserV20251028Schema : CurrentUserV20260121Schema;
+}
+async function getCurrentUser(client, parameters) {
+  const response = await client.get("/auth/me");
+  if (parameters?.schema === false) {
+    return response;
+  }
+  const schema = parameters?.schema || getSchemaForVersion(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetCurrentUser(client, parameters) {
+  try {
+    const data = await getCurrentUser(client, parameters);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/get_available_nodes.ts
+import { z as z5 } from "zod";
+
+// src/types/kms_info.ts
+import { z as z4 } from "zod";
+
+// src/types/supported_chains.ts
+import { anvil, base, mainnet } from "viem/chains";
+var SUPPORTED_CHAINS = {
+  [mainnet.id]: mainnet,
+  [base.id]: base,
+  [anvil.id]: anvil
+};
+
+// src/types/kms_info.ts
+var KmsInfoBaseSchema = z4.object({
+  id: z4.string(),
+  slug: z4.string().nullable(),
+  url: z4.string(),
+  version: z4.string(),
+  chain_id: z4.number().nullable(),
+  kms_contract_address: z4.string().nullable().transform((val) => val),
+  gateway_app_id: z4.string().nullable().transform((val) => val)
+}).passthrough();
+var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
+  if (data.chain_id != null) {
+    const chain = SUPPORTED_CHAINS[data.chain_id];
+    if (chain) {
+      return { ...data, chain };
+    }
+  }
+  return data;
+});
 
 // src/utils/validate-parameters.ts
 function validateActionParameters(parameters) {
@@ -789,95 +971,44 @@ function defineAction(schema, fn) {
   };
 }
 
-// src/actions/get_current_user.ts
-var CurrentUserSchema = z2.object({
-  username: z2.string(),
-  email: z2.string(),
-  credits: z2.number(),
-  granted_credits: z2.number(),
-  avatar: z2.string(),
-  team_name: z2.string(),
-  team_tier: z2.string()
-}).passthrough();
-var { action: getCurrentUser, safeAction: safeGetCurrentUser } = defineSimpleAction(
-  CurrentUserSchema,
-  async (client) => {
-    return await client.get("/auth/me");
-  }
-);
-
-// src/actions/get_available_nodes.ts
-import { z as z4 } from "zod";
-
-// src/types/kms_info.ts
-import { z as z3 } from "zod";
-
-// src/types/supported_chains.ts
-import { anvil, base, mainnet } from "viem/chains";
-var SUPPORTED_CHAINS = {
-  [mainnet.id]: mainnet,
-  [base.id]: base,
-  [anvil.id]: anvil
-};
-
-// src/types/kms_info.ts
-var KmsInfoBaseSchema = z3.object({
-  id: z3.string(),
-  slug: z3.string().nullable(),
-  url: z3.string(),
-  version: z3.string(),
-  chain_id: z3.number().nullable(),
-  kms_contract_address: z3.string().nullable().transform((val) => val),
-  gateway_app_id: z3.string().nullable().transform((val) => val)
-}).passthrough();
-var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
-  if (data.chain_id != null) {
-    const chain = SUPPORTED_CHAINS[data.chain_id];
-    if (chain) {
-      return { ...data, chain };
-    }
-  }
-  return data;
-});
-
 // src/actions/get_available_nodes.ts
-var AvailableOSImageSchema = z4.object({
-  name: z4.string(),
-  is_dev: z4.boolean(),
-  version: z4.union([
-    z4.tuple([z4.number(), z4.number(), z4.number()]),
-    z4.tuple([z4.number(), z4.number(), z4.number(), z4.number()])
+var AvailableOSImageSchema = z5.object({
+  name: z5.string(),
+  is_dev: z5.boolean(),
+  version: z5.union([
+    z5.tuple([z5.number(), z5.number(), z5.number()]),
+    z5.tuple([z5.number(), z5.number(), z5.number(), z5.number()])
   ]),
-  os_image_hash: z4.string().nullable().optional()
+  os_image_hash: z5.string().nullable().optional()
 }).passthrough();
-var TeepodCapacitySchema = z4.object({
-  teepod_id: z4.number(),
-  name: z4.string(),
-  listed: z4.boolean(),
-  resource_score: z4.number(),
-  remaining_vcpu: z4.number(),
-  remaining_memory: z4.number(),
-  remaining_cvm_slots: z4.number(),
-  images: z4.array(AvailableOSImageSchema),
-  support_onchain_kms: z4.boolean().optional(),
-  fmspc: z4.string().nullable().optional(),
-  device_id: z4.string().nullable().optional(),
-  region_identifier: z4.string().nullable().optional(),
-  default_kms: z4.string().nullable().optional(),
-  kms_list: z4.array(z4.string()).default([])
+var TeepodCapacitySchema = z5.object({
+  teepod_id: z5.number(),
+  name: z5.string(),
+  listed: z5.boolean(),
+  resource_score: z5.number(),
+  remaining_vcpu: z5.number(),
+  remaining_memory: z5.number(),
+  remaining_cvm_slots: z5.number(),
+  images: z5.array(AvailableOSImageSchema),
+  support_onchain_kms: z5.boolean().optional(),
+  fmspc: z5.string().nullable().optional(),
+  device_id: z5.string().nullable().optional(),
+  region_identifier: z5.string().nullable().optional(),
+  default_kms: z5.string().nullable().optional(),
+  kms_list: z5.array(z5.string()).default([])
 }).passthrough();
-var ResourceThresholdSchema = z4.object({
-  max_instances: z4.number().nullable().optional(),
-  max_vcpu: z4.number().nullable().optional(),
-  max_memory: z4.number().nullable().optional(),
-  max_disk: z4.number().nullable().optional()
+var ResourceThresholdSchema = z5.object({
+  max_instances: z5.number().nullable().optional(),
+  max_vcpu: z5.number().nullable().optional(),
+  max_memory: z5.number().nullable().optional(),
+  max_disk: z5.number().nullable().optional()
 }).passthrough();
-var AvailableNodesSchema = z4.object({
-  tier: z4.string(),
+var AvailableNodesSchema = z5.object({
+  tier: z5.string(),
   // TeamTier is string enum
   capacity: ResourceThresholdSchema,
-  nodes: z4.array(TeepodCapacitySchema),
-  kms_list: z4.array(KmsInfoSchema)
+  nodes: z5.array(TeepodCapacitySchema),
+  kms_list: z5.array(KmsInfoSchema)
 }).passthrough();
 var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
   AvailableNodesSchema,
@@ -887,33 +1018,33 @@ var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSim
 );
 
 // src/actions/list-instance-types.ts
-import { z as z5 } from "zod";
-var InstanceTypeSchema = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  description: z5.string(),
-  vcpu: z5.number(),
-  memory_mb: z5.number(),
-  hourly_rate: z5.string(),
-  requires_gpu: z5.boolean(),
-  default_disk_size_gb: z5.number().default(20),
-  family: z5.string().nullable()
+import { z as z6 } from "zod";
+var InstanceTypeSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  description: z6.string(),
+  vcpu: z6.number(),
+  memory_mb: z6.number(),
+  hourly_rate: z6.string(),
+  requires_gpu: z6.boolean(),
+  default_disk_size_gb: z6.number().default(20),
+  family: z6.string().nullable()
 }).passthrough();
-var FamilyGroupSchema = z5.object({
-  name: z5.string(),
-  items: z5.array(InstanceTypeSchema),
-  total: z5.number()
+var FamilyGroupSchema = z6.object({
+  name: z6.string(),
+  items: z6.array(InstanceTypeSchema),
+  total: z6.number()
 }).strict();
-var AllFamiliesResponseSchema = z5.object({
-  result: z5.array(FamilyGroupSchema)
+var AllFamiliesResponseSchema = z6.object({
+  result: z6.array(FamilyGroupSchema)
 }).strict();
-var FamilyInstanceTypesResponseSchema = z5.object({
-  items: z5.array(InstanceTypeSchema),
-  total: z5.number(),
-  family: z5.string()
+var FamilyInstanceTypesResponseSchema = z6.object({
+  items: z6.array(InstanceTypeSchema),
+  total: z6.number(),
+  family: z6.string()
 }).strict();
-var ListFamilyInstanceTypesRequestSchema = z5.object({
-  family: z5.string()
+var ListFamilyInstanceTypesRequestSchema = z6.object({
+  family: z6.string()
 }).strict();
 var { action: listAllInstanceTypeFamilies, safeAction: safeListAllInstanceTypeFamilies } = defineAction(
   AllFamiliesResponseSchema,
@@ -927,22 +1058,22 @@ var { action: listFamilyInstanceTypes, safeAction: safeListFamilyInstanceTypes }
 });
 
 // src/actions/workspaces/list_workspaces.ts
-import { z as z6 } from "zod";
-var WorkspaceResponseSchema = z6.object({
-  id: z6.string(),
-  name: z6.string(),
-  slug: z6.string().nullable(),
-  tier: z6.string(),
-  role: z6.string(),
-  created_at: z6.string()
+import { z as z7 } from "zod";
+var WorkspaceResponseSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  slug: z7.string().nullable(),
+  tier: z7.string(),
+  role: z7.string(),
+  created_at: z7.string()
 }).passthrough();
-var PaginationMetadataSchema = z6.object({
-  has_more: z6.boolean(),
-  next_cursor: z6.string().nullable(),
-  total: z6.number().nullable()
+var PaginationMetadataSchema = z7.object({
+  has_more: z7.boolean(),
+  next_cursor: z7.string().nullable(),
+  total: z7.number().nullable()
 }).passthrough();
-var ListWorkspacesSchema = z6.object({
-  data: z6.array(WorkspaceResponseSchema),
+var ListWorkspacesSchema = z7.object({
+  data: z7.array(WorkspaceResponseSchema),
   pagination: PaginationMetadataSchema
 }).passthrough();
 var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
@@ -958,196 +1089,393 @@ var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(Worksp
   return await client.get(`/workspaces/${teamSlug}`);
 });
 
-// src/types/cvm_info.ts
-import { z as z7 } from "zod";
-var VmInfoSchema = z7.object({
-  id: z7.string(),
-  name: z7.string(),
-  status: z7.string(),
-  uptime: z7.string(),
-  app_url: z7.string().nullable(),
-  app_id: z7.string(),
-  instance_id: z7.string().nullable(),
-  configuration: z7.any().optional(),
-  // TODO: add VmConfiguration schema if needed
-  exited_at: z7.string().nullable(),
-  boot_progress: z7.string().nullable(),
-  boot_error: z7.string().nullable(),
-  shutdown_progress: z7.string().nullable(),
-  image_version: z7.string().nullable()
-});
-var ManagedUserSchema = z7.object({
-  id: z7.number(),
-  username: z7.string()
-});
-var CvmNodeSchema = z7.object({
-  id: z7.number(),
-  name: z7.string(),
-  region_identifier: z7.string().nullable().optional()
+// src/types/cvm_info_v20251028.ts
+import { z as z8 } from "zod";
+var VmInfoV20251028Schema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  status: z8.string(),
+  uptime: z8.string(),
+  app_url: z8.string().nullable(),
+  app_id: z8.string(),
+  instance_id: z8.string().nullable(),
+  configuration: z8.any().optional(),
+  exited_at: z8.string().nullable(),
+  boot_progress: z8.string().nullable(),
+  boot_error: z8.string().nullable(),
+  shutdown_progress: z8.string().nullable(),
+  image_version: z8.string().nullable()
 });
-var CvmNetworkUrlsSchema = z7.object({
-  app: z7.string(),
-  instance: z7.string()
+var ManagedUserV20251028Schema = z8.object({
+  id: z8.number(),
+  username: z8.string()
 });
-var CvmInfoSchema = z7.object({
-  hosted: VmInfoSchema,
-  name: z7.string(),
-  managed_user: ManagedUserSchema.nullable(),
-  node: CvmNodeSchema.nullable(),
-  listed: z7.boolean().default(false),
-  status: z7.string(),
-  in_progress: z7.boolean().default(false),
-  dapp_dashboard_url: z7.string().nullable(),
-  syslog_endpoint: z7.string().nullable(),
-  allow_upgrade: z7.boolean().default(false),
-  project_id: z7.string().nullable(),
-  // HashedId is represented as string in JS
-  project_type: z7.string().nullable(),
-  billing_period: z7.string().nullable(),
+var CvmNodeV20251028Schema = z8.object({
+  id: z8.number(),
+  name: z8.string(),
+  region_identifier: z8.string().nullable().optional()
+});
+var MachineInfoV20251028Schema = z8.object({
+  vcpu: z8.number(),
+  memory: z8.number(),
+  disk_size: z8.number(),
+  gpu_count: z8.number().default(0)
+});
+var CvmNetworkUrlsV20251028Schema = z8.object({
+  app: z8.string(),
+  instance: z8.string()
+});
+var CvmInfoV20251028Schema = z8.object({
+  hosted: VmInfoV20251028Schema,
+  name: z8.string(),
+  managed_user: ManagedUserV20251028Schema.nullable(),
+  node: CvmNodeV20251028Schema.nullable(),
+  listed: z8.boolean().default(false),
+  status: z8.string(),
+  in_progress: z8.boolean().default(false),
+  dapp_dashboard_url: z8.string().nullable(),
+  syslog_endpoint: z8.string().nullable(),
+  allow_upgrade: z8.boolean().default(false),
+  project_id: z8.string().nullable(),
+  project_type: z8.string().nullable(),
+  billing_period: z8.string().nullable(),
   kms_info: KmsInfoSchema.nullable(),
-  vcpu: z7.number().nullable(),
-  memory: z7.number().nullable(),
-  disk_size: z7.number().nullable(),
-  gateway_domain: z7.string().nullable(),
-  public_urls: z7.array(CvmNetworkUrlsSchema)
-});
-var CvmLegacyDetailSchema = z7.object({
-  id: z7.number(),
-  name: z7.string(),
-  status: z7.string(),
-  in_progress: z7.boolean().optional().default(false),
-  teepod_id: z7.number().nullable(),
-  teepod: CvmNodeSchema.optional().nullable(),
-  app_id: z7.string(),
-  vm_uuid: z7.string().nullable(),
-  instance_id: z7.string().nullable(),
-  vcpu: z7.number(),
-  memory: z7.number(),
-  disk_size: z7.number(),
-  base_image: z7.string().nullable(),
-  encrypted_env_pubkey: z7.string().nullable(),
-  listed: z7.boolean().optional().default(false),
-  project_id: z7.string().optional().nullable(),
-  project_type: z7.string().optional().nullable(),
-  public_sysinfo: z7.boolean().optional().default(false),
-  public_logs: z7.boolean().optional().default(false),
-  dapp_dashboard_url: z7.string().optional().nullable(),
-  syslog_endpoint: z7.string().optional().nullable(),
+  vcpu: z8.number().nullable(),
+  memory: z8.number().nullable(),
+  disk_size: z8.number().nullable(),
+  gateway_domain: z8.string().nullable(),
+  public_urls: z8.array(CvmNetworkUrlsV20251028Schema),
+  machine_info: MachineInfoV20251028Schema.nullable().optional(),
+  updated_at: z8.string().nullable().optional()
+});
+var CvmDetailV20251028Schema = z8.object({
+  id: z8.number(),
+  name: z8.string(),
+  status: z8.string(),
+  in_progress: z8.boolean().optional().default(false),
+  teepod_id: z8.number().nullable(),
+  teepod: CvmNodeV20251028Schema.optional().nullable(),
+  app_id: z8.string(),
+  vm_uuid: z8.string().nullable(),
+  instance_id: z8.string().nullable(),
+  vcpu: z8.number(),
+  memory: z8.number(),
+  disk_size: z8.number(),
+  base_image: z8.string().nullable(),
+  encrypted_env_pubkey: z8.string().nullable(),
+  listed: z8.boolean().optional().default(false),
+  project_id: z8.string().optional().nullable(),
+  project_type: z8.string().optional().nullable(),
+  instance_type: z8.string().optional().nullable(),
+  public_sysinfo: z8.boolean().optional().default(false),
+  public_logs: z8.boolean().optional().default(false),
+  dapp_dashboard_url: z8.string().optional().nullable(),
+  syslog_endpoint: z8.string().optional().nullable(),
   kms_info: KmsInfoSchema.optional().nullable(),
-  contract_address: z7.string().optional().nullable(),
-  deployer_address: z7.string().optional().nullable(),
-  scheduled_delete_at: z7.string().optional().nullable(),
-  public_urls: z7.array(CvmNetworkUrlsSchema).optional().default([]),
-  gateway_domain: z7.string().optional().nullable()
-});
-var VMSchema = z7.object({
-  id: z7.number(),
-  name: z7.string(),
-  status: z7.string(),
-  teepod_id: z7.number(),
-  teepod: CvmNodeSchema.optional().nullable(),
-  user_id: z7.number().optional().nullable(),
-  app_id: z7.string(),
-  vm_uuid: z7.string().nullable(),
-  instance_id: z7.string().nullable(),
-  app_url: z7.string().optional().nullable(),
-  base_image: z7.string().nullable(),
-  vcpu: z7.number(),
-  memory: z7.number(),
-  disk_size: z7.number(),
-  manifest_version: z7.number().optional().nullable(),
-  version: z7.string().optional().nullable(),
-  runner: z7.string().optional().nullable(),
-  docker_compose_file: z7.string().optional().nullable(),
-  features: z7.array(z7.string()).optional().nullable(),
-  created_at: z7.string(),
-  // datetime serialized as ISO string
-  encrypted_env_pubkey: z7.string().nullable()
+  contract_address: z8.string().optional().nullable(),
+  deployer_address: z8.string().optional().nullable(),
+  scheduled_delete_at: z8.string().optional().nullable(),
+  public_urls: z8.array(CvmNetworkUrlsV20251028Schema).optional().default([]),
+  gateway_domain: z8.string().optional().nullable(),
+  machine_info: MachineInfoV20251028Schema.optional().nullable(),
+  updated_at: z8.string().optional().nullable()
+});
+var PaginatedCvmInfosV20251028Schema = z8.object({
+  items: z8.array(CvmInfoV20251028Schema),
+  total: z8.number(),
+  page: z8.number(),
+  page_size: z8.number(),
+  pages: z8.number()
+});
+
+// src/types/cvm_info_v20260121.ts
+import { z as z9 } from "zod";
+var BillingPeriodSchema = z9.enum(["skip", "hourly", "monthly"]);
+var KmsTypeSchema = z9.enum(["phala", "ethereum", "base", "legacy"]);
+var UserRefSchema = z9.object({
+  object_type: z9.literal("user"),
+  id: z9.string().nullable().optional(),
+  username: z9.string().nullable().optional(),
+  avatar_url: z9.string().nullable().optional()
+});
+var WorkspaceRefSchema = z9.object({
+  object_type: z9.literal("workspace"),
+  id: z9.string(),
+  name: z9.string(),
+  slug: z9.string().nullable().optional(),
+  avatar_url: z9.string().nullable().optional()
+});
+var CvmResourceInfoV20260121Schema = z9.object({
+  instance_type: z9.string().nullable().optional(),
+  vcpu: z9.number().int().nullable().optional(),
+  memory_in_gb: z9.number().nullable().optional(),
+  disk_in_gb: z9.number().int().nullable().optional(),
+  gpus: z9.number().int().nullable().optional(),
+  compute_billing_price: z9.string().nullable().optional(),
+  billing_period: BillingPeriodSchema.nullable().optional()
+});
+var CvmOsInfoV20260121Schema = z9.object({
+  name: z9.string().nullable().optional(),
+  version: z9.string().nullable().optional(),
+  is_dev: z9.boolean().nullable().optional(),
+  os_image_hash: z9.string().nullable().optional()
+});
+var CvmKmsInfoV20260121Schema = z9.object({
+  chain_id: z9.number().int().nullable().optional(),
+  dstack_kms_address: z9.string().nullable().optional(),
+  dstack_app_address: z9.string().nullable().optional(),
+  deployer_address: z9.string().nullable().optional(),
+  rpc_endpoint: z9.string().nullable().optional(),
+  encrypted_env_pubkey: z9.string().nullable().optional()
+});
+var CvmProgressInfoV20260121Schema = z9.object({
+  target: z9.string().nullable().optional(),
+  started_at: z9.string().nullable().optional(),
+  correlation_id: z9.string().nullable().optional()
+});
+var CvmGatewayInfoV20260121Schema = z9.object({
+  base_domain: z9.string().nullable().optional(),
+  cname: z9.string().nullable().optional()
+});
+var CvmNodeInfoV20260121Schema = z9.object({
+  name: z9.string().nullable().optional(),
+  region: z9.string().nullable().optional(),
+  device_id: z9.string().nullable().optional(),
+  ppid: z9.string().nullable().optional(),
+  status: z9.string().nullable().optional(),
+  version: z9.string().nullable().optional()
+});
+var CvmInfoV20260121Schema = z9.object({
+  id: z9.string(),
+  // hashed CvmId
+  name: z9.string(),
+  app_id: z9.string().nullable().optional(),
+  vm_uuid: z9.string().nullable().optional(),
+  resource: CvmResourceInfoV20260121Schema,
+  node_info: CvmNodeInfoV20260121Schema.nullable().optional(),
+  os: CvmOsInfoV20260121Schema.nullable().optional(),
+  kms_type: KmsTypeSchema.nullable().optional(),
+  kms_info: CvmKmsInfoV20260121Schema.nullable().optional(),
+  status: z9.string(),
+  progress: CvmProgressInfoV20260121Schema.nullable().optional(),
+  compose_hash: z9.string().nullable().optional(),
+  gateway: CvmGatewayInfoV20260121Schema,
+  services: z9.array(z9.record(z9.any())).optional().default([]),
+  endpoints: z9.array(CvmNetworkUrlsV20251028Schema).nullable().optional(),
+  public_logs: z9.boolean().optional(),
+  public_sysinfo: z9.boolean().optional(),
+  public_tcbinfo: z9.boolean().optional(),
+  gateway_enabled: z9.boolean().optional(),
+  secure_time: z9.boolean().optional(),
+  storage_fs: z9.string().optional(),
+  workspace: WorkspaceRefSchema.nullable().optional(),
+  creator: UserRefSchema.nullable().optional()
+});
+var CvmInfoDetailV20260121Schema = CvmInfoV20260121Schema.extend({
+  compose_file: z9.union([z9.record(z9.any()), z9.string()]).nullable().optional()
+});
+var PaginatedCvmInfosV20260121Schema = z9.object({
+  items: z9.array(CvmInfoV20260121Schema),
+  total: z9.number(),
+  page: z9.number(),
+  page_size: z9.number(),
+  pages: z9.number()
 });
 
 // src/types/cvm_id.ts
-import { z as z8 } from "zod";
-var CvmIdObjectSchema = z8.object({
-  /** Direct CVM ID (any format) */
-  id: z8.string().optional(),
+import { z as z10 } from "zod";
+
+// src/utils/hostname.ts
+function isValidHostname(name) {
+  if (typeof name !== "string" || name.length < 5 || name.length > 63) {
+    return false;
+  }
+  return /^[a-zA-Z](?!.*--)([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(name);
+}
+function convertToHostname(input) {
+  if (typeof input !== "string") {
+    return generateFallbackHostname();
+  }
+  let result = input;
+  result = result.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  result = result.replace(/_/g, "-");
+  result = result.replace(/[^a-z0-9\s-]/gi, "-").replace(/\s+/g, "-");
+  result = result.replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  if (result.length === 0) {
+    return generateFallbackHostname();
+  }
+  if (/^\d/.test(result)) {
+    result = `dstack-app-${result}`;
+  }
+  if (result.length < 5) {
+    result = `dstack-app-${result}`;
+  }
+  result = result.slice(0, 63).replace(/-+$/, "");
+  if (result.length === 0) {
+    return generateFallbackHostname();
+  }
+  if (!isValidHostname(result)) {
+    return generateFallbackHostname();
+  }
+  return result;
+}
+function generateFallbackHostname() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 6);
+  return `dstack-app-${timestamp}-${random}`;
+}
+function generateDefaultCvmName(prefix = "dstack-app") {
+  const random = Array.from(
+    { length: 5 },
+    () => "abcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 36)]
+  ).join("");
+  const result = `${prefix}-${random}`;
+  if (result.length > 63) {
+    const shortRandom = Array.from(
+      { length: 3 },
+      () => "abcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 36)]
+    ).join("");
+    return `${prefix.slice(0, 55)}-${shortRandom}`;
+  }
+  return result;
+}
+
+// src/types/cvm_id.ts
+var CvmIdObjectSchema = z10.object({
+  /** Direct CVM ID (any format) - accepts any string including names */
+  id: z10.string().optional(),
   /** UUID format (with or without dashes) */
-  uuid: z8.string().regex(
+  uuid: z10.string().regex(
     /^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i,
     "Invalid UUID format"
   ).optional(),
   /** App ID (40 characters, optionally prefixed with 'app_id_') */
-  app_id: z8.string().optional(),
+  app_id: z10.string().optional(),
   /** Instance ID (40 characters, optionally prefixed with 'instance_') */
-  instance_id: z8.string().optional()
+  instance_id: z10.string().optional(),
+  /** CVM name (RFC 1123 hostname format: 5-63 chars, starts with letter, alphanumeric + hyphens) */
+  name: z10.string().refine(isValidHostname, {
+    message: "Name must be 5-63 characters, start with letter, and contain only letters/numbers/hyphens"
+  }).optional()
 });
 var refineCvmId = (schema) => schema.refine(
   (data) => {
     const obj = data;
-    return !!(obj.id || obj.uuid || obj.app_id || obj.instance_id);
+    return !!(obj.id || obj.uuid || obj.app_id || obj.instance_id || obj.name);
   },
   {
-    message: "One of id, uuid, app_id, or instance_id must be provided"
+    message: "One of id, uuid, app_id, instance_id, or name must be provided"
   }
 );
 var CvmIdBaseSchema = refineCvmId(CvmIdObjectSchema);
 var CvmIdSchema = CvmIdBaseSchema.transform((data) => {
-  let cvmId;
+  let rawValue;
   if (data.id) {
-    cvmId = data.id;
+    rawValue = data.id;
   } else if (data.uuid) {
-    cvmId = data.uuid.replace(/-/g, "");
+    rawValue = data.uuid;
   } else if (data.app_id) {
-    cvmId = data.app_id.startsWith("app_") ? data.app_id : `app_${data.app_id}`;
+    rawValue = data.app_id;
   } else if (data.instance_id) {
-    cvmId = data.instance_id.startsWith("instance_") ? data.instance_id : `instance_${data.instance_id}`;
+    rawValue = data.instance_id;
+  } else if (data.name) {
+    return { cvmId: data.name };
   } else {
     throw new Error("No valid identifier provided");
   }
+  const uuidRegex = /^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i;
+  const appIdRegex = /^[0-9a-f]{40}$/i;
+  let cvmId;
+  if (uuidRegex.test(rawValue)) {
+    cvmId = rawValue.replace(/-/g, "");
+  } else if (appIdRegex.test(rawValue)) {
+    cvmId = `app_${rawValue}`;
+  } else {
+    cvmId = rawValue;
+  }
   return { cvmId };
 });
 
 // src/actions/cvms/get_cvm_info.ts
 var GetCvmInfoRequestSchema = CvmIdSchema;
-var { action: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
+function getSchemaForVersion2(version) {
+  return version === "2025-10-28" ? CvmDetailV20251028Schema : CvmInfoDetailV20260121Schema;
+}
+async function getCvmInfo(client, request) {
   const { cvmId } = GetCvmInfoRequestSchema.parse(request);
-  return await client.get(`/cvms/${cvmId}`);
-});
+  const response = await client.get(`/cvms/${cvmId}`);
+  const schema = getSchemaForVersion2(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetCvmInfo(client, request) {
+  try {
+    const data = await getCvmInfo(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
 
 // src/actions/cvms/get_cvm_list.ts
-import { z as z9 } from "zod";
-var GetCvmListRequestSchema = z9.object({
-  page: z9.number().int().min(1).optional(),
-  page_size: z9.number().int().min(1).optional(),
-  node_id: z9.number().int().min(1).optional(),
-  teepod_id: z9.number().int().min(1).optional(),
-  user_id: z9.string().optional()
-}).strict();
-var GetCvmListSchema = z9.object({
-  items: z9.array(CvmInfoSchema),
-  total: z9.number(),
-  page: z9.number(),
-  page_size: z9.number(),
-  pages: z9.number()
+import { z as z11 } from "zod";
+var GetCvmListRequestSchema = z11.object({
+  page: z11.number().int().min(1).optional(),
+  page_size: z11.number().int().min(1).optional(),
+  node_id: z11.number().int().min(1).optional(),
+  teepod_id: z11.number().int().min(1).optional(),
+  user_id: z11.string().optional()
 }).strict();
-var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
+function getSchemaForVersion3(version) {
+  return version === "2025-10-28" ? PaginatedCvmInfosV20251028Schema : PaginatedCvmInfosV20260121Schema;
+}
+async function getCvmList(client, request) {
   const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
-  return await client.get("/cvms/paginated", { params: validatedRequest });
-});
+  const response = await client.get("/cvms/paginated", { params: validatedRequest });
+  const schema = getSchemaForVersion3(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetCvmList(client, request) {
+  try {
+    const data = await getCvmList(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
 
 // src/actions/cvms/provision_cvm.ts
-import { z as z10 } from "zod";
-var ProvisionCvmSchema = z10.object({
-  app_id: z10.string().nullable().optional(),
-  app_env_encrypt_pubkey: z10.string().nullable().optional(),
-  compose_hash: z10.string(),
-  fmspc: z10.string().nullable().optional(),
-  device_id: z10.string().nullable().optional(),
-  os_image_hash: z10.string().nullable().optional(),
-  instance_type: z10.string().nullable().optional(),
-  teepod_id: z10.number().nullable().optional(),
+import { z as z12 } from "zod";
+var ProvisionCvmSchema = z12.object({
+  app_id: z12.string().nullable().optional(),
+  app_env_encrypt_pubkey: z12.string().nullable().optional(),
+  compose_hash: z12.string(),
+  kms_info: KmsInfoSchema.nullable().optional(),
+  fmspc: z12.string().nullable().optional(),
+  device_id: z12.string().nullable().optional(),
+  os_image_hash: z12.string().nullable().optional(),
+  instance_type: z12.string().nullable().optional(),
+  teepod_id: z12.number().nullable().optional(),
   // Will be transformed to node_id
-  node_id: z10.number().nullable().optional(),
-  kms_id: z10.string().nullable().optional()
+  node_id: z12.number().nullable().optional(),
+  kms_id: z12.string().nullable().optional()
 }).passthrough().transform((data) => {
   if ("teepod_id" in data && data.teepod_id !== void 0) {
     const { teepod_id, ...rest } = data;
@@ -1155,47 +1483,55 @@ var ProvisionCvmSchema = z10.object({
   }
   return data;
 });
-var ProvisionCvmRequestSchema = z10.object({
-  node_id: z10.number().optional(),
+var NAME_VALIDATION_MESSAGE = "Name must be 5-63 characters, start with letter, and contain only letters/numbers/hyphens";
+var ProvisionCvmRequestSchema = z12.object({
+  node_id: z12.number().optional(),
   // recommended - optional, system auto-selects if not specified
-  teepod_id: z10.number().optional(),
+  teepod_id: z12.number().optional(),
   // deprecated, for compatibility
-  region: z10.string().optional(),
+  region: z12.string().optional(),
   // optional - region filter for auto-selection
-  name: z10.string(),
-  instance_type: z10.string().default("tdx.small"),
-  // defaults to "tdx.small"
-  image: z10.string().optional(),
-  vcpu: z10.number().optional(),
-  memory: z10.number().optional(),
-  disk_size: z10.number().optional(),
-  compose_file: z10.object({
-    allowed_envs: z10.array(z10.string()).optional(),
-    pre_launch_script: z10.string().optional(),
-    docker_compose_file: z10.string().optional(),
-    name: z10.string().optional().default(""),
+  name: z12.string().min(5, NAME_VALIDATION_MESSAGE).max(63, NAME_VALIDATION_MESSAGE).refine((val) => isValidHostname(val), NAME_VALIDATION_MESSAGE),
+  instance_type: z12.string().optional(),
+  // optional, defaults to "tdx.small" when no resource params specified
+  image: z12.string().optional(),
+  vcpu: z12.number().optional(),
+  // deprecated, use instance_type instead
+  memory: z12.number().optional(),
+  // deprecated, use instance_type instead
+  disk_size: z12.number().optional(),
+  compose_file: z12.object({
+    allowed_envs: z12.array(z12.string()).optional(),
+    pre_launch_script: z12.string().optional(),
+    docker_compose_file: z12.string().optional(),
+    name: z12.string().optional().default(""),
     // optional with default empty string
-    kms_enabled: z10.boolean().optional(),
-    public_logs: z10.boolean().optional(),
-    public_sysinfo: z10.boolean().optional(),
-    gateway_enabled: z10.boolean().optional(),
+    kms_enabled: z12.boolean().optional(),
+    public_logs: z12.boolean().optional(),
+    public_sysinfo: z12.boolean().optional(),
+    gateway_enabled: z12.boolean().optional(),
     // recommended
-    tproxy_enabled: z10.boolean().optional()
+    tproxy_enabled: z12.boolean().optional()
     // deprecated, for compatibility
   }),
-  listed: z10.boolean().optional(),
-  kms_id: z10.string().optional(),
-  kms: z10.enum(["PHALA", "ETHEREUM", "BASE"]).optional(),
+  listed: z12.boolean().optional(),
+  kms_id: z12.string().optional(),
+  kms: z12.enum(["PHALA", "ETHEREUM", "BASE"]).optional(),
   // KMS type selection (defaults to PHALA)
-  kms_contract: z10.string().optional(),
+  kms_contract: z12.string().optional(),
   // KMS contract address for on-chain KMS
-  env_keys: z10.array(z10.string()).optional(),
+  env_keys: z12.array(z12.string()).optional(),
   // Manual nonce specification (Advanced - PHALA KMS only)
-  nonce: z10.number().optional(),
+  nonce: z12.number().optional(),
   // User-specified nonce for deterministic app_id generation
-  app_id: z10.string().optional()
+  app_id: z12.string().optional()
   // Expected app_id (must match calculated app_id from nonce)
-}).passthrough();
+}).passthrough().transform((data) => {
+  if (!data.instance_type && !data.vcpu && !data.memory) {
+    return { ...data, instance_type: "tdx.small" };
+  }
+  return data;
+});
 function handleGatewayCompatibility(appCompose) {
   if (!appCompose.compose_file) {
     return appCompose;
@@ -1231,63 +1567,64 @@ var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(Provis
 });
 
 // src/actions/cvms/commit_cvm_provision.ts
-import { z as z11 } from "zod";
-var CommitCvmProvisionSchema = z11.object({
-  id: z11.number(),
-  name: z11.string(),
-  status: z11.string(),
-  teepod_id: z11.number(),
-  teepod: z11.object({
-    id: z11.number(),
-    name: z11.string()
+import { z as z13 } from "zod";
+var CommitCvmProvisionSchema = z13.object({
+  id: z13.number(),
+  name: z13.string(),
+  status: z13.string(),
+  teepod_id: z13.number(),
+  teepod: z13.object({
+    id: z13.number(),
+    name: z13.string()
   }).nullable(),
-  user_id: z11.number().nullable(),
-  app_id: z11.string().nullable(),
-  vm_uuid: z11.string().nullable(),
-  instance_id: z11.string().nullable(),
-  app_url: z11.string().nullable(),
-  base_image: z11.string().nullable(),
-  vcpu: z11.number(),
-  memory: z11.number(),
-  disk_size: z11.number(),
-  manifest_version: z11.number().nullable(),
-  version: z11.string().nullable(),
-  runner: z11.string().nullable(),
-  docker_compose_file: z11.string().nullable(),
-  features: z11.array(z11.string()).nullable(),
-  created_at: z11.string(),
-  encrypted_env_pubkey: z11.string().nullable().optional(),
-  app_auth_contract_address: z11.string().nullable().optional(),
-  deployer_address: z11.string().nullable().optional()
+  user_id: z13.number().nullable(),
+  app_id: z13.string().nullable(),
+  vm_uuid: z13.string().nullable(),
+  instance_id: z13.string().nullable(),
+  // Deprecated fields - will be removed in next API version
+  app_url: z13.string().nullable().default(null),
+  base_image: z13.string().nullable(),
+  vcpu: z13.number(),
+  memory: z13.number(),
+  disk_size: z13.number(),
+  manifest_version: z13.number().nullable().default(2),
+  version: z13.string().nullable().default("1.0.0"),
+  runner: z13.string().nullable().default("docker-compose"),
+  docker_compose_file: z13.string().nullable(),
+  features: z13.array(z13.string()).nullable().default(["kms", "tproxy-net"]),
+  created_at: z13.string(),
+  encrypted_env_pubkey: z13.string().nullable().optional(),
+  app_auth_contract_address: z13.string().nullable().optional(),
+  deployer_address: z13.string().nullable().optional()
 }).passthrough();
-var CommitCvmProvisionRequestSchema = z11.object({
-  encrypted_env: z11.string().optional().nullable(),
-  app_id: z11.string(),
-  compose_hash: z11.string(),
-  kms_id: z11.string().optional(),
-  contract_address: z11.string().optional(),
-  deployer_address: z11.string().optional(),
-  env_keys: z11.array(z11.string()).optional().nullable()
+var CommitCvmProvisionRequestSchema = z13.object({
+  encrypted_env: z13.string().optional().nullable(),
+  app_id: z13.string(),
+  compose_hash: z13.string(),
+  kms_id: z13.string().optional(),
+  contract_address: z13.string().optional(),
+  deployer_address: z13.string().optional(),
+  env_keys: z13.array(z13.string()).optional().nullable()
 }).passthrough();
 var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
   return await client.post("/cvms", payload);
 });
 
 // src/types/app_compose.ts
-import { z as z12 } from "zod";
-var LooseAppComposeSchema = z12.object({
-  allowed_envs: z12.array(z12.string()).optional(),
-  docker_compose_file: z12.string(),
-  features: z12.array(z12.string()).optional(),
-  name: z12.string().optional(),
-  manifest_version: z12.number().optional(),
-  kms_enabled: z12.boolean().optional(),
-  public_logs: z12.boolean().optional(),
-  public_sysinfo: z12.boolean().optional(),
-  tproxy_enabled: z12.boolean().optional(),
-  pre_launch_script: z12.string().optional(),
-  env_pubkey: z12.string().optional(),
-  salt: z12.string().optional().nullable()
+import { z as z14 } from "zod";
+var LooseAppComposeSchema = z14.object({
+  allowed_envs: z14.array(z14.string()).optional(),
+  docker_compose_file: z14.string(),
+  features: z14.array(z14.string()).optional(),
+  name: z14.string().optional(),
+  manifest_version: z14.number().optional(),
+  kms_enabled: z14.boolean().optional(),
+  public_logs: z14.boolean().optional(),
+  public_sysinfo: z14.boolean().optional(),
+  tproxy_enabled: z14.boolean().optional(),
+  pre_launch_script: z14.string().optional(),
+  env_pubkey: z14.string().optional(),
+  salt: z14.string().optional().nullable()
 }).passthrough();
 
 // src/utils/get_compose_hash.ts
@@ -1350,20 +1687,20 @@ var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAct
 });
 
 // src/actions/cvms/provision_cvm_compose_file_update.ts
-import { z as z13 } from "zod";
-var ProvisionCvmComposeFileUpdateRequestSchema = z13.object({
-  id: z13.string().optional(),
-  uuid: z13.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: z13.string().refine(
+import { z as z15 } from "zod";
+var ProvisionCvmComposeFileUpdateRequestSchema = z15.object({
+  id: z15.string().optional(),
+  uuid: z15.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: z15.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: z13.string().refine(
+  instance_id: z15.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
   app_compose: LooseAppComposeSchema,
-  update_env_vars: z13.boolean().optional().nullable()
+  update_env_vars: z15.boolean().optional().nullable()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
@@ -1374,10 +1711,10 @@ var ProvisionCvmComposeFileUpdateRequestSchema = z13.object({
     _raw: data
   };
 });
-var ProvisionCvmComposeFileUpdateResultSchema = z13.object({
-  app_id: z13.string().nullable(),
-  device_id: z13.string().nullable(),
-  compose_hash: z13.string(),
+var ProvisionCvmComposeFileUpdateResultSchema = z15.object({
+  app_id: z15.string().nullable(),
+  device_id: z15.string().nullable(),
+  compose_hash: z15.string(),
   kms_info: KmsInfoSchema.nullable().optional()
 }).passthrough();
 var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
@@ -1389,22 +1726,22 @@ var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmCompose
 });
 
 // src/actions/cvms/commit_cvm_compose_file_update.ts
-import { z as z14 } from "zod";
-var CommitCvmComposeFileUpdateRequestSchema = z14.object({
-  id: z14.string().optional(),
-  uuid: z14.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
-  app_id: z14.string().refine(
+import { z as z16 } from "zod";
+var CommitCvmComposeFileUpdateRequestSchema = z16.object({
+  id: z16.string().optional(),
+  uuid: z16.string().regex(/^[0-9a-f]{8}[-]?[0-9a-f]{4}[-]?4[0-9a-f]{3}[-]?[89ab][0-9a-f]{3}[-]?[0-9a-f]{12}$/i).optional(),
+  app_id: z16.string().refine(
     (val) => !val.startsWith("app_") && val.length === 40,
     "app_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
-  instance_id: z14.string().refine(
+  instance_id: z16.string().refine(
     (val) => !val.startsWith("instance_") && val.length === 40,
     "instance_id should be 40 characters without prefix"
   ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
-  compose_hash: z14.string().min(1, "Compose hash is required"),
-  encrypted_env: z14.string().optional(),
-  env_keys: z14.array(z14.string()).optional(),
-  update_env_vars: z14.boolean().optional().nullable()
+  compose_hash: z16.string().min(1, "Compose hash is required"),
+  encrypted_env: z16.string().optional(),
+  env_keys: z16.array(z16.string()).optional(),
+  update_env_vars: z16.boolean().optional().nullable()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
@@ -1413,10 +1750,10 @@ var CommitCvmComposeFileUpdateRequestSchema = z14.object({
   compose_hash: data.compose_hash,
   encrypted_env: data.encrypted_env,
   env_keys: data.env_keys,
-  update_env_vars: !!data.update_env_vars,
+  update_env_vars: data.update_env_vars ?? void 0,
   _raw: data
 }));
-var CommitCvmComposeFileUpdateSchema = z14.any().transform(() => void 0);
+var CommitCvmComposeFileUpdateSchema = z16.any().transform(() => void 0);
 var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
   CommitCvmComposeFileUpdateSchema,
   async (client, request) => {
@@ -1424,15 +1761,241 @@ var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUp
     return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
       compose_hash: validatedRequest.compose_hash,
       encrypted_env: validatedRequest.encrypted_env,
-      env_keys: validatedRequest.env_keys
+      env_keys: validatedRequest.env_keys,
+      update_env_vars: validatedRequest.update_env_vars
     });
   }
 );
 
+// src/actions/cvms/update_cvm_envs.ts
+import { z as z17 } from "zod";
+var UpdateCvmEnvsRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    encrypted_env: z17.string().describe("Encrypted environment variables (hex string)"),
+    env_keys: z17.array(z17.string()).optional().describe("List of allowed environment variable keys"),
+    compose_hash: z17.string().optional().describe("Compose hash for verification (Phase 2, required when env_keys changes)"),
+    transaction_hash: z17.string().optional().describe(
+      "On-chain transaction hash for verification (Phase 2, required when env_keys changes)"
+    )
+  })
+).transform((data) => {
+  const { cvmId } = CvmIdSchema.parse(data);
+  return {
+    cvmId,
+    request: {
+      encrypted_env: data.encrypted_env,
+      env_keys: data.env_keys,
+      compose_hash: data.compose_hash,
+      transaction_hash: data.transaction_hash
+    },
+    _raw: data
+  };
+});
+var UpdateCvmEnvsInProgressSchema = z17.object({
+  status: z17.literal("in_progress"),
+  message: z17.string(),
+  correlation_id: z17.string(),
+  allowed_envs_changed: z17.boolean()
+});
+var UpdateCvmEnvsPreconditionRequiredSchema = z17.object({
+  status: z17.literal("precondition_required"),
+  message: z17.string(),
+  compose_hash: z17.string(),
+  app_id: z17.string(),
+  device_id: z17.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdateCvmEnvsResultSchema = z17.union([
+  UpdateCvmEnvsInProgressSchema,
+  UpdateCvmEnvsPreconditionRequiredSchema
+]);
+var { action: updateCvmEnvs, safeAction: safeUpdateCvmEnvs } = defineAction(UpdateCvmEnvsResultSchema, async (client, request) => {
+  const validatedRequest = UpdateCvmEnvsRequestSchema.parse(request);
+  try {
+    const response = await client.patch(
+      `/cvms/${validatedRequest.cvmId}/envs`,
+      validatedRequest.request
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof PhalaCloudError && error.status === 465) {
+      const detail = error.detail;
+      if (detail && typeof detail === "object") {
+        const detailObj = detail;
+        return {
+          status: "precondition_required",
+          message: detailObj.message || "Compose hash verification required",
+          compose_hash: detailObj.compose_hash,
+          app_id: detailObj.app_id,
+          device_id: detailObj.device_id,
+          kms_info: detailObj.kms_info
+        };
+      }
+    }
+    throw error;
+  }
+});
+
+// src/actions/cvms/update_docker_compose.ts
+import { z as z18 } from "zod";
+var UpdateDockerComposeRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    docker_compose_file: z18.string().describe("Docker Compose YAML content"),
+    compose_hash: z18.string().optional().describe("Compose hash for verification (Phase 2, contract-owned KMS only)"),
+    transaction_hash: z18.string().optional().describe("On-chain transaction hash for verification (Phase 2, contract-owned KMS only)")
+  })
+).transform((data) => {
+  const { cvmId } = CvmIdSchema.parse(data);
+  return {
+    cvmId,
+    request: {
+      docker_compose_file: data.docker_compose_file,
+      compose_hash: data.compose_hash,
+      transaction_hash: data.transaction_hash
+    },
+    _raw: data
+  };
+});
+var UpdateDockerComposeInProgressSchema = z18.object({
+  status: z18.literal("in_progress"),
+  message: z18.string(),
+  correlation_id: z18.string()
+});
+var UpdateDockerComposePreconditionRequiredSchema = z18.object({
+  status: z18.literal("precondition_required"),
+  message: z18.string(),
+  compose_hash: z18.string(),
+  app_id: z18.string(),
+  device_id: z18.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdateDockerComposeResultSchema = z18.union([
+  UpdateDockerComposeInProgressSchema,
+  UpdateDockerComposePreconditionRequiredSchema
+]);
+var { action: updateDockerCompose, safeAction: safeUpdateDockerCompose } = defineAction(UpdateDockerComposeResultSchema, async (client, request) => {
+  const validatedRequest = UpdateDockerComposeRequestSchema.parse(request);
+  const headers = {
+    "Content-Type": "text/yaml"
+  };
+  if (validatedRequest.request.compose_hash) {
+    headers["X-Compose-Hash"] = validatedRequest.request.compose_hash;
+  }
+  if (validatedRequest.request.transaction_hash) {
+    headers["X-Transaction-Hash"] = validatedRequest.request.transaction_hash;
+  }
+  try {
+    const response = await client.patch(
+      `/cvms/${validatedRequest.cvmId}/docker-compose`,
+      validatedRequest.request.docker_compose_file,
+      { headers }
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof PhalaCloudError && error.status === 465) {
+      const detail = error.detail;
+      if (detail && typeof detail === "object") {
+        const detailObj = detail;
+        return {
+          status: "precondition_required",
+          message: detailObj.message || "Compose hash verification required",
+          compose_hash: detailObj.compose_hash,
+          app_id: detailObj.app_id,
+          device_id: detailObj.device_id,
+          kms_info: detailObj.kms_info
+        };
+      }
+    }
+    throw error;
+  }
+});
+
+// src/actions/cvms/update_prelaunch_script.ts
+import { z as z19 } from "zod";
+var UpdatePreLaunchScriptRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    pre_launch_script: z19.string().describe("Pre-launch script content (shell script)"),
+    compose_hash: z19.string().optional().describe("Compose hash for verification (Phase 2, contract-owned KMS only)"),
+    transaction_hash: z19.string().optional().describe("On-chain transaction hash for verification (Phase 2, contract-owned KMS only)")
+  })
+).transform((data) => {
+  const { cvmId } = CvmIdSchema.parse(data);
+  return {
+    cvmId,
+    request: {
+      pre_launch_script: data.pre_launch_script,
+      compose_hash: data.compose_hash,
+      transaction_hash: data.transaction_hash
+    },
+    _raw: data
+  };
+});
+var UpdatePreLaunchScriptInProgressSchema = z19.object({
+  status: z19.literal("in_progress"),
+  message: z19.string(),
+  correlation_id: z19.string()
+});
+var UpdatePreLaunchScriptPreconditionRequiredSchema = z19.object({
+  status: z19.literal("precondition_required"),
+  message: z19.string(),
+  compose_hash: z19.string(),
+  app_id: z19.string(),
+  device_id: z19.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdatePreLaunchScriptResultSchema = z19.union([
+  UpdatePreLaunchScriptInProgressSchema,
+  UpdatePreLaunchScriptPreconditionRequiredSchema
+]);
+var { action: updatePreLaunchScript, safeAction: safeUpdatePreLaunchScript } = defineAction(UpdatePreLaunchScriptResultSchema, async (client, request) => {
+  const validatedRequest = UpdatePreLaunchScriptRequestSchema.parse(request);
+  const headers = {
+    "Content-Type": "text/plain"
+  };
+  if (validatedRequest.request.compose_hash) {
+    headers["X-Compose-Hash"] = validatedRequest.request.compose_hash;
+  }
+  if (validatedRequest.request.transaction_hash) {
+    headers["X-Transaction-Hash"] = validatedRequest.request.transaction_hash;
+  }
+  try {
+    const response = await client.patch(
+      `/cvms/${validatedRequest.cvmId}/pre-launch-script`,
+      validatedRequest.request.pre_launch_script,
+      { headers }
+    );
+    return response;
+  } catch (error) {
+    if (error instanceof PhalaCloudError && error.status === 465) {
+      const detail = error.detail;
+      if (detail && typeof detail === "object") {
+        const detailObj = detail;
+        return {
+          status: "precondition_required",
+          message: detailObj.message || "Compose hash verification required",
+          compose_hash: detailObj.compose_hash,
+          app_id: detailObj.app_id,
+          device_id: detailObj.device_id,
+          kms_info: detailObj.kms_info
+        };
+      }
+    }
+    throw error;
+  }
+});
+
+// src/actions/cvms/get_cvm_prelaunch_script.ts
+import { z as z20 } from "zod";
+var GetCvmPreLaunchScriptRequestSchema = CvmIdSchema;
+var { action: getCvmPreLaunchScript, safeAction: safeGetCvmPreLaunchScript } = defineAction(z20.string(), async (client, request) => {
+  const { cvmId } = GetCvmPreLaunchScriptRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/pre-launch-script`);
+});
+
 // src/actions/kms/get_kms_info.ts
-import { z as z15 } from "zod";
-var GetKmsInfoRequestSchema = z15.object({
-  kms_id: z15.string().min(1, "KMS ID is required")
+import { z as z21 } from "zod";
+var GetKmsInfoRequestSchema = z21.object({
+  kms_id: z21.string().min(1, "KMS ID is required")
 });
 var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
   const validatedRequest = GetKmsInfoRequestSchema.parse(request);
@@ -1440,18 +2003,18 @@ var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSch
 });
 
 // src/actions/kms/get_kms_list.ts
-import { z as z16 } from "zod";
-var GetKmsListRequestSchema = z16.object({
-  page: z16.number().int().min(1).optional(),
-  page_size: z16.number().int().min(1).optional(),
-  is_onchain: z16.boolean().optional()
+import { z as z22 } from "zod";
+var GetKmsListRequestSchema = z22.object({
+  page: z22.number().int().min(1).optional(),
+  page_size: z22.number().int().min(1).optional(),
+  is_onchain: z22.boolean().optional()
 }).strict();
-var GetKmsListSchema = z16.object({
-  items: z16.array(KmsInfoSchema),
-  total: z16.number(),
-  page: z16.number(),
-  page_size: z16.number(),
-  pages: z16.number()
+var GetKmsListSchema = z22.object({
+  items: z22.array(KmsInfoSchema),
+  total: z22.number(),
+  page: z22.number(),
+  page_size: z22.number(),
+  pages: z22.number()
 }).strict();
 var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
   const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
@@ -1459,17 +2022,17 @@ var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsList
 });
 
 // src/actions/kms/get_app_env_encrypt_pubkey.ts
-import { z as z17 } from "zod";
-var GetAppEnvEncryptPubKeyRequestSchema = z17.object({
-  kms: z17.string().min(1, "KMS ID or slug is required"),
-  app_id: z17.string().refine(
+import { z as z23 } from "zod";
+var GetAppEnvEncryptPubKeyRequestSchema = z23.object({
+  kms: z23.string().min(1, "KMS ID or slug is required"),
+  app_id: z23.string().refine(
     (val) => val.length === 40 || val.startsWith("0x") && val.length === 42,
     "App ID must be exactly 40 characters or 42 characters with 0x prefix"
   )
 }).strict();
-var GetAppEnvEncryptPubKeySchema = z17.object({
-  public_key: z17.string(),
-  signature: z17.string()
+var GetAppEnvEncryptPubKeySchema = z23.object({
+  public_key: z23.string(),
+  signature: z23.string()
 }).strict();
 var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
@@ -1477,15 +2040,15 @@ var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } =
 });
 
 // src/actions/kms/next_app_ids.ts
-import { z as z18 } from "zod";
-var NextAppIdsRequestSchema = z18.object({
-  counts: z18.number().int().min(1).max(20).optional().default(1)
+import { z as z24 } from "zod";
+var NextAppIdsRequestSchema = z24.object({
+  counts: z24.number().int().min(1).max(20).optional().default(1)
 }).strict();
-var NextAppIdsSchema = z18.object({
-  app_ids: z18.array(
-    z18.object({
-      app_id: z18.string(),
-      nonce: z18.number().int().min(0)
+var NextAppIdsSchema = z24.object({
+  app_ids: z24.array(
+    z24.object({
+      app_id: z24.string(),
+      nonce: z24.number().int().min(0)
     })
   )
 }).strict();
@@ -1496,6 +2059,36 @@ var { action: nextAppIds, safeAction: safeNextAppIds } = defineAction(NextAppIds
   return await client.get(`/kms/phala/next_app_id?${params.toString()}`);
 });
 
+// src/types/cvm_info.ts
+import { z as z25 } from "zod";
+var VMSchema = z25.object({
+  id: z25.number(),
+  name: z25.string(),
+  status: z25.string(),
+  teepod_id: z25.number(),
+  teepod: z25.object({
+    id: z25.number(),
+    name: z25.string(),
+    region_identifier: z25.string().nullable().optional()
+  }).optional().nullable(),
+  user_id: z25.number().optional().nullable(),
+  app_id: z25.string(),
+  vm_uuid: z25.string().nullable(),
+  instance_id: z25.string().nullable(),
+  app_url: z25.string().optional().nullable(),
+  base_image: z25.string().nullable(),
+  vcpu: z25.number(),
+  memory: z25.number(),
+  disk_size: z25.number(),
+  manifest_version: z25.number().optional().nullable(),
+  version: z25.string().optional().nullable(),
+  runner: z25.string().optional().nullable(),
+  docker_compose_file: z25.string().optional().nullable(),
+  features: z25.array(z25.string()).optional().nullable(),
+  created_at: z25.string(),
+  encrypted_env_pubkey: z25.string().nullable()
+});
+
 // src/actions/cvms/start_cvm.ts
 var StartCvmRequestSchema = CvmIdSchema;
 var { action: startCvm, safeAction: safeStartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1521,10 +2114,10 @@ var { action: shutdownCvm, safeAction: safeShutdownCvm } = defineAction(VMSchema
 });
 
 // src/actions/cvms/restart_cvm.ts
-import { z as z19 } from "zod";
+import { z as z26 } from "zod";
 var RestartCvmRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    force: z19.boolean().optional()
+    force: z26.boolean().optional()
   })
 );
 var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1535,10 +2128,10 @@ var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema,
 });
 
 // src/actions/cvms/delete_cvm.ts
-import { z as z20 } from "zod";
+import { z as z27 } from "zod";
 var DeleteCvmRequestSchema = CvmIdSchema;
 var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
-  z20.void(),
+  z27.void(),
   async (client, request) => {
     const { cvmId } = DeleteCvmRequestSchema.parse(request);
     await client.delete(`/cvms/${cvmId}`);
@@ -1547,41 +2140,41 @@ var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
 );
 
 // src/actions/cvms/get_cvm_stats.ts
-import { z as z21 } from "zod";
-var DiskInfoSchema = z21.object({
-  name: z21.string(),
-  mount_point: z21.string(),
-  total_size: z21.number(),
-  free_size: z21.number()
-});
-var SystemInfoSchema = z21.object({
-  os_name: z21.string(),
-  os_version: z21.string(),
-  kernel_version: z21.string(),
-  cpu_model: z21.string(),
-  num_cpus: z21.number(),
-  total_memory: z21.number(),
-  available_memory: z21.number(),
-  used_memory: z21.number(),
-  free_memory: z21.number(),
-  total_swap: z21.number(),
-  used_swap: z21.number(),
-  free_swap: z21.number(),
-  uptime: z21.number(),
-  loadavg_one: z21.number(),
-  loadavg_five: z21.number(),
-  loadavg_fifteen: z21.number(),
-  disks: z21.array(DiskInfoSchema)
-});
-var CvmSystemInfoSchema = z21.object({
-  is_online: z21.boolean(),
-  is_public: z21.boolean().default(false),
-  error: z21.string().nullable(),
+import { z as z28 } from "zod";
+var DiskInfoSchema = z28.object({
+  name: z28.string(),
+  mount_point: z28.string(),
+  total_size: z28.number(),
+  free_size: z28.number()
+});
+var SystemInfoSchema = z28.object({
+  os_name: z28.string(),
+  os_version: z28.string(),
+  kernel_version: z28.string(),
+  cpu_model: z28.string(),
+  num_cpus: z28.number(),
+  total_memory: z28.number(),
+  available_memory: z28.number(),
+  used_memory: z28.number(),
+  free_memory: z28.number(),
+  total_swap: z28.number(),
+  used_swap: z28.number(),
+  free_swap: z28.number(),
+  uptime: z28.number(),
+  loadavg_one: z28.number(),
+  loadavg_five: z28.number(),
+  loadavg_fifteen: z28.number(),
+  disks: z28.array(DiskInfoSchema)
+});
+var CvmSystemInfoSchema = z28.object({
+  is_online: z28.boolean(),
+  is_public: z28.boolean().default(false),
+  error: z28.string().nullable(),
   sysinfo: SystemInfoSchema.nullable(),
-  status: z21.string().nullable(),
-  in_progress: z21.boolean().default(false),
-  boot_progress: z21.string().nullable(),
-  boot_error: z21.string().nullable()
+  status: z28.string().nullable(),
+  in_progress: z28.boolean().default(false),
+  boot_progress: z28.string().nullable(),
+  boot_error: z28.string().nullable()
 });
 var GetCvmStatsRequestSchema = CvmIdSchema;
 var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSystemInfoSchema, async (client, request) => {
@@ -1590,18 +2183,18 @@ var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSyste
 });
 
 // src/actions/cvms/get_cvm_network.ts
-import { z as z22 } from "zod";
-var CvmNetworkUrlsSchema2 = z22.object({
-  app: z22.string(),
-  instance: z22.string()
-});
-var CvmNetworkSchema = z22.object({
-  is_online: z22.boolean(),
-  is_public: z22.boolean().default(true),
-  error: z22.string().nullable(),
-  internal_ip: z22.string().nullable(),
-  latest_handshake: z22.string().nullable(),
-  public_urls: z22.array(CvmNetworkUrlsSchema2).nullable()
+import { z as z29 } from "zod";
+var CvmNetworkUrlsSchema = z29.object({
+  app: z29.string(),
+  instance: z29.string()
+});
+var CvmNetworkSchema = z29.object({
+  is_online: z29.boolean(),
+  is_public: z29.boolean().default(true),
+  error: z29.string().nullable(),
+  internal_ip: z29.string().nullable(),
+  latest_handshake: z29.string().nullable(),
+  public_urls: z29.array(CvmNetworkUrlsSchema).nullable()
 });
 var GetCvmNetworkRequestSchema = CvmIdSchema;
 var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmNetworkSchema, async (client, request) => {
@@ -1610,36 +2203,36 @@ var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmN
 });
 
 // src/actions/cvms/get_cvm_docker_compose.ts
-import { z as z23 } from "zod";
+import { z as z30 } from "zod";
 var GetCvmDockerComposeRequestSchema = CvmIdSchema;
-var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z23.string(), async (client, request) => {
+var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z30.string(), async (client, request) => {
   const { cvmId } = GetCvmDockerComposeRequestSchema.parse(request);
   return await client.get(`/cvms/${cvmId}/docker-compose.yml`);
 });
 
 // src/actions/cvms/get_cvm_containers_stats.ts
-import { z as z24 } from "zod";
-var ContainerInfoSchema = z24.object({
-  id: z24.string(),
-  names: z24.array(z24.string()),
-  image: z24.string(),
-  image_id: z24.string(),
-  command: z24.string().nullable().optional(),
-  created: z24.number(),
-  state: z24.string(),
-  status: z24.string(),
-  log_endpoint: z24.string().nullable()
-});
-var CvmContainersStatsSchema = z24.object({
-  is_online: z24.boolean(),
-  is_public: z24.boolean().default(true),
-  error: z24.string().nullable(),
-  docker_compose_file: z24.string().nullable(),
-  manifest_version: z24.number().nullable(),
-  version: z24.string().nullable(),
-  runner: z24.string().nullable(),
-  features: z24.array(z24.string()).nullable(),
-  containers: z24.array(ContainerInfoSchema).nullable()
+import { z as z31 } from "zod";
+var ContainerInfoSchema = z31.object({
+  id: z31.string(),
+  names: z31.array(z31.string()),
+  image: z31.string(),
+  image_id: z31.string(),
+  command: z31.string().nullable().optional(),
+  created: z31.number(),
+  state: z31.string(),
+  status: z31.string(),
+  log_endpoint: z31.string().nullable()
+});
+var CvmContainersStatsSchema = z31.object({
+  is_online: z31.boolean(),
+  is_public: z31.boolean().default(true),
+  error: z31.string().nullable(),
+  docker_compose_file: z31.string().nullable(),
+  manifest_version: z31.number().nullable(),
+  version: z31.string().nullable(),
+  runner: z31.string().nullable(),
+  features: z31.array(z31.string()).nullable(),
+  containers: z31.array(ContainerInfoSchema).nullable()
 });
 var GetCvmContainersStatsRequestSchema = CvmIdSchema;
 var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = defineAction(CvmContainersStatsSchema, async (client, request) => {
@@ -1648,62 +2241,62 @@ var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = d
 });
 
 // src/actions/cvms/get_cvm_attestation.ts
-import { z as z25 } from "zod";
-var CertificateSubjectSchema = z25.object({
-  common_name: z25.string().nullable(),
-  organization: z25.string().nullable(),
-  country: z25.string().nullable(),
-  state: z25.string().nullable(),
-  locality: z25.string().nullable()
-});
-var CertificateIssuerSchema = z25.object({
-  common_name: z25.string().nullable(),
-  organization: z25.string().nullable(),
-  country: z25.string().nullable()
-});
-var CertificateSchema = z25.object({
+import { z as z32 } from "zod";
+var CertificateSubjectSchema = z32.object({
+  common_name: z32.string().nullable(),
+  organization: z32.string().nullable(),
+  country: z32.string().nullable(),
+  state: z32.string().nullable(),
+  locality: z32.string().nullable()
+});
+var CertificateIssuerSchema = z32.object({
+  common_name: z32.string().nullable(),
+  organization: z32.string().nullable(),
+  country: z32.string().nullable()
+});
+var CertificateSchema = z32.object({
   subject: CertificateSubjectSchema,
   issuer: CertificateIssuerSchema,
-  serial_number: z25.string(),
-  not_before: z25.string(),
+  serial_number: z32.string(),
+  not_before: z32.string(),
   // datetime serialized as ISO string
-  not_after: z25.string(),
+  not_after: z32.string(),
   // datetime serialized as ISO string
-  version: z25.string(),
-  fingerprint: z25.string(),
-  signature_algorithm: z25.string(),
-  sans: z25.array(z25.string()).nullable(),
-  is_ca: z25.boolean(),
-  position_in_chain: z25.number().nullable(),
-  quote: z25.string().nullable(),
-  app_id: z25.string().nullable().optional(),
-  cert_usage: z25.string().nullable().optional()
-});
-var EventLogSchema = z25.object({
-  imr: z25.number(),
-  event_type: z25.number(),
-  digest: z25.string(),
-  event: z25.string(),
-  event_payload: z25.string()
-});
-var TcbInfoSchema = z25.object({
-  mrtd: z25.string(),
-  rootfs_hash: z25.string().nullable().optional(),
-  rtmr0: z25.string(),
-  rtmr1: z25.string(),
-  rtmr2: z25.string(),
-  rtmr3: z25.string(),
-  event_log: z25.array(EventLogSchema),
-  app_compose: z25.string()
-});
-var CvmAttestationSchema = z25.object({
-  name: z25.string().nullable(),
-  is_online: z25.boolean(),
-  is_public: z25.boolean().default(true),
-  error: z25.string().nullable(),
-  app_certificates: z25.array(CertificateSchema).nullable(),
+  version: z32.string(),
+  fingerprint: z32.string(),
+  signature_algorithm: z32.string(),
+  sans: z32.array(z32.string()).nullable(),
+  is_ca: z32.boolean(),
+  position_in_chain: z32.number().nullable(),
+  quote: z32.string().nullable(),
+  app_id: z32.string().nullable().optional(),
+  cert_usage: z32.string().nullable().optional()
+});
+var EventLogSchema = z32.object({
+  imr: z32.number(),
+  event_type: z32.number(),
+  digest: z32.string(),
+  event: z32.string(),
+  event_payload: z32.string()
+});
+var TcbInfoSchema = z32.object({
+  mrtd: z32.string(),
+  rootfs_hash: z32.string().nullable().optional(),
+  rtmr0: z32.string(),
+  rtmr1: z32.string(),
+  rtmr2: z32.string(),
+  rtmr3: z32.string(),
+  event_log: z32.array(EventLogSchema),
+  app_compose: z32.string()
+});
+var CvmAttestationSchema = z32.object({
+  name: z32.string().nullable(),
+  is_online: z32.boolean(),
+  is_public: z32.boolean().default(true),
+  error: z32.string().nullable(),
+  app_certificates: z32.array(CertificateSchema).nullable(),
   tcb_info: TcbInfoSchema.nullable(),
-  compose_file: z25.string().nullable()
+  compose_file: z32.string().nullable()
 });
 var GetCvmAttestationRequestSchema = CvmIdSchema;
 var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAction(CvmAttestationSchema, async (client, request) => {
@@ -1712,17 +2305,17 @@ var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAct
 });
 
 // src/actions/cvms/update_cvm_resources.ts
-import { z as z26 } from "zod";
+import { z as z33 } from "zod";
 var UpdateCvmResourcesRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    vcpu: z26.number().optional(),
-    memory: z26.number().optional(),
-    disk_size: z26.number().optional(),
-    instance_type: z26.string().optional(),
-    allow_restart: z26.boolean().optional()
+    vcpu: z33.number().optional(),
+    memory: z33.number().optional(),
+    disk_size: z33.number().optional(),
+    instance_type: z33.string().optional(),
+    allow_restart: z33.boolean().optional()
   })
 );
-var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z26.void(), async (client, request) => {
+var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z33.void(), async (client, request) => {
   const parsed = UpdateCvmResourcesRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { ...body } = parsed;
@@ -1731,14 +2324,14 @@ var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineA
 });
 
 // src/actions/cvms/update_cvm_visibility.ts
-import { z as z27 } from "zod";
+import { z as z34 } from "zod";
 var UpdateCvmVisibilityRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    public_sysinfo: z27.boolean(),
-    public_logs: z27.boolean()
+    public_sysinfo: z34.boolean(),
+    public_logs: z34.boolean()
   })
 );
-var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
+var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmDetailV20251028Schema, async (client, request) => {
   const parsed = UpdateCvmVisibilityRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { public_sysinfo, public_logs } = parsed;
@@ -1746,21 +2339,21 @@ var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defin
 });
 
 // src/actions/cvms/get_available_os_images.ts
-import { z as z28 } from "zod";
-var OSImageVariantSchema = z28.object({
-  name: z28.string(),
-  os_image_hash: z28.string().nullable(),
-  is_current: z28.boolean()
+import { z as z35 } from "zod";
+var OSImageVariantSchema = z35.object({
+  name: z35.string(),
+  os_image_hash: z35.string().nullable(),
+  is_current: z35.boolean()
 });
-var AvailableOSImageSchema2 = z28.object({
-  version: z28.union([
-    z28.tuple([z28.number(), z28.number(), z28.number(), z28.number()]),
-    z28.tuple([z28.number(), z28.number(), z28.number()])
+var AvailableOSImageSchema2 = z35.object({
+  version: z35.union([
+    z35.tuple([z35.number(), z35.number(), z35.number(), z35.number()]),
+    z35.tuple([z35.number(), z35.number(), z35.number()])
   ]),
   prod: OSImageVariantSchema.nullable(),
   dev: OSImageVariantSchema.nullable()
 });
-var GetAvailableOSImagesResponseSchema = z28.array(AvailableOSImageSchema2);
+var GetAvailableOSImagesResponseSchema = z35.array(AvailableOSImageSchema2);
 var GetAvailableOSImagesRequestSchema = CvmIdSchema;
 var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = defineAction(GetAvailableOSImagesResponseSchema, async (client, request) => {
   const { cvmId } = GetAvailableOSImagesRequestSchema.parse(request);
@@ -1768,13 +2361,13 @@ var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = def
 });
 
 // src/actions/cvms/update_os_image.ts
-import { z as z29 } from "zod";
+import { z as z36 } from "zod";
 var UpdateOsImageRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    os_image_name: z29.string().min(1, "OS image name is required")
+    os_image_name: z36.string().min(1, "OS image name is required")
   })
 );
-var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(z29.void(), async (client, request) => {
+var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(z36.void(), async (client, request) => {
   const parsed = UpdateOsImageRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { os_image_name } = parsed;
@@ -1783,17 +2376,17 @@ var { action: updateOsImage, safeAction: safeUpdateOsImage } = defineAction(z29.
 });
 
 // src/actions/cvms/get_cvm_state.ts
-import { z as z30 } from "zod";
-var CvmStateSchema = z30.object({
-  id: z30.string().optional(),
-  instance_id: z30.string().optional(),
-  name: z30.string(),
-  status: z30.string(),
-  uptime: z30.string().optional(),
-  exited_at: z30.string().optional(),
-  boot_progress: z30.string().optional(),
-  boot_error: z30.string().optional(),
-  shutdown_progress: z30.string().optional()
+import { z as z37 } from "zod";
+var CvmStateSchema = z37.object({
+  id: z37.string().optional(),
+  instance_id: z37.string().optional(),
+  name: z37.string(),
+  status: z37.string(),
+  uptime: z37.string().optional(),
+  exited_at: z37.string().optional(),
+  boot_progress: z37.string().optional(),
+  boot_error: z37.string().optional(),
+  shutdown_progress: z37.string().optional()
 });
 var GetCvmStateRequestSchema = CvmIdSchema;
 var { action: getCvmState, safeAction: safeGetCvmState } = defineAction(CvmStateSchema, async (client, request) => {
@@ -1831,6 +2424,14 @@ function createClient2(config = {}) {
     safeProvisionCvmComposeFileUpdate,
     commitCvmComposeFileUpdate,
     safeCommitCvmComposeFileUpdate,
+    updateCvmEnvs,
+    safeUpdateCvmEnvs,
+    updateDockerCompose,
+    safeUpdateDockerCompose,
+    updatePreLaunchScript,
+    safeUpdatePreLaunchScript,
+    getCvmPreLaunchScript,
+    safeGetCvmPreLaunchScript,
     startCvm,
     safeStartCvm,
     stopCvm,
@@ -1873,8 +2474,147 @@ function createClient2(config = {}) {
   return client.extend(allActions);
 }
 
+// src/types/app_info_v20251028.ts
+import { z as z38 } from "zod";
+var CvmBasicInfoV20251028Schema = z38.object({
+  vm_uuid: z38.string().nullable(),
+  app_id: z38.string(),
+  name: z38.string().default(""),
+  status: z38.string(),
+  vcpu: z38.number().int(),
+  memory: z38.number().int(),
+  disk_size: z38.number().int(),
+  teepod_id: z38.number().int(),
+  teepod_name: z38.string(),
+  region_identifier: z38.string().nullable().optional(),
+  kms_type: z38.string().nullable().optional(),
+  instance_type: z38.string().nullable().optional(),
+  listed: z38.boolean().nullable().optional(),
+  base_image: z38.string().nullable().optional(),
+  kms_slug: z38.string().nullable().optional(),
+  kms_id: z38.string().nullable().optional(),
+  instance_id: z38.string().nullable().optional(),
+  machine_info: MachineInfoV20251028Schema.nullable().optional(),
+  updated_at: z38.string().nullable().optional()
+});
+var DstackAppFullResponseV20251028Schema = z38.object({
+  id: z38.string(),
+  name: z38.string(),
+  app_id: z38.string(),
+  app_provision_type: z38.string().nullable().optional(),
+  app_icon_url: z38.string().nullable().optional(),
+  created_at: z38.string(),
+  kms_type: z38.string(),
+  current_cvm: CvmBasicInfoV20251028Schema.nullable().optional(),
+  cvms: z38.array(CvmBasicInfoV20251028Schema).default([]),
+  cvm_count: z38.number().int().default(0)
+});
+var DstackAppMinimalResponseV20251028Schema = z38.object({
+  id: z38.null().optional(),
+  app_id: z38.string(),
+  name: z38.null().optional(),
+  app_provision_type: z38.null().optional(),
+  app_icon_url: z38.null().optional(),
+  created_at: z38.null().optional(),
+  kms_type: z38.null().optional(),
+  current_cvm: z38.null().optional(),
+  cvms: z38.null().optional(),
+  cvm_count: z38.null().optional()
+});
+var DstackAppWithCvmResponseV20251028Schema = z38.union([
+  DstackAppFullResponseV20251028Schema,
+  DstackAppMinimalResponseV20251028Schema
+]);
+var DstackAppListResponseV20251028Schema = z38.object({
+  dstack_apps: z38.array(DstackAppWithCvmResponseV20251028Schema),
+  page: z38.number().int(),
+  page_size: z38.number().int(),
+  total: z38.number().int(),
+  total_pages: z38.number().int()
+});
+
+// src/types/app_info_v20260121.ts
+import { z as z39 } from "zod";
+var DstackAppFullResponseV20260121Schema = z39.object({
+  id: z39.string(),
+  name: z39.string(),
+  app_id: z39.string(),
+  app_provision_type: z39.string().nullable().optional(),
+  app_icon_url: z39.string().nullable().optional(),
+  created_at: z39.string(),
+  kms_type: z39.string(),
+  current_cvm: CvmInfoV20260121Schema.nullable().optional(),
+  cvms: z39.array(CvmInfoV20260121Schema).default([]),
+  cvm_count: z39.number().int().default(0)
+});
+var DstackAppMinimalResponseV20260121Schema = z39.object({
+  id: z39.null().optional(),
+  app_id: z39.string(),
+  name: z39.null().optional(),
+  app_provision_type: z39.null().optional(),
+  app_icon_url: z39.null().optional(),
+  created_at: z39.null().optional(),
+  kms_type: z39.null().optional(),
+  current_cvm: z39.null().optional(),
+  cvms: z39.null().optional(),
+  cvm_count: z39.null().optional()
+});
+var DstackAppWithCvmResponseV20260121Schema = z39.union([
+  DstackAppFullResponseV20260121Schema,
+  DstackAppMinimalResponseV20260121Schema
+]);
+var DstackAppListResponseV20260121Schema = z39.object({
+  dstack_apps: z39.array(DstackAppWithCvmResponseV20260121Schema),
+  page: z39.number().int(),
+  page_size: z39.number().int(),
+  total: z39.number().int(),
+  total_pages: z39.number().int()
+});
+
+// src/types/app_revision.ts
+import { z as z40 } from "zod";
+var CvmRefSchema = z40.object({
+  object_type: z40.literal("cvm"),
+  id: z40.string().nullable().optional(),
+  name: z40.string().nullable().optional(),
+  app_id: z40.string().nullable().optional(),
+  vm_uuid: z40.string().nullable().optional()
+});
+var AppRevisionResponseSchema = z40.object({
+  app_id: z40.string(),
+  vm_uuid: z40.string(),
+  compose_hash: z40.string(),
+  created_at: z40.string(),
+  trace_id: z40.string().nullable().optional(),
+  operation_type: z40.string(),
+  triggered_by: UserRefSchema.nullable().optional(),
+  cvm: CvmRefSchema.nullable().optional(),
+  workspace: WorkspaceRefSchema.nullable().optional()
+});
+var AppRevisionDetailResponseSchema = z40.object({
+  app_id: z40.string(),
+  vm_uuid: z40.string(),
+  compose_hash: z40.string(),
+  compose_file: z40.union([z40.record(z40.any()), z40.string()]).nullable().optional(),
+  encrypted_env: z40.string(),
+  user_config: z40.string(),
+  created_at: z40.string(),
+  trace_id: z40.string().nullable().optional(),
+  operation_type: z40.string(),
+  triggered_by: UserRefSchema.nullable().optional(),
+  cvm: CvmRefSchema.nullable().optional(),
+  workspace: WorkspaceRefSchema.nullable().optional()
+});
+var AppRevisionsResponseSchema = z40.object({
+  revisions: z40.array(AppRevisionResponseSchema),
+  total: z40.number().int(),
+  page: z40.number().int(),
+  page_size: z40.number().int(),
+  total_pages: z40.number().int()
+});
+
 // src/actions/blockchains/deploy_app_auth.ts
-import { z as z31 } from "zod";
+import { z as z41 } from "zod";
 import {
   createPublicClient as createPublicClient2,
   createWalletClient as createWalletClient2,
@@ -2535,25 +3275,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z31.object({
+var DeployAppAuthRequestBaseSchema = z41.object({
   // Chain configuration (conditionally required)
-  chain: z31.unknown().optional(),
-  rpcUrl: z31.string().optional(),
+  chain: z41.unknown().optional(),
+  rpcUrl: z41.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z31.string(),
+  kmsContractAddress: z41.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z31.string().optional(),
-  walletClient: z31.unknown().optional(),
+  privateKey: z41.string().optional(),
+  walletClient: z41.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z31.unknown().optional(),
+  publicClient: z41.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z31.boolean().optional().default(false),
-  deviceId: z31.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z31.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z31.boolean().optional().default(false),
+  allowAnyDevice: z41.boolean().optional().default(false),
+  deviceId: z41.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z41.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z41.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z31.boolean().optional().default(false),
-  minBalance: z31.string().optional()
+  skipPrerequisiteChecks: z41.boolean().optional().default(false),
+  minBalance: z41.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -2581,13 +3321,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z31.object({
-  appId: z31.string(),
-  appAuthAddress: z31.string(),
-  deployer: z31.string(),
-  transactionHash: z31.string(),
-  blockNumber: z31.bigint().optional(),
-  gasUsed: z31.bigint().optional()
+var DeployAppAuthSchema = z41.object({
+  appId: z41.string(),
+  appAuthAddress: z41.string(),
+  deployer: z41.string(),
+  transactionHash: z41.string(),
+  blockNumber: z41.bigint().optional(),
+  gasUsed: z41.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -2833,7 +3573,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-import { z as z32 } from "zod";
+import { z as z42 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -2857,29 +3597,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z32.object({
+var AddComposeHashRequestSchema = z42.object({
   // Chain configuration (conditionally required)
-  chain: z32.unknown().optional(),
-  rpcUrl: z32.string().optional(),
-  appId: z32.string(),
-  composeHash: z32.string(),
+  chain: z42.unknown().optional(),
+  rpcUrl: z42.string().optional(),
+  appId: z42.string(),
+  composeHash: z42.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z32.string().optional(),
-  walletClient: z32.unknown().optional(),
+  privateKey: z42.string().optional(),
+  walletClient: z42.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z32.unknown().optional(),
+  publicClient: z42.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z32.boolean().optional().default(false),
-  minBalance: z32.string().optional(),
+  skipPrerequisiteChecks: z42.boolean().optional().default(false),
+  minBalance: z42.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z32.number().optional().default(12e4),
-  retryOptions: z32.unknown().optional(),
-  signal: z32.unknown().optional(),
+  timeout: z42.number().optional().default(12e4),
+  retryOptions: z42.unknown().optional(),
+  signal: z42.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z32.function().optional(),
-  onTransactionSubmitted: z32.function().optional(),
-  onTransactionConfirmed: z32.function().optional()
+  onTransactionStateChange: z42.function().optional(),
+  onTransactionSubmitted: z42.function().optional(),
+  onTransactionConfirmed: z42.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -2903,12 +3643,12 @@ var AddComposeHashRequestSchema = z32.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z32.object({
-  composeHash: z32.string(),
-  appId: z32.string(),
-  transactionHash: z32.string(),
-  blockNumber: z32.bigint().optional(),
-  gasUsed: z32.bigint().optional()
+var AddComposeHashSchema = z42.object({
+  composeHash: z42.string(),
+  appId: z42.string(),
+  transactionHash: z42.string(),
+  blockNumber: z42.bigint().optional(),
+  gasUsed: z42.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -3099,14 +3839,70 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
+// src/actions/workspaces/get_workspace_nodes.ts
+import { z as z43 } from "zod";
+var NodeInfoSchema = z43.object({
+  id: z43.number().nullable(),
+  name: z43.string().nullable(),
+  region: z43.string().nullable(),
+  device_id: z43.string().nullable(),
+  ppid: z43.string().nullable(),
+  status: z43.string().nullable(),
+  version: z43.string().nullable()
+}).passthrough();
+var GetWorkspaceNodesSchema = z43.object({
+  items: z43.array(NodeInfoSchema),
+  total: z43.number(),
+  page: z43.number(),
+  page_size: z43.number(),
+  pages: z43.number()
+}).passthrough();
+var { action: getWorkspaceNodes, safeAction: safeGetWorkspaceNodes } = defineAction(GetWorkspaceNodesSchema, async (client, request) => {
+  const { teamSlug, page, pageSize } = request;
+  const queryParams = new URLSearchParams();
+  if (page !== void 0) queryParams.append("page", page.toString());
+  if (pageSize !== void 0) queryParams.append("page_size", pageSize.toString());
+  const url = queryParams.toString() ? `/workspaces/${teamSlug}/nodes?${queryParams.toString()}` : `/workspaces/${teamSlug}/nodes`;
+  return await client.get(url);
+});
+
+// src/actions/workspaces/get_workspace_quotas.ts
+import { z as z44 } from "zod";
+var QuotaMetricSchema = z44.object({
+  limit: z44.number(),
+  remaining: z44.number()
+}).passthrough();
+var WorkspaceQuotasSchema = z44.object({
+  vm_slots: QuotaMetricSchema,
+  vcpu: QuotaMetricSchema,
+  memory_mb: QuotaMetricSchema,
+  disk_gb: QuotaMetricSchema
+}).passthrough();
+var WorkspaceReservedGpuQuotaSchema = z44.object({
+  gpus: QuotaMetricSchema,
+  in_use: z44.number(),
+  misconfigured: z44.number()
+}).passthrough();
+var GetWorkspaceQuotasSchema = z44.object({
+  team_slug: z44.string(),
+  tier: z44.string(),
+  quotas: WorkspaceQuotasSchema,
+  reserved_nodes: QuotaMetricSchema,
+  reserved_gpu: WorkspaceReservedGpuQuotaSchema,
+  as_of: z44.string()
+}).passthrough();
+var { action: getWorkspaceQuotas, safeAction: safeGetWorkspaceQuotas } = defineAction(GetWorkspaceQuotasSchema, async (client, request) => {
+  return await client.get(`/workspaces/${request.teamSlug}/quotas`);
+});
+
 // src/actions/cvms/watch_cvm_state.ts
-import { z as z33 } from "zod";
-var WatchCvmStateParamsSchema = z33.object({
-  target: z33.string().describe("Target status to wait for (e.g., 'running', 'stopped')"),
-  interval: z33.number().min(5).max(30).default(5).describe("Polling interval in seconds"),
-  timeout: z33.number().min(10).max(600).default(300).describe("Timeout per attempt in seconds"),
-  maxRetries: z33.number().min(0).default(Number.POSITIVE_INFINITY).describe("Maximum number of retry attempts (Infinity for unlimited)"),
-  retryDelay: z33.number().min(0).default(5e3).describe("Delay between retries in milliseconds")
+import { z as z45 } from "zod";
+var WatchCvmStateParamsSchema = z45.object({
+  target: z45.string().describe("Target status to wait for (e.g., 'running', 'stopped')"),
+  interval: z45.number().min(5).max(30).default(5).describe("Polling interval in seconds"),
+  timeout: z45.number().min(10).max(600).default(300).describe("Timeout per attempt in seconds"),
+  maxRetries: z45.number().min(0).default(Number.POSITIVE_INFINITY).describe("Maximum number of retry attempts (Infinity for unlimited)"),
+  retryDelay: z45.number().min(0).default(5e3).describe("Delay between retries in milliseconds")
 });
 var WatchCvmStateRequestSchema = WatchCvmStateParamsSchema;
 var WatchAbortedError = class extends Error {
@@ -3293,6 +4089,195 @@ function sleep(ms, signal) {
   });
 }
 
+// src/actions/cvms/get_cvm_status_batch.ts
+import { z as z46 } from "zod";
+var CvmStatusSchema = z46.object({
+  vm_uuid: z46.string(),
+  status: z46.string(),
+  uptime: z46.string().nullable().optional(),
+  in_progress: z46.boolean(),
+  boot_progress: z46.string().nullable().optional(),
+  boot_error: z46.string().nullable().optional(),
+  operation_type: z46.string().nullable().optional(),
+  operation_started_at: z46.string().nullable().optional(),
+  correlation_id: z46.string().nullable().optional()
+});
+var GetCvmStatusBatchResponseSchema = z46.record(z46.string(), CvmStatusSchema);
+var GetCvmStatusBatchRequestSchema = z46.object({
+  vmUuids: z46.array(z46.string())
+});
+var { action: getCvmStatusBatch, safeAction: safeGetCvmStatusBatch } = defineAction(GetCvmStatusBatchResponseSchema, async (client, request) => {
+  const { vmUuids } = GetCvmStatusBatchRequestSchema.parse(request);
+  return await client.post("/status/batch", { vm_uuids: vmUuids });
+});
+
+// src/actions/apps/get_app_list.ts
+import { z as z47 } from "zod";
+var GetAppListRequestSchema = z47.object({
+  page: z47.number().int().min(1).optional(),
+  page_size: z47.number().int().min(1).max(100).optional(),
+  search: z47.string().optional(),
+  status: z47.array(z47.string()).optional(),
+  listed: z47.boolean().optional(),
+  base_image: z47.string().optional(),
+  instance_type: z47.string().optional(),
+  kms_slug: z47.string().optional(),
+  kms_type: z47.string().optional(),
+  teepod_name: z47.string().optional(),
+  region: z47.string().optional()
+}).strict();
+function getSchemaForVersion4(version) {
+  return version === "2025-10-28" ? DstackAppListResponseV20251028Schema : DstackAppListResponseV20260121Schema;
+}
+async function getAppList(client, request) {
+  const validatedRequest = GetAppListRequestSchema.parse(request ?? {});
+  const response = await client.get("/apps", { params: validatedRequest });
+  const schema = getSchemaForVersion4(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetAppList(client, request) {
+  try {
+    const data = await getAppList(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_info.ts
+import { z as z48 } from "zod";
+var GetAppInfoRequestSchema = z48.object({
+  appId: z48.string().min(1)
+}).strict();
+function getSchemaForVersion5(version) {
+  return version === "2025-10-28" ? DstackAppWithCvmResponseV20251028Schema : DstackAppWithCvmResponseV20260121Schema;
+}
+async function getAppInfo(client, request) {
+  const { appId } = GetAppInfoRequestSchema.parse(request);
+  const response = await client.get(`/apps/${appId}`);
+  const schema = getSchemaForVersion5(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetAppInfo(client, request) {
+  try {
+    const data = await getAppInfo(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_cvms.ts
+import { z as z49 } from "zod";
+var GetAppCvmsRequestSchema = z49.object({
+  appId: z49.string().min(1)
+}).strict();
+function getSchemaForVersion6(version) {
+  return version === "2025-10-28" ? z49.array(CvmInfoV20251028Schema) : z49.array(CvmInfoV20260121Schema);
+}
+async function getAppCvms(client, request) {
+  const { appId } = GetAppCvmsRequestSchema.parse(request);
+  const response = await client.get(`/apps/${appId}/cvms`);
+  const schema = getSchemaForVersion6(client.config.version);
+  return schema.parse(response);
+}
+async function safeGetAppCvms(client, request) {
+  try {
+    const data = await getAppCvms(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_revisions.ts
+import { z as z50 } from "zod";
+var GetAppRevisionsRequestSchema = z50.object({
+  appId: z50.string().min(1),
+  page: z50.number().int().min(1).optional(),
+  page_size: z50.number().int().min(1).max(1e3).optional()
+}).strict();
+async function getAppRevisions(client, request) {
+  const { appId, ...params } = GetAppRevisionsRequestSchema.parse(request);
+  const response = await client.get(`/apps/${appId}/revisions`, { params });
+  return AppRevisionsResponseSchema.parse(response);
+}
+async function safeGetAppRevisions(client, request) {
+  try {
+    const data = await getAppRevisions(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
+// src/actions/apps/get_app_revision_detail.ts
+import { z as z51 } from "zod";
+var GetAppRevisionDetailRequestSchema = z51.object({
+  appId: z51.string().min(1),
+  composeHash: z51.string().min(1),
+  rawComposeFile: z51.boolean().optional()
+}).strict();
+async function getAppRevisionDetail(client, request) {
+  const { appId, composeHash, rawComposeFile } = GetAppRevisionDetailRequestSchema.parse(request);
+  const params = rawComposeFile !== void 0 ? { raw_compose_file: rawComposeFile } : void 0;
+  const response = await client.get(`/apps/${appId}/revisions/${composeHash}`, { params });
+  return AppRevisionDetailResponseSchema.parse(response);
+}
+async function safeGetAppRevisionDetail(client, request) {
+  try {
+    const data = await getAppRevisionDetail(client, request);
+    return { success: true, data };
+  } catch (error) {
+    if (error && typeof error === "object" && ("status" in error || "issues" in error)) {
+      return { success: false, error };
+    }
+    return {
+      success: false,
+      error: {
+        name: "Error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -3334,33 +4319,65 @@ export {
   AddComposeHashSchema,
   AllFamiliesResponseSchema,
   ApiErrorSchema,
+  AppRevisionDetailResponseSchema,
+  AppRevisionResponseSchema,
+  AppRevisionsResponseSchema,
   AuthError,
+  CurrentUserV20260121Schema as AuthResponseSchema,
   AvailableNodesSchema,
+  BillingPeriodSchema,
   BusinessError,
   CommitCvmComposeFileUpdateRequestSchema,
   CommitCvmComposeFileUpdateSchema,
   CommitCvmProvisionRequestSchema,
   CommitCvmProvisionSchema,
-  CurrentUserSchema,
+  CreditsInfoSchema,
+  CurrentUserV20251028Schema as CurrentUserSchema,
+  CurrentUserV20251028Schema,
+  CurrentUserV20260121Schema,
   CvmAttestationSchema,
+  CvmBasicInfoV20251028Schema,
   CvmContainersStatsSchema,
+  CvmDetailV20251028Schema,
+  CvmGatewayInfoV20260121Schema,
   CvmIdBaseSchema,
   CvmIdObjectSchema,
   CvmIdSchema,
-  CvmInfoSchema,
-  CvmLegacyDetailSchema,
+  CvmInfoDetailV20260121Schema,
+  CvmInfoV20251028Schema,
+  CvmInfoV20260121Schema,
+  CvmKmsInfoV20260121Schema,
   CvmNetworkSchema,
-  CvmNetworkUrlsSchema,
-  CvmNodeSchema,
+  CvmNetworkUrlsV20251028Schema,
+  CvmNodeInfoV20260121Schema,
+  CvmNodeV20251028Schema,
+  CvmOsInfoV20260121Schema,
+  CvmProgressInfoV20260121Schema,
+  CvmRefSchema,
+  CvmResourceInfoV20260121Schema,
   CvmStateSchema,
+  CvmStatusSchema,
   CvmSystemInfoSchema,
   DeleteCvmRequestSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
+  DstackAppFullResponseV20251028Schema,
+  DstackAppFullResponseV20260121Schema,
+  DstackAppListResponseV20251028Schema,
+  DstackAppListResponseV20260121Schema,
+  DstackAppMinimalResponseV20251028Schema,
+  DstackAppMinimalResponseV20260121Schema,
+  DstackAppWithCvmResponseV20251028Schema,
+  DstackAppWithCvmResponseV20260121Schema,
   FamilyGroupSchema,
   FamilyInstanceTypesResponseSchema,
+  GetAppCvmsRequestSchema,
   GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema,
+  GetAppInfoRequestSchema,
+  GetAppListRequestSchema,
+  GetAppRevisionDetailRequestSchema,
+  GetAppRevisionsRequestSchema,
   GetAvailableOSImagesRequestSchema,
   GetAvailableOSImagesResponseSchema,
   GetCvmAttestationRequestSchema,
@@ -3369,29 +4386,39 @@ export {
   GetCvmDockerComposeRequestSchema,
   GetCvmInfoRequestSchema,
   GetCvmListRequestSchema,
-  GetCvmListSchema,
   GetCvmNetworkRequestSchema,
+  GetCvmPreLaunchScriptRequestSchema,
   GetCvmStateRequestSchema,
   GetCvmStatsRequestSchema,
+  GetCvmStatusBatchRequestSchema,
+  GetCvmStatusBatchResponseSchema,
   GetKmsInfoRequestSchema,
   GetKmsListRequestSchema,
   GetKmsListSchema,
+  GetWorkspaceNodesSchema,
+  GetWorkspaceQuotasSchema,
   InstanceTypeSchema,
   KmsInfoSchema,
+  KmsTypeSchema,
   ListFamilyInstanceTypesRequestSchema,
   ListWorkspacesSchema,
-  ManagedUserSchema,
+  MachineInfoV20251028Schema,
+  ManagedUserV20251028Schema,
   MaxRetriesExceededError,
   NetworkError,
   NextAppIdsRequestSchema,
   NextAppIdsSchema,
+  NodeInfoSchema,
   OSImageVariantSchema,
+  PaginatedCvmInfosV20251028Schema,
+  PaginatedCvmInfosV20260121Schema,
   PaginationMetadataSchema,
   PhalaCloudError,
   ProvisionCvmComposeFileUpdateRequestSchema,
   ProvisionCvmComposeFileUpdateResultSchema,
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
+  QuotaMetricSchema,
   RequestError,
   ResourceError,
   RestartCvmRequestSchema,
@@ -3403,15 +4430,27 @@ export {
   StopCvmRequestSchema,
   TransactionError,
   UnknownError,
+  UpdateCvmEnvsRequestSchema,
+  UpdateCvmEnvsResultSchema,
   UpdateCvmResourcesRequestSchema,
   UpdateCvmVisibilityRequestSchema,
+  UpdateDockerComposeRequestSchema,
+  UpdateDockerComposeResultSchema,
   UpdateOsImageRequestSchema,
+  UpdatePreLaunchScriptRequestSchema,
+  UpdatePreLaunchScriptResultSchema,
+  UserInfoSchema,
+  UserRefSchema,
   VMSchema,
   ValidationError,
-  VmInfoSchema,
+  VmInfoV20251028Schema,
   WalletError,
   WatchAbortedError,
   WatchCvmStateRequestSchema,
+  WorkspaceInfoSchema,
+  WorkspaceQuotasSchema,
+  WorkspaceRefSchema,
+  WorkspaceReservedGpuQuotaSchema,
   WorkspaceResponseSchema,
   addComposeHash,
   addNetwork,
@@ -3421,6 +4460,7 @@ export {
   checkNetworkStatus,
   commitCvmComposeFileUpdate,
   commitCvmProvision,
+  convertToHostname,
   createClient as createBaseClient,
   createClient2 as createClient,
   createClientsFromBrowser,
@@ -3441,7 +4481,14 @@ export {
   formatErrorMessage,
   formatStructuredError,
   formatValidationErrors,
+  generateDefaultCvmName,
+  generateFallbackHostname,
+  getAppCvms,
   getAppEnvEncryptPubKey,
+  getAppInfo,
+  getAppList,
+  getAppRevisionDetail,
+  getAppRevisions,
   getAvailableNodes,
   getAvailableOsImages,
   getComposeHash2 as getComposeHash,
@@ -3453,13 +4500,18 @@ export {
   getCvmInfo,
   getCvmList,
   getCvmNetwork,
+  getCvmPreLaunchScript,
   getCvmState,
   getCvmStats,
+  getCvmStatusBatch,
   getErrorMessage,
   getKmsInfo,
   getKmsList,
   getValidationFields,
   getWorkspace,
+  getWorkspaceNodes,
+  getWorkspaceQuotas,
+  isValidHostname,
   listAllInstanceTypeFamilies,
   listFamilyInstanceTypes,
   listWorkspaces,
@@ -3477,7 +4529,12 @@ export {
   safeCommitCvmProvision,
   safeDeleteCvm,
   safeDeployAppAuth,
+  safeGetAppCvms,
   safeGetAppEnvEncryptPubKey,
+  safeGetAppInfo,
+  safeGetAppList,
+  safeGetAppRevisionDetail,
+  safeGetAppRevisions,
   safeGetAvailableNodes,
   safeGetAvailableOsImages,
   safeGetCurrentUser,
@@ -3488,11 +4545,15 @@ export {
   safeGetCvmInfo,
   safeGetCvmList,
   safeGetCvmNetwork,
+  safeGetCvmPreLaunchScript,
   safeGetCvmState,
   safeGetCvmStats,
+  safeGetCvmStatusBatch,
   safeGetKmsInfo,
   safeGetKmsList,
   safeGetWorkspace,
+  safeGetWorkspaceNodes,
+  safeGetWorkspaceQuotas,
   safeListAllInstanceTypeFamilies,
   safeListFamilyInstanceTypes,
   safeListWorkspaces,
@@ -3503,18 +4564,24 @@ export {
   safeShutdownCvm,
   safeStartCvm,
   safeStopCvm,
+  safeUpdateCvmEnvs,
   safeUpdateCvmResources,
   safeUpdateCvmVisibility,
+  safeUpdateDockerCompose,
   safeUpdateOsImage,
+  safeUpdatePreLaunchScript,
   safeValidateActionParameters,
   shutdownCvm,
   sortObject,
   startCvm,
   stopCvm,
   switchToNetwork,
+  updateCvmEnvs,
   updateCvmResources,
   updateCvmVisibility,
+  updateDockerCompose,
   updateOsImage,
+  updatePreLaunchScript,
   validateActionParameters,
   validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey,