@phala/cloud 0.1.1-beta.2 → 0.1.1

package/dist/index.mjs

@@ -631,9 +631,6 @@ var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(Worksp
   return await client.get(`/workspaces/${teamSlug}`);
 });
 
-// src/actions/cvms/get_cvm_info.ts
-import { z as z8 } from "zod";
-
 // src/types/cvm_info.ts
 import { z as z7 } from "zod";
 var VmInfoSchema = z7.object({
@@ -659,7 +656,7 @@ var ManagedUserSchema = z7.object({
 var CvmNodeSchema = z7.object({
   id: z7.number(),
   name: z7.string(),
-  region_identifier: z7.string().optional()
+  region_identifier: z7.string().nullable().optional()
 });
 var CvmNetworkUrlsSchema = z7.object({
   app: z7.string(),
@@ -668,8 +665,8 @@ var CvmNetworkUrlsSchema = z7.object({
 var CvmInfoSchema = z7.object({
   hosted: VmInfoSchema,
   name: z7.string(),
-  managed_user: ManagedUserSchema.optional().nullable(),
-  node: CvmNodeSchema.optional().nullable(),
+  managed_user: ManagedUserSchema.nullable(),
+  node: CvmNodeSchema.nullable(),
   listed: z7.boolean().default(false),
   status: z7.string(),
   in_progress: z7.boolean().default(false),
@@ -686,59 +683,107 @@ var CvmInfoSchema = z7.object({
   disk_size: z7.number().nullable(),
   gateway_domain: z7.string().nullable(),
   public_urls: z7.array(CvmNetworkUrlsSchema)
-}).partial();
+});
 var CvmLegacyDetailSchema = z7.object({
   id: z7.number(),
   name: z7.string(),
   status: z7.string(),
-  in_progress: z7.boolean(),
+  in_progress: z7.boolean().optional().default(false),
   teepod_id: z7.number().nullable(),
-  teepod: CvmNodeSchema,
+  teepod: CvmNodeSchema.optional().nullable(),
   app_id: z7.string(),
   vm_uuid: z7.string().nullable(),
   instance_id: z7.string().nullable(),
-  vcpu: z7.number().nullable(),
-  memory: z7.number().nullable(),
-  disk_size: z7.number().nullable(),
-  base_image: z7.string(),
+  vcpu: z7.number(),
+  memory: z7.number(),
+  disk_size: z7.number(),
+  base_image: z7.string().nullable(),
   encrypted_env_pubkey: z7.string().nullable(),
-  listed: z7.boolean(),
-  project_id: z7.string().nullable(),
-  project_type: z7.string().nullable(),
-  public_sysinfo: z7.boolean(),
-  public_logs: z7.boolean(),
-  dapp_dashboard_url: z7.string().nullable(),
-  syslog_endpoint: z7.string().nullable(),
-  kms_info: KmsInfoSchema.nullable(),
-  contract_address: z7.string().nullable(),
-  deployer_address: z7.string().nullable(),
-  scheduled_delete_at: z7.string().nullable(),
-  public_urls: z7.array(CvmNetworkUrlsSchema),
-  gateway_domain: 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(),
+  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()
 });
 
-// src/actions/cvms/get_cvm_info.ts
-var GetCvmInfoRequestSchema = z8.object({
+// src/types/cvm_id.ts
+import { z as z8 } from "zod";
+var CvmIdObjectSchema = z8.object({
+  /** Direct CVM ID (any format) */
   id: z8.string().optional(),
-  uuid: z8.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: z8.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: z8.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()
-}).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) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  _raw: data
-}));
+  /** UUID format (with or without dashes) */
+  uuid: z8.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(),
+  /** Instance ID (40 characters, optionally prefixed with 'instance_') */
+  instance_id: z8.string().optional()
+});
+var refineCvmId = (schema) => schema.refine(
+  (data) => {
+    const obj = data;
+    return !!(obj.id || obj.uuid || obj.app_id || obj.instance_id);
+  },
+  {
+    message: "One of id, uuid, app_id, or instance_id must be provided"
+  }
+);
+var CvmIdBaseSchema = refineCvmId(CvmIdObjectSchema);
+var CvmIdSchema = CvmIdBaseSchema.transform((data) => {
+  let cvmId;
+  if (data.id) {
+    cvmId = data.id;
+  } else if (data.uuid) {
+    cvmId = data.uuid.replace(/-/g, "");
+  } else if (data.app_id) {
+    cvmId = data.app_id.startsWith("app_") ? data.app_id : `app_${data.app_id}`;
+  } else if (data.instance_id) {
+    cvmId = data.instance_id.startsWith("instance_") ? data.instance_id : `instance_${data.instance_id}`;
+  } else {
+    throw new Error("No valid identifier provided");
+  }
+  return { cvmId };
+});
+
+// src/actions/cvms/get_cvm_info.ts
+var GetCvmInfoRequestSchema = CvmIdSchema;
 var { action: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
-  const validatedRequest = GetCvmInfoRequestSchema.parse(request);
-  return await client.get(`/cvms/${validatedRequest.cvmId}`);
+  const { cvmId } = GetCvmInfoRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}`);
 });
 
 // src/actions/cvms/get_cvm_list.ts
@@ -746,7 +791,9 @@ 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()
+  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),
@@ -808,18 +855,6 @@ var ProvisionCvmRequestSchema = z10.object({
   kms_id: z10.string().optional(),
   env_keys: z10.array(z10.string()).optional()
 }).passthrough();
-function autofillComposeFileName(appCompose) {
-  if (appCompose.compose_file && !appCompose.compose_file.name) {
-    return {
-      ...appCompose,
-      compose_file: {
-        ...appCompose.compose_file,
-        name: appCompose.name
-      }
-    };
-  }
-  return appCompose;
-}
 function handleGatewayCompatibility(appCompose) {
   if (!appCompose.compose_file) {
     return appCompose;
@@ -842,7 +877,7 @@ function handleGatewayCompatibility(appCompose) {
   };
 }
 var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(ProvisionCvmSchema, async (client, appCompose) => {
-  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
+  const body = handleGatewayCompatibility(appCompose);
   let requestBody = { ...body };
   if (typeof body.node_id === "number") {
     requestBody = { ...body, teepod_id: body.node_id };
@@ -896,9 +931,6 @@ var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineA
   return await client.post("/cvms", payload);
 });
 
-// src/actions/cvms/get_cvm_compose_file.ts
-import { z as z13 } from "zod";
-
 // src/types/app_compose.ts
 import { z as z12 } from "zod";
 var LooseAppComposeSchema = z12.object({
@@ -911,11 +943,73 @@ var LooseAppComposeSchema = z12.object({
   public_logs: z12.boolean().optional(),
   public_sysinfo: z12.boolean().optional(),
   tproxy_enabled: z12.boolean().optional(),
-  pre_launch_script: z12.string().optional()
+  pre_launch_script: z12.string().optional(),
+  env_pubkey: z12.string().optional(),
+  salt: z12.string().optional().nullable()
 }).passthrough();
 
+// src/utils/get_compose_hash.ts
+import crypto from "crypto";
+function sortObject(obj) {
+  if (obj === void 0 || obj === null) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(sortObject);
+  } else if (obj && typeof obj === "object" && obj.constructor === Object) {
+    return Object.keys(obj).sort().reduce((result, key) => {
+      const value = obj[key];
+      result[key] = sortObject(value);
+      return result;
+    }, {});
+  }
+  return obj;
+}
+function preprocessAppCompose(dic) {
+  const obj = { ...dic };
+  if (obj.runner === "bash" && "docker_compose_file" in obj) {
+    delete obj.docker_compose_file;
+  } else if (obj.runner === "docker-compose" && "bash_script" in obj) {
+    delete obj.bash_script;
+  }
+  if ("pre_launch_script" in obj && !obj.pre_launch_script) {
+    delete obj.pre_launch_script;
+  }
+  return obj;
+}
+function dumpAppCompose(dic) {
+  const ordered = sortObject(dic);
+  let json = JSON.stringify(ordered, null, 4);
+  json = json.replace(/": /g, '":');
+  return json;
+}
+function getComposeHash(app_compose) {
+  const preprocessed = preprocessAppCompose(app_compose);
+  const manifest_str = dumpAppCompose(preprocessed);
+  return crypto.createHash("sha256").update(manifest_str, "utf8").digest("hex");
+}
+function withComposeMethods(compose) {
+  const appCompose = compose;
+  return {
+    ...compose,
+    getHash: () => getComposeHash(appCompose),
+    toString: () => dumpAppCompose(preprocessAppCompose(appCompose))
+  };
+}
+
 // src/actions/cvms/get_cvm_compose_file.ts
-var GetCvmComposeFileRequestSchema = z13.object({
+var GetCvmComposeFileResultSchema = LooseAppComposeSchema.transform(
+  (data) => withComposeMethods(data)
+);
+var GetCvmComposeFileRequestSchema = CvmIdSchema;
+var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAction(GetCvmComposeFileResultSchema, async (client, request) => {
+  const { cvmId } = GetCvmComposeFileRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/compose_file`);
+});
+
+// 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(
@@ -925,34 +1019,9 @@ var GetCvmComposeFileRequestSchema = z13.object({
   instance_id: z13.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()
-}).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) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  _raw: data
-}));
-var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAction(LooseAppComposeSchema, async (client, request) => {
-  const validatedRequest = GetCvmComposeFileRequestSchema.parse(request);
-  return await client.get(`/cvms/${validatedRequest.cvmId}/compose_file`);
-});
-
-// src/actions/cvms/provision_cvm_compose_file_update.ts
-import { z as z14 } from "zod";
-var ProvisionCvmComposeFileUpdateRequestSchema = 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(
-    (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(
-    (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: z14.boolean().optional().nullable()
+  update_env_vars: z13.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"
@@ -962,10 +1031,10 @@ var ProvisionCvmComposeFileUpdateRequestSchema = z14.object({
   update_env_vars: data.update_env_vars,
   _raw: data
 }));
-var ProvisionCvmComposeFileUpdateResultSchema = z14.object({
-  app_id: z14.string().nullable(),
-  device_id: z14.string().nullable(),
-  compose_hash: z14.string(),
+var ProvisionCvmComposeFileUpdateResultSchema = z13.object({
+  app_id: z13.string().nullable(),
+  device_id: z13.string().nullable(),
+  compose_hash: z13.string(),
   kms_info: KmsInfoSchema.nullable().optional()
 }).passthrough();
 var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
@@ -977,22 +1046,22 @@ var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmCompose
 });
 
 // src/actions/cvms/commit_cvm_compose_file_update.ts
-import { z as z15 } from "zod";
-var CommitCvmComposeFileUpdateRequestSchema = 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(
+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(
     (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(
+  instance_id: z14.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: z15.string().min(1, "Compose hash is required"),
-  encrypted_env: z15.string().optional(),
-  env_keys: z15.array(z15.string()).optional(),
-  update_env_vars: z15.boolean().optional().nullable()
+  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()
 }).refine(
   (data) => !!(data.id || data.uuid || data.app_id || data.instance_id),
   "One of id, uuid, app_id, or instance_id must be provided"
@@ -1004,7 +1073,7 @@ var CommitCvmComposeFileUpdateRequestSchema = z15.object({
   update_env_vars: !!data.update_env_vars,
   _raw: data
 }));
-var CommitCvmComposeFileUpdateSchema = z15.any().transform(() => void 0);
+var CommitCvmComposeFileUpdateSchema = z14.any().transform(() => void 0);
 var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
   CommitCvmComposeFileUpdateSchema,
   async (client, request) => {
@@ -1018,9 +1087,9 @@ var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUp
 );
 
 // 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")
+import { z as z15 } from "zod";
+var GetKmsInfoRequestSchema = z15.object({
+  kms_id: z15.string().min(1, "KMS ID is required")
 });
 var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
   const validatedRequest = GetKmsInfoRequestSchema.parse(request);
@@ -1028,18 +1097,18 @@ var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSch
 });
 
 // src/actions/kms/get_kms_list.ts
-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()
+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()
 }).strict();
-var GetKmsListSchema = z17.object({
-  items: z17.array(KmsInfoSchema),
-  total: z17.number(),
-  page: z17.number(),
-  page_size: z17.number(),
-  pages: z17.number()
+var GetKmsListSchema = z16.object({
+  items: z16.array(KmsInfoSchema),
+  total: z16.number(),
+  page: z16.number(),
+  page_size: z16.number(),
+  pages: z16.number()
 }).strict();
 var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
   const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
@@ -1047,23 +1116,272 @@ var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsList
 });
 
 // src/actions/kms/get_app_env_encrypt_pubkey.ts
-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(
+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(
     (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 = z18.object({
-  public_key: z18.string(),
-  signature: z18.string()
+var GetAppEnvEncryptPubKeySchema = z17.object({
+  public_key: z17.string(),
+  signature: z17.string()
 }).strict();
 var { action: getAppEnvEncryptPubKey, safeAction: safeGetAppEnvEncryptPubKey } = defineAction(GetAppEnvEncryptPubKeySchema, async (client, payload) => {
   const validatedRequest = GetAppEnvEncryptPubKeyRequestSchema.parse(payload);
   return await client.get(`/kms/${validatedRequest.kms}/pubkey/${validatedRequest.app_id}`);
 });
 
+// src/actions/cvms/start_cvm.ts
+var StartCvmRequestSchema = CvmIdSchema;
+var { action: startCvm, safeAction: safeStartCvm } = defineAction(VMSchema, async (client, request) => {
+  const { cvmId } = StartCvmRequestSchema.parse(request);
+  return await client.post(`/cvms/${cvmId}/start`);
+});
+
+// src/actions/cvms/stop_cvm.ts
+var StopCvmRequestSchema = CvmIdSchema;
+var { action: stopCvm, safeAction: safeStopCvm } = defineAction(
+  VMSchema,
+  async (client, request) => {
+    const { cvmId } = StopCvmRequestSchema.parse(request);
+    return await client.post(`/cvms/${cvmId}/stop`);
+  }
+);
+
+// src/actions/cvms/shutdown_cvm.ts
+var ShutdownCvmRequestSchema = CvmIdSchema;
+var { action: shutdownCvm, safeAction: safeShutdownCvm } = defineAction(VMSchema, async (client, request) => {
+  const { cvmId } = ShutdownCvmRequestSchema.parse(request);
+  return await client.post(`/cvms/${cvmId}/shutdown`);
+});
+
+// src/actions/cvms/restart_cvm.ts
+import { z as z18 } from "zod";
+var RestartCvmRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    force: z18.boolean().optional()
+  })
+);
+var { action: restartCvm, safeAction: safeRestartCvm } = defineAction(VMSchema, async (client, request) => {
+  const parsed = RestartCvmRequestSchema.parse(request);
+  const { cvmId } = CvmIdSchema.parse(parsed);
+  const { force = false } = parsed;
+  return await client.post(`/cvms/${cvmId}/restart`, { force });
+});
+
+// src/actions/cvms/delete_cvm.ts
+import { z as z19 } from "zod";
+var DeleteCvmRequestSchema = CvmIdSchema;
+var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
+  z19.void(),
+  async (client, request) => {
+    const { cvmId } = DeleteCvmRequestSchema.parse(request);
+    await client.delete(`/cvms/${cvmId}`);
+    return void 0;
+  }
+);
+
+// src/actions/cvms/get_cvm_stats.ts
+import { z as z20 } from "zod";
+var DiskInfoSchema = z20.object({
+  name: z20.string(),
+  mount_point: z20.string(),
+  total_size: z20.number(),
+  free_size: z20.number()
+});
+var SystemInfoSchema = z20.object({
+  os_name: z20.string(),
+  os_version: z20.string(),
+  kernel_version: z20.string(),
+  cpu_model: z20.string(),
+  num_cpus: z20.number(),
+  total_memory: z20.number(),
+  available_memory: z20.number(),
+  used_memory: z20.number(),
+  free_memory: z20.number(),
+  total_swap: z20.number(),
+  used_swap: z20.number(),
+  free_swap: z20.number(),
+  uptime: z20.number(),
+  loadavg_one: z20.number(),
+  loadavg_five: z20.number(),
+  loadavg_fifteen: z20.number(),
+  disks: z20.array(DiskInfoSchema)
+});
+var CvmSystemInfoSchema = z20.object({
+  is_online: z20.boolean(),
+  is_public: z20.boolean().default(false),
+  error: z20.string().nullable(),
+  sysinfo: SystemInfoSchema.nullable(),
+  status: z20.string().nullable(),
+  in_progress: z20.boolean().default(false),
+  boot_progress: z20.string().nullable(),
+  boot_error: z20.string().nullable()
+});
+var GetCvmStatsRequestSchema = CvmIdSchema;
+var { action: getCvmStats, safeAction: safeGetCvmStats } = defineAction(CvmSystemInfoSchema, async (client, request) => {
+  const { cvmId } = GetCvmStatsRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/stats`);
+});
+
+// src/actions/cvms/get_cvm_network.ts
+import { z as z21 } from "zod";
+var CvmNetworkUrlsSchema2 = z21.object({
+  app: z21.string(),
+  instance: z21.string()
+});
+var CvmNetworkSchema = z21.object({
+  is_online: z21.boolean(),
+  is_public: z21.boolean().default(true),
+  error: z21.string().nullable(),
+  internal_ip: z21.string().nullable(),
+  latest_handshake: z21.string().nullable(),
+  public_urls: z21.array(CvmNetworkUrlsSchema2).nullable()
+});
+var GetCvmNetworkRequestSchema = CvmIdSchema;
+var { action: getCvmNetwork, safeAction: safeGetCvmNetwork } = defineAction(CvmNetworkSchema, async (client, request) => {
+  const { cvmId } = GetCvmNetworkRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/network`);
+});
+
+// src/actions/cvms/get_cvm_docker_compose.ts
+import { z as z22 } from "zod";
+var GetCvmDockerComposeRequestSchema = CvmIdSchema;
+var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(z22.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 z23 } from "zod";
+var ContainerInfoSchema = z23.object({
+  id: z23.string(),
+  names: z23.array(z23.string()),
+  image: z23.string(),
+  image_id: z23.string(),
+  command: z23.string().nullable().optional(),
+  created: z23.number(),
+  state: z23.string(),
+  status: z23.string(),
+  log_endpoint: z23.string().nullable()
+});
+var CvmContainersStatsSchema = z23.object({
+  is_online: z23.boolean(),
+  is_public: z23.boolean().default(true),
+  error: z23.string().nullable(),
+  docker_compose_file: z23.string().nullable(),
+  manifest_version: z23.number().nullable(),
+  version: z23.string().nullable(),
+  runner: z23.string().nullable(),
+  features: z23.array(z23.string()).nullable(),
+  containers: z23.array(ContainerInfoSchema).nullable()
+});
+var GetCvmContainersStatsRequestSchema = CvmIdSchema;
+var { action: getCvmContainersStats, safeAction: safeGetCvmContainersStats } = defineAction(CvmContainersStatsSchema, async (client, request) => {
+  const { cvmId } = GetCvmContainersStatsRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/composition`);
+});
+
+// src/actions/cvms/get_cvm_attestation.ts
+import { z as z24 } from "zod";
+var CertificateSubjectSchema = z24.object({
+  common_name: z24.string().nullable(),
+  organization: z24.string().nullable(),
+  country: z24.string().nullable(),
+  state: z24.string().nullable(),
+  locality: z24.string().nullable()
+});
+var CertificateIssuerSchema = z24.object({
+  common_name: z24.string().nullable(),
+  organization: z24.string().nullable(),
+  country: z24.string().nullable()
+});
+var CertificateSchema = z24.object({
+  subject: CertificateSubjectSchema,
+  issuer: CertificateIssuerSchema,
+  serial_number: z24.string(),
+  not_before: z24.string(),
+  // datetime serialized as ISO string
+  not_after: z24.string(),
+  // datetime serialized as ISO string
+  version: z24.string(),
+  fingerprint: z24.string(),
+  signature_algorithm: z24.string(),
+  sans: z24.array(z24.string()).nullable(),
+  is_ca: z24.boolean(),
+  position_in_chain: z24.number().nullable(),
+  quote: z24.string().nullable(),
+  app_id: z24.string().nullable().optional(),
+  cert_usage: z24.string().nullable().optional()
+});
+var EventLogSchema = z24.object({
+  imr: z24.number(),
+  event_type: z24.number(),
+  digest: z24.string(),
+  event: z24.string(),
+  event_payload: z24.string()
+});
+var TcbInfoSchema = z24.object({
+  mrtd: z24.string(),
+  rootfs_hash: z24.string().nullable().optional(),
+  rtmr0: z24.string(),
+  rtmr1: z24.string(),
+  rtmr2: z24.string(),
+  rtmr3: z24.string(),
+  event_log: z24.array(EventLogSchema),
+  app_compose: z24.string()
+});
+var CvmAttestationSchema = z24.object({
+  name: z24.string().nullable(),
+  is_online: z24.boolean(),
+  is_public: z24.boolean().default(true),
+  error: z24.string().nullable(),
+  app_certificates: z24.array(CertificateSchema).nullable(),
+  tcb_info: TcbInfoSchema.nullable(),
+  compose_file: z24.string().nullable()
+});
+var GetCvmAttestationRequestSchema = CvmIdSchema;
+var { action: getCvmAttestation, safeAction: safeGetCvmAttestation } = defineAction(CvmAttestationSchema, async (client, request) => {
+  const { cvmId } = GetCvmAttestationRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}/attestation`);
+});
+
+// src/actions/cvms/update_cvm_resources.ts
+import { z as z25 } from "zod";
+var UpdateCvmResourcesRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    vcpu: z25.number().optional(),
+    memory: z25.number().optional(),
+    disk_size: z25.number().optional(),
+    instance_type: z25.string().optional(),
+    allow_restart: z25.boolean().optional()
+  })
+);
+var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(z25.void(), async (client, request) => {
+  const parsed = UpdateCvmResourcesRequestSchema.parse(request);
+  const { cvmId } = CvmIdSchema.parse(parsed);
+  const { ...body } = parsed;
+  await client.patch(`/cvms/${cvmId}/resources`, body);
+  return void 0;
+});
+
+// src/actions/cvms/update_cvm_visibility.ts
+import { z as z26 } from "zod";
+var UpdateCvmVisibilityRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    public_sysinfo: z26.boolean(),
+    public_logs: z26.boolean()
+  })
+);
+var { action: updateCvmVisibility, safeAction: safeUpdateCvmVisibility } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
+  const parsed = UpdateCvmVisibilityRequestSchema.parse(request);
+  const { cvmId } = CvmIdSchema.parse(parsed);
+  const { public_sysinfo, public_logs } = parsed;
+  return await client.patch(`/cvms/${cvmId}/visibility`, { public_sysinfo, public_logs });
+});
+
 // src/create-client.ts
 function createClient2(config = {}) {
   const client = createClient(config);
@@ -1092,6 +1410,30 @@ function createClient2(config = {}) {
     safeProvisionCvmComposeFileUpdate,
     commitCvmComposeFileUpdate,
     safeCommitCvmComposeFileUpdate,
+    startCvm,
+    safeStartCvm,
+    stopCvm,
+    safeStopCvm,
+    shutdownCvm,
+    safeShutdownCvm,
+    restartCvm,
+    safeRestartCvm,
+    deleteCvm,
+    safeDeleteCvm,
+    getCvmStats,
+    safeGetCvmStats,
+    getCvmNetwork,
+    safeGetCvmNetwork,
+    getCvmDockerCompose,
+    safeGetCvmDockerCompose,
+    getCvmContainersStats,
+    safeGetCvmContainersStats,
+    getCvmAttestation,
+    safeGetCvmAttestation,
+    updateCvmResources,
+    safeUpdateCvmResources,
+    updateCvmVisibility,
+    safeUpdateCvmVisibility,
     getKmsInfo,
     safeGetKmsInfo,
     getKmsList,
@@ -1103,7 +1445,7 @@ function createClient2(config = {}) {
 }
 
 // src/actions/blockchains/deploy_app_auth.ts
-import { z as z19 } from "zod";
+import { z as z27 } from "zod";
 import {
   createPublicClient as createPublicClient2,
   createWalletClient as createWalletClient2,
@@ -1781,25 +2123,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z19.object({
+var DeployAppAuthRequestBaseSchema = z27.object({
   // Chain configuration (conditionally required)
-  chain: z19.unknown().optional(),
-  rpcUrl: z19.string().optional(),
+  chain: z27.unknown().optional(),
+  rpcUrl: z27.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z19.string(),
+  kmsContractAddress: z27.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z19.string().optional(),
-  walletClient: z19.unknown().optional(),
+  privateKey: z27.string().optional(),
+  walletClient: z27.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z19.unknown().optional(),
+  publicClient: z27.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z19.boolean().optional().default(false),
-  deviceId: z19.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z19.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z19.boolean().optional().default(false),
+  allowAnyDevice: z27.boolean().optional().default(false),
+  deviceId: z27.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: z27.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: z27.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z19.boolean().optional().default(false),
-  minBalance: z19.string().optional()
+  skipPrerequisiteChecks: z27.boolean().optional().default(false),
+  minBalance: z27.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -1827,13 +2169,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z19.object({
-  appId: z19.string(),
-  appAuthAddress: z19.string(),
-  deployer: z19.string(),
-  transactionHash: z19.string(),
-  blockNumber: z19.bigint().optional(),
-  gasUsed: z19.bigint().optional()
+var DeployAppAuthSchema = z27.object({
+  appId: z27.string(),
+  appAuthAddress: z27.string(),
+  deployer: z27.string(),
+  transactionHash: z27.string(),
+  blockNumber: z27.bigint().optional(),
+  gasUsed: z27.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -2079,7 +2421,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-import { z as z20 } from "zod";
+import { z as z28 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -2103,29 +2445,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z20.object({
+var AddComposeHashRequestSchema = z28.object({
   // Chain configuration (conditionally required)
-  chain: z20.unknown().optional(),
-  rpcUrl: z20.string().optional(),
-  appId: z20.string(),
-  composeHash: z20.string(),
+  chain: z28.unknown().optional(),
+  rpcUrl: z28.string().optional(),
+  appId: z28.string(),
+  composeHash: z28.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z20.string().optional(),
-  walletClient: z20.unknown().optional(),
+  privateKey: z28.string().optional(),
+  walletClient: z28.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z20.unknown().optional(),
+  publicClient: z28.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z20.boolean().optional().default(false),
-  minBalance: z20.string().optional(),
+  skipPrerequisiteChecks: z28.boolean().optional().default(false),
+  minBalance: z28.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z20.number().optional().default(12e4),
-  retryOptions: z20.unknown().optional(),
-  signal: z20.unknown().optional(),
+  timeout: z28.number().optional().default(12e4),
+  retryOptions: z28.unknown().optional(),
+  signal: z28.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z20.function().optional(),
-  onTransactionSubmitted: z20.function().optional(),
-  onTransactionConfirmed: z20.function().optional()
+  onTransactionStateChange: z28.function().optional(),
+  onTransactionSubmitted: z28.function().optional(),
+  onTransactionConfirmed: z28.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -2149,12 +2491,12 @@ var AddComposeHashRequestSchema = z20.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z20.object({
-  composeHash: z20.string(),
-  appId: z20.string(),
-  transactionHash: z20.string(),
-  blockNumber: z20.bigint().optional(),
-  gasUsed: z20.bigint().optional()
+var AddComposeHashSchema = z28.object({
+  composeHash: z28.string(),
+  appId: z28.string(),
+  transactionHash: z28.string(),
+  blockNumber: z28.bigint().optional(),
+  gasUsed: z28.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -2391,18 +2733,31 @@ export {
   CommitCvmProvisionRequestSchema,
   CommitCvmProvisionSchema,
   CurrentUserSchema,
+  CvmAttestationSchema,
+  CvmContainersStatsSchema,
+  CvmIdBaseSchema,
+  CvmIdObjectSchema,
+  CvmIdSchema,
   CvmInfoSchema,
   CvmLegacyDetailSchema,
+  CvmNetworkSchema,
   CvmNetworkUrlsSchema,
   CvmNodeSchema,
+  CvmSystemInfoSchema,
+  DeleteCvmRequestSchema,
   DeployAppAuthRequestSchema,
   DeployAppAuthSchema,
   GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema,
+  GetCvmAttestationRequestSchema,
   GetCvmComposeFileRequestSchema,
+  GetCvmContainersStatsRequestSchema,
+  GetCvmDockerComposeRequestSchema,
   GetCvmInfoRequestSchema,
   GetCvmListRequestSchema,
   GetCvmListSchema,
+  GetCvmNetworkRequestSchema,
+  GetCvmStatsRequestSchema,
   GetKmsInfoRequestSchema,
   GetKmsListRequestSchema,
   GetKmsListSchema,
@@ -2419,8 +2774,15 @@ export {
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
   RequestError,
+  RestartCvmRequestSchema,
   SUPPORTED_CHAINS,
+  ShutdownCvmRequestSchema,
+  StartCvmRequestSchema,
+  StopCvmRequestSchema,
   TransactionError,
+  UpdateCvmResourcesRequestSchema,
+  UpdateCvmVisibilityRequestSchema,
+  VMSchema,
   VmInfoSchema,
   WalletError,
   WorkspaceResponseSchema,
@@ -2440,7 +2802,9 @@ export {
   createTransactionTracker,
   defineAction,
   defineSimpleAction,
+  deleteCvm,
   deployAppAuth,
+  dumpAppCompose,
   encryptEnvVars2 as encryptEnvVars,
   estimateTransactionGas,
   executeBatchTransactions,
@@ -2451,9 +2815,14 @@ export {
   getAvailableNodes,
   getComposeHash2 as getComposeHash,
   getCurrentUser,
+  getCvmAttestation,
   getCvmComposeFile,
+  getCvmContainersStats,
+  getCvmDockerCompose,
   getCvmInfo,
   getCvmList,
+  getCvmNetwork,
+  getCvmStats,
   getErrorMessage,
   getKmsInfo,
   getKmsList,
@@ -2462,18 +2831,27 @@ export {
   listWorkspaces,
   parseEnv,
   parseEnvVars,
+  preprocessAppCompose,
   provisionCvm,
   provisionCvmComposeFileUpdate,
+  refineCvmId,
+  restartCvm,
   safeAddComposeHash,
   safeCommitCvmComposeFileUpdate,
   safeCommitCvmProvision,
+  safeDeleteCvm,
   safeDeployAppAuth,
   safeGetAppEnvEncryptPubKey,
   safeGetAvailableNodes,
   safeGetCurrentUser,
+  safeGetCvmAttestation,
   safeGetCvmComposeFile,
+  safeGetCvmContainersStats,
+  safeGetCvmDockerCompose,
   safeGetCvmInfo,
   safeGetCvmList,
+  safeGetCvmNetwork,
+  safeGetCvmStats,
   safeGetKmsInfo,
   safeGetKmsList,
   safeGetWorkspace,
@@ -2481,10 +2859,23 @@ export {
   safeListWorkspaces,
   safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate,
+  safeRestartCvm,
+  safeShutdownCvm,
+  safeStartCvm,
+  safeStopCvm,
+  safeUpdateCvmResources,
+  safeUpdateCvmVisibility,
   safeValidateActionParameters,
+  shutdownCvm,
+  sortObject,
+  startCvm,
+  stopCvm,
   switchToNetwork,
+  updateCvmResources,
+  updateCvmVisibility,
   validateActionParameters,
   validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey,
-  waitForTransactionReceipt
+  waitForTransactionReceipt,
+  withComposeMethods
 };