@phala/cloud 0.2.1-beta.2 → 0.2.1-beta.4

package/dist/index.mjs

@@ -1091,18 +1091,28 @@ var refineCvmId = (schema) => schema.refine(
 );
 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 {
     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 };
 });
 
@@ -1189,7 +1199,12 @@ var ProvisionCvmRequestSchema = z10.object({
   // KMS type selection (defaults to PHALA)
   kms_contract: z10.string().optional(),
   // KMS contract address for on-chain KMS
-  env_keys: z10.array(z10.string()).optional()
+  env_keys: z10.array(z10.string()).optional(),
+  // Manual nonce specification (Advanced - PHALA KMS only)
+  nonce: z10.number().optional(),
+  // User-specified nonce for deterministic app_id generation
+  app_id: z10.string().optional()
+  // Expected app_id (must match calculated app_id from nonce)
 }).passthrough();
 function handleGatewayCompatibility(appCompose) {
   if (!appCompose.compose_file) {
@@ -1424,10 +1439,89 @@ var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUp
   }
 );
 
-// src/actions/kms/get_kms_info.ts
+// src/actions/cvms/update_cvm_envs.ts
 import { z as z15 } from "zod";
-var GetKmsInfoRequestSchema = z15.object({
-  kms_id: z15.string().min(1, "KMS ID is required")
+var UpdateCvmEnvsRequestSchema = 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: 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(),
+  encrypted_env: z15.string().describe("Encrypted environment variables (hex string)"),
+  env_keys: z15.array(z15.string()).optional().describe("List of allowed environment variable keys"),
+  compose_hash: z15.string().optional().describe("Compose hash for verification (Phase 2, required when env_keys changes)"),
+  transaction_hash: z15.string().optional().describe(
+    "On-chain transaction hash for verification (Phase 2, required when env_keys changes)"
+  )
+}).refine(
+  (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
+  "One of id, uuid, app_id, or instance_id must be provided"
+).transform((data) => {
+  return {
+    cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+    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 = z15.object({
+  status: z15.literal("in_progress"),
+  message: z15.string(),
+  correlation_id: z15.string(),
+  allowed_envs_changed: z15.boolean()
+});
+var UpdateCvmEnvsPreconditionRequiredSchema = z15.object({
+  status: z15.literal("precondition_required"),
+  message: z15.string(),
+  compose_hash: z15.string(),
+  app_id: z15.string(),
+  device_id: z15.string(),
+  kms_info: KmsInfoSchema
+});
+var UpdateCvmEnvsResultSchema = z15.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 === 428) {
+      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/kms/get_kms_info.ts
+import { z as z16 } from "zod";
+var GetKmsInfoRequestSchema = z16.object({
+  kms_id: z16.string().min(1, "KMS ID is required")
 });
 var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
   const validatedRequest = GetKmsInfoRequestSchema.parse(request);
@@ -1435,18 +1529,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 z17 } from "zod";
+var GetKmsListRequestSchema = z17.object({
+  page: z17.number().int().min(1).optional(),
+  page_size: z17.number().int().min(1).optional(),
+  is_onchain: z17.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 = z17.object({
+  items: z17.array(KmsInfoSchema),
+  total: z17.number(),
+  page: z17.number(),
+  page_size: z17.number(),
+  pages: z17.number()
 }).strict();
 var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
   const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
@@ -1454,17 +1548,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 z18 } from "zod";
+var GetAppEnvEncryptPubKeyRequestSchema = z18.object({
+  kms: z18.string().min(1, "KMS ID or slug is required"),
+  app_id: z18.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 = z18.object({
+  public_key: z18.string(),
+  signature: z18.string()
 }).strict();
 var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
@@ -1472,15 +1566,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 z19 } from "zod";
+var NextAppIdsRequestSchema = z19.object({
+  counts: z19.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 = z19.object({
+  app_ids: z19.array(
+    z19.object({
+      app_id: z19.string(),
+      nonce: z19.number().int().min(0)
     })
   )
 }).strict();
@@ -1516,10 +1610,10 @@ var { action: shutdownCvm, safeAction: safeShutdownCvm } = defineAction(VMSchema
 });
 
 // src/actions/cvms/restart_cvm.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var RestartCvmRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    force: z19.boolean().optional()
+    force: z20.boolean().optional()
   })
 );
 var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema, async (client, request) => {
@@ -1530,10 +1624,10 @@ var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema,
 });
 
 // src/actions/cvms/delete_cvm.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var DeleteCvmRequestSchema = CvmIdSchema;
 var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
-  z20.void(),
+  z21.void(),
   async (client, request) => {
     const { cvmId } = DeleteCvmRequestSchema.parse(request);
     await client.delete(`/cvms/${cvmId}`);
@@ -1542,41 +1636,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()
+import { z as z22 } from "zod";
+var DiskInfoSchema = z22.object({
+  name: z22.string(),
+  mount_point: z22.string(),
+  total_size: z22.number(),
+  free_size: z22.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 SystemInfoSchema = z22.object({
+  os_name: z22.string(),
+  os_version: z22.string(),
+  kernel_version: z22.string(),
+  cpu_model: z22.string(),
+  num_cpus: z22.number(),
+  total_memory: z22.number(),
+  available_memory: z22.number(),
+  used_memory: z22.number(),
+  free_memory: z22.number(),
+  total_swap: z22.number(),
+  used_swap: z22.number(),
+  free_swap: z22.number(),
+  uptime: z22.number(),
+  loadavg_one: z22.number(),
+  loadavg_five: z22.number(),
+  loadavg_fifteen: z22.number(),
+  disks: z22.array(DiskInfoSchema)
 });
-var CvmSystemInfoSchema = z21.object({
-  is_online: z21.boolean(),
-  is_public: z21.boolean().default(false),
-  error: z21.string().nullable(),
+var CvmSystemInfoSchema = z22.object({
+  is_online: z22.boolean(),
+  is_public: z22.boolean().default(false),
+  error: z22.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: z22.string().nullable(),
+  in_progress: z22.boolean().default(false),
+  boot_progress: z22.string().nullable(),
+  boot_error: z22.string().nullable()
 });
 var GetCvmStatsRequestSchema = CvmIdSchema;
 var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSystemInfoSchema, async (client, request) => {
@@ -1585,18 +1679,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()
+import { z as z23 } from "zod";
+var CvmNetworkUrlsSchema2 = z23.object({
+  app: z23.string(),
+  instance: z23.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()
+var CvmNetworkSchema = z23.object({
+  is_online: z23.boolean(),
+  is_public: z23.boolean().default(true),
+  error: z23.string().nullable(),
+  internal_ip: z23.string().nullable(),
+  latest_handshake: z23.string().nullable(),
+  public_urls: z23.array(CvmNetworkUrlsSchema2).nullable()
 });
 var GetCvmNetworkRequestSchema = CvmIdSchema;
 var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmNetworkSchema, async (client, request) => {
@@ -1605,36 +1699,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 z24 } from "zod";
 var GetCvmDockerComposeRequestSchema = CvmIdSchema;
-var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z23.string(), async (client, request) => {
+var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z24.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()
+import { z as z25 } from "zod";
+var ContainerInfoSchema = z25.object({
+  id: z25.string(),
+  names: z25.array(z25.string()),
+  image: z25.string(),
+  image_id: z25.string(),
+  command: z25.string().nullable().optional(),
+  created: z25.number(),
+  state: z25.string(),
+  status: z25.string(),
+  log_endpoint: z25.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()
+var CvmContainersStatsSchema = z25.object({
+  is_online: z25.boolean(),
+  is_public: z25.boolean().default(true),
+  error: z25.string().nullable(),
+  docker_compose_file: z25.string().nullable(),
+  manifest_version: z25.number().nullable(),
+  version: z25.string().nullable(),
+  runner: z25.string().nullable(),
+  features: z25.array(z25.string()).nullable(),
+  containers: z25.array(ContainerInfoSchema).nullable()
 });
 var GetCvmContainersStatsRequestSchema = CvmIdSchema;
 var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = defineAction(CvmContainersStatsSchema, async (client, request) => {
@@ -1643,62 +1737,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()
+import { z as z26 } from "zod";
+var CertificateSubjectSchema = z26.object({
+  common_name: z26.string().nullable(),
+  organization: z26.string().nullable(),
+  country: z26.string().nullable(),
+  state: z26.string().nullable(),
+  locality: z26.string().nullable()
 });
-var CertificateIssuerSchema = z25.object({
-  common_name: z25.string().nullable(),
-  organization: z25.string().nullable(),
-  country: z25.string().nullable()
+var CertificateIssuerSchema = z26.object({
+  common_name: z26.string().nullable(),
+  organization: z26.string().nullable(),
+  country: z26.string().nullable()
 });
-var CertificateSchema = z25.object({
+var CertificateSchema = z26.object({
   subject: CertificateSubjectSchema,
   issuer: CertificateIssuerSchema,
-  serial_number: z25.string(),
-  not_before: z25.string(),
+  serial_number: z26.string(),
+  not_before: z26.string(),
   // datetime serialized as ISO string
-  not_after: z25.string(),
+  not_after: z26.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()
+  version: z26.string(),
+  fingerprint: z26.string(),
+  signature_algorithm: z26.string(),
+  sans: z26.array(z26.string()).nullable(),
+  is_ca: z26.boolean(),
+  position_in_chain: z26.number().nullable(),
+  quote: z26.string().nullable(),
+  app_id: z26.string().nullable().optional(),
+  cert_usage: z26.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 EventLogSchema = z26.object({
+  imr: z26.number(),
+  event_type: z26.number(),
+  digest: z26.string(),
+  event: z26.string(),
+  event_payload: z26.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 TcbInfoSchema = z26.object({
+  mrtd: z26.string(),
+  rootfs_hash: z26.string().nullable().optional(),
+  rtmr0: z26.string(),
+  rtmr1: z26.string(),
+  rtmr2: z26.string(),
+  rtmr3: z26.string(),
+  event_log: z26.array(EventLogSchema),
+  app_compose: z26.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(),
+var CvmAttestationSchema = z26.object({
+  name: z26.string().nullable(),
+  is_online: z26.boolean(),
+  is_public: z26.boolean().default(true),
+  error: z26.string().nullable(),
+  app_certificates: z26.array(CertificateSchema).nullable(),
   tcb_info: TcbInfoSchema.nullable(),
-  compose_file: z25.string().nullable()
+  compose_file: z26.string().nullable()
 });
 var GetCvmAttestationRequestSchema = CvmIdSchema;
 var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAction(CvmAttestationSchema, async (client, request) => {
@@ -1707,17 +1801,17 @@ var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAct
 });
 
 // src/actions/cvms/update_cvm_resources.ts
-import { z as z26 } from "zod";
+import { z as z27 } 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: z27.number().optional(),
+    memory: z27.number().optional(),
+    disk_size: z27.number().optional(),
+    instance_type: z27.string().optional(),
+    allow_restart: z27.boolean().optional()
   })
 );
-var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z26.void(), async (client, request) => {
+var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z27.void(), async (client, request) => {
   const parsed = UpdateCvmResourcesRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { ...body } = parsed;
@@ -1726,11 +1820,11 @@ var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineA
 });
 
 // src/actions/cvms/update_cvm_visibility.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var UpdateCvmVisibilityRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    public_sysinfo: z27.boolean(),
-    public_logs: z27.boolean()
+    public_sysinfo: z28.boolean(),
+    public_logs: z28.boolean()
   })
 );
 var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
@@ -1741,21 +1835,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 z29 } from "zod";
+var OSImageVariantSchema = z29.object({
+  name: z29.string(),
+  os_image_hash: z29.string().nullable(),
+  is_current: z29.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 = z29.object({
+  version: z29.union([
+    z29.tuple([z29.number(), z29.number(), z29.number(), z29.number()]),
+    z29.tuple([z29.number(), z29.number(), z29.number()])
   ]),
   prod: OSImageVariantSchema.nullable(),
   dev: OSImageVariantSchema.nullable()
 });
-var GetAvailableOSImagesResponseSchema = z28.array(AvailableOSImageSchema2);
+var GetAvailableOSImagesResponseSchema = z29.array(AvailableOSImageSchema2);
 var GetAvailableOSImagesRequestSchema = CvmIdSchema;
 var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = defineAction(GetAvailableOSImagesResponseSchema, async (client, request) => {
   const { cvmId } = GetAvailableOSImagesRequestSchema.parse(request);
@@ -1763,13 +1857,13 @@ var { action: getAvailableOsImages, safeAction: safeGetAvailableOsImages } = def
 });
 
 // src/actions/cvms/update_os_image.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var UpdateOsImageRequestSchema = refineCvmId(
   CvmIdObjectSchema.extend({
-    os_image_name: z29.string().min(1, "OS image name is required")
+    os_image_name: z30.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(z30.void(), async (client, request) => {
   const parsed = UpdateOsImageRequestSchema.parse(request);
   const { cvmId } = CvmIdSchema.parse(parsed);
   const { os_image_name } = parsed;
@@ -1778,17 +1872,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 z31 } from "zod";
+var CvmStateSchema = z31.object({
+  id: z31.string().optional(),
+  instance_id: z31.string().optional(),
+  name: z31.string(),
+  status: z31.string(),
+  uptime: z31.string().optional(),
+  exited_at: z31.string().optional(),
+  boot_progress: z31.string().optional(),
+  boot_error: z31.string().optional(),
+  shutdown_progress: z31.string().optional()
 });
 var GetCvmStateRequestSchema = CvmIdSchema;
 var { action: getCvmState, safeAction: safeGetCvmState } = defineAction(CvmStateSchema, async (client, request) => {
@@ -1826,6 +1920,8 @@ function createClient2(config = {}) {
     safeProvisionCvmComposeFileUpdate,
     commitCvmComposeFileUpdate,
     safeCommitCvmComposeFileUpdate,
+    updateCvmEnvs,
+    safeUpdateCvmEnvs,
     startCvm,
     safeStartCvm,
     stopCvm,
@@ -1869,7 +1965,7 @@ function createClient2(config = {}) {
 }
 
 // src/actions/blockchains/deploy_app_auth.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 import {
   createPublicClient as createPublicClient2,
   createWalletClient as createWalletClient2,
@@ -2530,25 +2626,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z31.object({
+var DeployAppAuthRequestBaseSchema = z32.object({
   // Chain configuration (conditionally required)
-  chain: z31.unknown().optional(),
-  rpcUrl: z31.string().optional(),
+  chain: z32.unknown().optional(),
+  rpcUrl: z32.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z31.string(),
+  kmsContractAddress: z32.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z31.string().optional(),
-  walletClient: z31.unknown().optional(),
+  privateKey: z32.string().optional(),
+  walletClient: z32.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z31.unknown().optional(),
+  publicClient: z32.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: z32.boolean().optional().default(false),
+  deviceId: z32.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z32.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z32.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z31.boolean().optional().default(false),
-  minBalance: z31.string().optional()
+  skipPrerequisiteChecks: z32.boolean().optional().default(false),
+  minBalance: z32.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -2576,13 +2672,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 = z32.object({
+  appId: z32.string(),
+  appAuthAddress: z32.string(),
+  deployer: z32.string(),
+  transactionHash: z32.string(),
+  blockNumber: z32.bigint().optional(),
+  gasUsed: z32.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -2828,7 +2924,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -2852,29 +2948,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z32.object({
+var AddComposeHashRequestSchema = z33.object({
   // Chain configuration (conditionally required)
-  chain: z32.unknown().optional(),
-  rpcUrl: z32.string().optional(),
-  appId: z32.string(),
-  composeHash: z32.string(),
+  chain: z33.unknown().optional(),
+  rpcUrl: z33.string().optional(),
+  appId: z33.string(),
+  composeHash: z33.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z32.string().optional(),
-  walletClient: z32.unknown().optional(),
+  privateKey: z33.string().optional(),
+  walletClient: z33.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z32.unknown().optional(),
+  publicClient: z33.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z32.boolean().optional().default(false),
-  minBalance: z32.string().optional(),
+  skipPrerequisiteChecks: z33.boolean().optional().default(false),
+  minBalance: z33.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: z33.number().optional().default(12e4),
+  retryOptions: z33.unknown().optional(),
+  signal: z33.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z32.function().optional(),
-  onTransactionSubmitted: z32.function().optional(),
-  onTransactionConfirmed: z32.function().optional()
+  onTransactionStateChange: z33.function().optional(),
+  onTransactionSubmitted: z33.function().optional(),
+  onTransactionConfirmed: z33.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -2898,12 +2994,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 = z33.object({
+  composeHash: z33.string(),
+  appId: z33.string(),
+  transactionHash: z33.string(),
+  blockNumber: z33.bigint().optional(),
+  gasUsed: z33.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -3095,13 +3191,13 @@ async function safeAddComposeHash(request, parameters) {
 }
 
 // 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 z34 } from "zod";
+var WatchCvmStateParamsSchema = z34.object({
+  target: z34.string().describe("Target status to wait for (e.g., 'running', 'stopped')"),
+  interval: z34.number().min(5).max(30).default(5).describe("Polling interval in seconds"),
+  timeout: z34.number().min(10).max(600).default(300).describe("Timeout per attempt in seconds"),
+  maxRetries: z34.number().min(0).default(Number.POSITIVE_INFINITY).describe("Maximum number of retry attempts (Infinity for unlimited)"),
+  retryDelay: z34.number().min(0).default(5e3).describe("Delay between retries in milliseconds")
 });
 var WatchCvmStateRequestSchema = WatchCvmStateParamsSchema;
 var WatchAbortedError = class extends Error {
@@ -3390,6 +3486,7 @@ export {
   RequestError,
   ResourceError,
   RestartCvmRequestSchema,
+  SUPPORTED_API_VERSIONS,
   SUPPORTED_CHAINS,
   ServerError,
   ShutdownCvmRequestSchema,
@@ -3397,6 +3494,8 @@ export {
   StopCvmRequestSchema,
   TransactionError,
   UnknownError,
+  UpdateCvmEnvsRequestSchema,
+  UpdateCvmEnvsResultSchema,
   UpdateCvmResourcesRequestSchema,
   UpdateCvmVisibilityRequestSchema,
   UpdateOsImageRequestSchema,
@@ -3497,6 +3596,7 @@ export {
   safeShutdownCvm,
   safeStartCvm,
   safeStopCvm,
+  safeUpdateCvmEnvs,
   safeUpdateCvmResources,
   safeUpdateCvmVisibility,
   safeUpdateOsImage,
@@ -3506,6 +3606,7 @@ export {
   startCvm,
   stopCvm,
   switchToNetwork,
+  updateCvmEnvs,
   updateCvmResources,
   updateCvmVisibility,
   updateOsImage,