@phala/cloud 0.1.1-beta.1 → 0.1.1-beta.3

package/dist/index.js

@@ -38,18 +38,31 @@ __export(index_exports, {
   CommitCvmProvisionRequestSchema: () => CommitCvmProvisionRequestSchema,
   CommitCvmProvisionSchema: () => CommitCvmProvisionSchema,
   CurrentUserSchema: () => CurrentUserSchema,
+  CvmAttestationSchema: () => CvmAttestationSchema,
+  CvmContainersStatsSchema: () => CvmContainersStatsSchema,
+  CvmIdBaseSchema: () => CvmIdBaseSchema,
+  CvmIdObjectSchema: () => CvmIdObjectSchema,
+  CvmIdSchema: () => CvmIdSchema,
   CvmInfoSchema: () => CvmInfoSchema,
   CvmLegacyDetailSchema: () => CvmLegacyDetailSchema,
+  CvmNetworkSchema: () => CvmNetworkSchema,
   CvmNetworkUrlsSchema: () => CvmNetworkUrlsSchema,
   CvmNodeSchema: () => CvmNodeSchema,
+  CvmSystemInfoSchema: () => CvmSystemInfoSchema,
+  DeleteCvmRequestSchema: () => DeleteCvmRequestSchema,
   DeployAppAuthRequestSchema: () => DeployAppAuthRequestSchema,
   DeployAppAuthSchema: () => DeployAppAuthSchema,
   GetAppEnvEncryptPubKeyRequestSchema: () => GetAppEnvEncryptPubKeyRequestSchema,
   GetAppEnvEncryptPubKeySchema: () => GetAppEnvEncryptPubKeySchema,
+  GetCvmAttestationRequestSchema: () => GetCvmAttestationRequestSchema,
   GetCvmComposeFileRequestSchema: () => GetCvmComposeFileRequestSchema,
+  GetCvmContainersStatsRequestSchema: () => GetCvmContainersStatsRequestSchema,
+  GetCvmDockerComposeRequestSchema: () => GetCvmDockerComposeRequestSchema,
   GetCvmInfoRequestSchema: () => GetCvmInfoRequestSchema,
   GetCvmListRequestSchema: () => GetCvmListRequestSchema,
   GetCvmListSchema: () => GetCvmListSchema,
+  GetCvmNetworkRequestSchema: () => GetCvmNetworkRequestSchema,
+  GetCvmStatsRequestSchema: () => GetCvmStatsRequestSchema,
   GetKmsInfoRequestSchema: () => GetKmsInfoRequestSchema,
   GetKmsListRequestSchema: () => GetKmsListRequestSchema,
   GetKmsListSchema: () => GetKmsListSchema,
@@ -66,8 +79,15 @@ __export(index_exports, {
   ProvisionCvmRequestSchema: () => ProvisionCvmRequestSchema,
   ProvisionCvmSchema: () => ProvisionCvmSchema,
   RequestError: () => RequestError,
+  RestartCvmRequestSchema: () => RestartCvmRequestSchema,
   SUPPORTED_CHAINS: () => SUPPORTED_CHAINS,
+  ShutdownCvmRequestSchema: () => ShutdownCvmRequestSchema,
+  StartCvmRequestSchema: () => StartCvmRequestSchema,
+  StopCvmRequestSchema: () => StopCvmRequestSchema,
   TransactionError: () => TransactionError,
+  UpdateCvmResourcesRequestSchema: () => UpdateCvmResourcesRequestSchema,
+  UpdateCvmVisibilityRequestSchema: () => UpdateCvmVisibilityRequestSchema,
+  VMSchema: () => VMSchema,
   VmInfoSchema: () => VmInfoSchema,
   WalletError: () => WalletError,
   WorkspaceResponseSchema: () => WorkspaceResponseSchema,
@@ -79,13 +99,15 @@ __export(index_exports, {
   checkNetworkStatus: () => checkNetworkStatus,
   commitCvmComposeFileUpdate: () => commitCvmComposeFileUpdate,
   commitCvmProvision: () => commitCvmProvision,
-  createClient: () => createClient,
+  createBaseClient: () => createClient,
+  createClient: () => createClient2,
   createClientsFromBrowser: () => createClientsFromBrowser,
   createClientsFromPrivateKey: () => createClientsFromPrivateKey,
   createNetworkClients: () => createNetworkClients,
   createTransactionTracker: () => createTransactionTracker,
   defineAction: () => defineAction,
   defineSimpleAction: () => defineSimpleAction,
+  deleteCvm: () => deleteCvm,
   deployAppAuth: () => deployAppAuth,
   encryptEnvVars: () => import_encrypt_env_vars2.encryptEnvVars,
   estimateTransactionGas: () => estimateTransactionGas,
@@ -97,9 +119,14 @@ __export(index_exports, {
   getAvailableNodes: () => getAvailableNodes,
   getComposeHash: () => import_get_compose_hash2.getComposeHash,
   getCurrentUser: () => getCurrentUser,
+  getCvmAttestation: () => getCvmAttestation,
   getCvmComposeFile: () => getCvmComposeFile,
+  getCvmContainersStats: () => getCvmContainersStats,
+  getCvmDockerCompose: () => getCvmDockerCompose,
   getCvmInfo: () => getCvmInfo,
   getCvmList: () => getCvmList,
+  getCvmNetwork: () => getCvmNetwork,
+  getCvmStats: () => getCvmStats,
   getErrorMessage: () => getErrorMessage,
   getKmsInfo: () => getKmsInfo,
   getKmsList: () => getKmsList,
@@ -110,16 +137,24 @@ __export(index_exports, {
   parseEnvVars: () => parseEnvVars,
   provisionCvm: () => provisionCvm,
   provisionCvmComposeFileUpdate: () => provisionCvmComposeFileUpdate,
+  refineCvmId: () => refineCvmId,
+  restartCvm: () => restartCvm,
   safeAddComposeHash: () => safeAddComposeHash,
   safeCommitCvmComposeFileUpdate: () => safeCommitCvmComposeFileUpdate,
   safeCommitCvmProvision: () => safeCommitCvmProvision,
+  safeDeleteCvm: () => safeDeleteCvm,
   safeDeployAppAuth: () => safeDeployAppAuth,
   safeGetAppEnvEncryptPubKey: () => safeGetAppEnvEncryptPubKey,
   safeGetAvailableNodes: () => safeGetAvailableNodes,
   safeGetCurrentUser: () => safeGetCurrentUser,
+  safeGetCvmAttestation: () => safeGetCvmAttestation,
   safeGetCvmComposeFile: () => safeGetCvmComposeFile,
+  safeGetCvmContainersStats: () => safeGetCvmContainersStats,
+  safeGetCvmDockerCompose: () => safeGetCvmDockerCompose,
   safeGetCvmInfo: () => safeGetCvmInfo,
   safeGetCvmList: () => safeGetCvmList,
+  safeGetCvmNetwork: () => safeGetCvmNetwork,
+  safeGetCvmStats: () => safeGetCvmStats,
   safeGetKmsInfo: () => safeGetKmsInfo,
   safeGetKmsList: () => safeGetKmsList,
   safeGetWorkspace: () => safeGetWorkspace,
@@ -127,8 +162,19 @@ __export(index_exports, {
   safeListWorkspaces: () => safeListWorkspaces,
   safeProvisionCvm: () => safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate: () => safeProvisionCvmComposeFileUpdate,
+  safeRestartCvm: () => safeRestartCvm,
+  safeShutdownCvm: () => safeShutdownCvm,
+  safeStartCvm: () => safeStartCvm,
+  safeStopCvm: () => safeStopCvm,
+  safeUpdateCvmResources: () => safeUpdateCvmResources,
+  safeUpdateCvmVisibility: () => safeUpdateCvmVisibility,
   safeValidateActionParameters: () => safeValidateActionParameters,
+  shutdownCvm: () => shutdownCvm,
+  startCvm: () => startCvm,
+  stopCvm: () => stopCvm,
   switchToNetwork: () => switchToNetwork,
+  updateCvmResources: () => updateCvmResources,
+  updateCvmVisibility: () => updateCvmVisibility,
   validateActionParameters: () => validateActionParameters,
   validateNetworkPrerequisites: () => validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey: () => import_verify_env_encrypt_public_key.verifyEnvEncryptPublicKey,
@@ -459,122 +505,8 @@ function createClient(config = {}) {
   return new Client(config);
 }
 
-// src/types/kms_info.ts
-var import_zod2 = require("zod");
-
-// src/types/supported_chains.ts
-var import_chains = require("viem/chains");
-var SUPPORTED_CHAINS = {
-  [import_chains.mainnet.id]: import_chains.mainnet,
-  [import_chains.base.id]: import_chains.base,
-  [import_chains.anvil.id]: import_chains.anvil
-};
-
-// src/types/kms_info.ts
-var KmsInfoBaseSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  slug: import_zod2.z.string().nullable(),
-  url: import_zod2.z.string(),
-  version: import_zod2.z.string(),
-  chain_id: import_zod2.z.number().nullable(),
-  kms_contract_address: import_zod2.z.string().nullable().transform((val) => val),
-  gateway_app_id: import_zod2.z.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/types/cvm_info.ts
-var import_zod3 = require("zod");
-var VmInfoSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  status: import_zod3.z.string(),
-  uptime: import_zod3.z.string(),
-  app_url: import_zod3.z.string().nullable(),
-  app_id: import_zod3.z.string(),
-  instance_id: import_zod3.z.string().nullable(),
-  configuration: import_zod3.z.any().optional(),
-  // TODO: add VmConfiguration schema if needed
-  exited_at: import_zod3.z.string().nullable(),
-  boot_progress: import_zod3.z.string().nullable(),
-  boot_error: import_zod3.z.string().nullable(),
-  shutdown_progress: import_zod3.z.string().nullable(),
-  image_version: import_zod3.z.string().nullable()
-});
-var ManagedUserSchema = import_zod3.z.object({
-  id: import_zod3.z.number(),
-  username: import_zod3.z.string()
-});
-var CvmNodeSchema = import_zod3.z.object({
-  id: import_zod3.z.number(),
-  name: import_zod3.z.string(),
-  region_identifier: import_zod3.z.string().optional()
-});
-var CvmNetworkUrlsSchema = import_zod3.z.object({
-  app: import_zod3.z.string(),
-  instance: import_zod3.z.string()
-});
-var CvmInfoSchema = import_zod3.z.object({
-  hosted: VmInfoSchema,
-  name: import_zod3.z.string(),
-  managed_user: ManagedUserSchema.optional().nullable(),
-  node: CvmNodeSchema.optional().nullable(),
-  listed: import_zod3.z.boolean().default(false),
-  status: import_zod3.z.string(),
-  in_progress: import_zod3.z.boolean().default(false),
-  dapp_dashboard_url: import_zod3.z.string().nullable(),
-  syslog_endpoint: import_zod3.z.string().nullable(),
-  allow_upgrade: import_zod3.z.boolean().default(false),
-  project_id: import_zod3.z.string().nullable(),
-  // HashedId is represented as string in JS
-  project_type: import_zod3.z.string().nullable(),
-  billing_period: import_zod3.z.string().nullable(),
-  kms_info: KmsInfoSchema.nullable(),
-  vcpu: import_zod3.z.number().nullable(),
-  memory: import_zod3.z.number().nullable(),
-  disk_size: import_zod3.z.number().nullable(),
-  gateway_domain: import_zod3.z.string().nullable(),
-  public_urls: import_zod3.z.array(CvmNetworkUrlsSchema)
-}).partial();
-var CvmLegacyDetailSchema = import_zod3.z.object({
-  id: import_zod3.z.number(),
-  name: import_zod3.z.string(),
-  status: import_zod3.z.string(),
-  in_progress: import_zod3.z.boolean(),
-  teepod_id: import_zod3.z.number().nullable(),
-  teepod: CvmNodeSchema,
-  app_id: import_zod3.z.string(),
-  vm_uuid: import_zod3.z.string().nullable(),
-  instance_id: import_zod3.z.string().nullable(),
-  vcpu: import_zod3.z.number().nullable(),
-  memory: import_zod3.z.number().nullable(),
-  disk_size: import_zod3.z.number().nullable(),
-  base_image: import_zod3.z.string(),
-  encrypted_env_pubkey: import_zod3.z.string().nullable(),
-  listed: import_zod3.z.boolean(),
-  project_id: import_zod3.z.string().nullable(),
-  project_type: import_zod3.z.string().nullable(),
-  public_sysinfo: import_zod3.z.boolean(),
-  public_logs: import_zod3.z.boolean(),
-  dapp_dashboard_url: import_zod3.z.string().nullable(),
-  syslog_endpoint: import_zod3.z.string().nullable(),
-  kms_info: KmsInfoSchema.nullable(),
-  contract_address: import_zod3.z.string().nullable(),
-  deployer_address: import_zod3.z.string().nullable(),
-  scheduled_delete_at: import_zod3.z.string().nullable(),
-  public_urls: import_zod3.z.array(CvmNetworkUrlsSchema),
-  gateway_domain: import_zod3.z.string().nullable()
-});
-
 // src/actions/get_current_user.ts
-var import_zod4 = require("zod");
+var import_zod2 = require("zod");
 
 // src/utils/validate-parameters.ts
 function validateActionParameters(parameters) {
@@ -723,14 +655,14 @@ function defineAction(schema, fn) {
 }
 
 // src/actions/get_current_user.ts
-var CurrentUserSchema = import_zod4.z.object({
-  username: import_zod4.z.string(),
-  email: import_zod4.z.string(),
-  credits: import_zod4.z.number(),
-  granted_credits: import_zod4.z.number(),
-  avatar: import_zod4.z.string(),
-  team_name: import_zod4.z.string(),
-  team_tier: import_zod4.z.string()
+var CurrentUserSchema = import_zod2.z.object({
+  username: import_zod2.z.string(),
+  email: import_zod2.z.string(),
+  credits: import_zod2.z.number(),
+  granted_credits: import_zod2.z.number(),
+  avatar: import_zod2.z.string(),
+  team_name: import_zod2.z.string(),
+  team_tier: import_zod2.z.string()
 }).passthrough();
 var { action: getCurrentUser, safeAction: safeGetCurrentUser } = defineSimpleAction(
   CurrentUserSchema,
@@ -740,44 +672,77 @@ var { action: getCurrentUser, safeAction: safeGetCurrentUser } = defineSimpleAct
 );
 
 // src/actions/get_available_nodes.ts
-var import_zod5 = require("zod");
-var AvailableOSImageSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  is_dev: import_zod5.z.boolean(),
-  version: import_zod5.z.union([
-    import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()]),
-    import_zod5.z.tuple([import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number(), import_zod5.z.number()])
+var import_zod4 = require("zod");
+
+// src/types/kms_info.ts
+var import_zod3 = require("zod");
+
+// src/types/supported_chains.ts
+var import_chains = require("viem/chains");
+var SUPPORTED_CHAINS = {
+  [import_chains.mainnet.id]: import_chains.mainnet,
+  [import_chains.base.id]: import_chains.base,
+  [import_chains.anvil.id]: import_chains.anvil
+};
+
+// src/types/kms_info.ts
+var KmsInfoBaseSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  slug: import_zod3.z.string().nullable(),
+  url: import_zod3.z.string(),
+  version: import_zod3.z.string(),
+  chain_id: import_zod3.z.number().nullable(),
+  kms_contract_address: import_zod3.z.string().nullable().transform((val) => val),
+  gateway_app_id: import_zod3.z.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 = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  is_dev: import_zod4.z.boolean(),
+  version: import_zod4.z.union([
+    import_zod4.z.tuple([import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number()]),
+    import_zod4.z.tuple([import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number(), import_zod4.z.number()])
   ]),
-  os_image_hash: import_zod5.z.string().nullable().optional()
+  os_image_hash: import_zod4.z.string().nullable().optional()
 }).passthrough();
-var TeepodCapacitySchema = import_zod5.z.object({
-  teepod_id: import_zod5.z.number(),
-  name: import_zod5.z.string(),
-  listed: import_zod5.z.boolean(),
-  resource_score: import_zod5.z.number(),
-  remaining_vcpu: import_zod5.z.number(),
-  remaining_memory: import_zod5.z.number(),
-  remaining_cvm_slots: import_zod5.z.number(),
-  images: import_zod5.z.array(AvailableOSImageSchema),
-  support_onchain_kms: import_zod5.z.boolean().optional(),
-  fmspc: import_zod5.z.string().nullable().optional(),
-  device_id: import_zod5.z.string().nullable().optional(),
-  region_identifier: import_zod5.z.string().nullable().optional(),
-  default_kms: import_zod5.z.string().nullable().optional(),
-  kms_list: import_zod5.z.array(import_zod5.z.string()).default([])
+var TeepodCapacitySchema = import_zod4.z.object({
+  teepod_id: import_zod4.z.number(),
+  name: import_zod4.z.string(),
+  listed: import_zod4.z.boolean(),
+  resource_score: import_zod4.z.number(),
+  remaining_vcpu: import_zod4.z.number(),
+  remaining_memory: import_zod4.z.number(),
+  remaining_cvm_slots: import_zod4.z.number(),
+  images: import_zod4.z.array(AvailableOSImageSchema),
+  support_onchain_kms: import_zod4.z.boolean().optional(),
+  fmspc: import_zod4.z.string().nullable().optional(),
+  device_id: import_zod4.z.string().nullable().optional(),
+  region_identifier: import_zod4.z.string().nullable().optional(),
+  default_kms: import_zod4.z.string().nullable().optional(),
+  kms_list: import_zod4.z.array(import_zod4.z.string()).default([])
 }).passthrough();
-var ResourceThresholdSchema = import_zod5.z.object({
-  max_instances: import_zod5.z.number().nullable().optional(),
-  max_vcpu: import_zod5.z.number().nullable().optional(),
-  max_memory: import_zod5.z.number().nullable().optional(),
-  max_disk: import_zod5.z.number().nullable().optional()
+var ResourceThresholdSchema = import_zod4.z.object({
+  max_instances: import_zod4.z.number().nullable().optional(),
+  max_vcpu: import_zod4.z.number().nullable().optional(),
+  max_memory: import_zod4.z.number().nullable().optional(),
+  max_disk: import_zod4.z.number().nullable().optional()
 }).passthrough();
-var AvailableNodesSchema = import_zod5.z.object({
-  tier: import_zod5.z.string(),
+var AvailableNodesSchema = import_zod4.z.object({
+  tier: import_zod4.z.string(),
   // TeamTier is string enum
   capacity: ResourceThresholdSchema,
-  nodes: import_zod5.z.array(TeepodCapacitySchema),
-  kms_list: import_zod5.z.array(KmsInfoSchema)
+  nodes: import_zod4.z.array(TeepodCapacitySchema),
+  kms_list: import_zod4.z.array(KmsInfoSchema)
 }).passthrough();
 var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
   AvailableNodesSchema,
@@ -786,19 +751,259 @@ var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSim
   }
 );
 
-// src/actions/cvms/provision_cvm.ts
+// src/actions/list-instance-types.ts
+var import_zod5 = require("zod");
+var ListInstanceTypesRequestSchema = import_zod5.z.object({
+  page: import_zod5.z.number().int().min(1).optional().default(1),
+  page_size: import_zod5.z.number().int().min(1).max(1e3).optional().default(100)
+}).strict();
+var InstanceTypeSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  name: import_zod5.z.string(),
+  description: import_zod5.z.string(),
+  vcpu: import_zod5.z.number(),
+  memory_mb: import_zod5.z.number(),
+  hourly_rate: import_zod5.z.string(),
+  requires_gpu: import_zod5.z.boolean(),
+  public: import_zod5.z.boolean(),
+  enabled: import_zod5.z.boolean()
+}).passthrough();
+var PaginatedInstanceTypesSchema = import_zod5.z.object({
+  items: import_zod5.z.array(InstanceTypeSchema),
+  total: import_zod5.z.number(),
+  page: import_zod5.z.number(),
+  page_size: import_zod5.z.number(),
+  pages: import_zod5.z.number()
+}).strict();
+var { action: listInstanceTypes, safeAction: safeListInstanceTypes } = defineAction(PaginatedInstanceTypesSchema, async (client, request) => {
+  const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
+  const queryParams = new URLSearchParams();
+  queryParams.append("page", validatedRequest.page.toString());
+  queryParams.append("page_size", validatedRequest.page_size.toString());
+  return await client.get(`/api/instance-types?${queryParams.toString()}`);
+});
+
+// src/actions/workspaces/list_workspaces.ts
 var import_zod6 = require("zod");
-var ProvisionCvmSchema = import_zod6.z.object({
-  app_id: import_zod6.z.string().nullable().optional(),
-  app_env_encrypt_pubkey: import_zod6.z.string().nullable().optional(),
-  compose_hash: import_zod6.z.string(),
-  fmspc: import_zod6.z.string().nullable().optional(),
-  device_id: import_zod6.z.string().nullable().optional(),
-  os_image_hash: import_zod6.z.string().nullable().optional(),
-  teepod_id: import_zod6.z.number().nullable().optional(),
+var WorkspaceResponseSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  slug: import_zod6.z.string().nullable(),
+  tier: import_zod6.z.string(),
+  role: import_zod6.z.string(),
+  created_at: import_zod6.z.string()
+}).passthrough();
+var PaginationMetadataSchema = import_zod6.z.object({
+  has_more: import_zod6.z.boolean(),
+  next_cursor: import_zod6.z.string().nullable(),
+  total: import_zod6.z.number().nullable()
+}).passthrough();
+var ListWorkspacesSchema = import_zod6.z.object({
+  data: import_zod6.z.array(WorkspaceResponseSchema),
+  pagination: PaginationMetadataSchema
+}).passthrough();
+var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
+  const queryParams = new URLSearchParams();
+  if (request?.cursor) queryParams.append("cursor", request.cursor);
+  if (request?.limit) queryParams.append("limit", request.limit.toString());
+  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
+  return await client.get(url);
+});
+
+// src/actions/workspaces/get_workspace.ts
+var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(WorkspaceResponseSchema, async (client, teamSlug) => {
+  return await client.get(`/workspaces/${teamSlug}`);
+});
+
+// src/types/cvm_info.ts
+var import_zod7 = require("zod");
+var VmInfoSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  status: import_zod7.z.string(),
+  uptime: import_zod7.z.string(),
+  app_url: import_zod7.z.string().nullable(),
+  app_id: import_zod7.z.string(),
+  instance_id: import_zod7.z.string().nullable(),
+  configuration: import_zod7.z.any().optional(),
+  // TODO: add VmConfiguration schema if needed
+  exited_at: import_zod7.z.string().nullable(),
+  boot_progress: import_zod7.z.string().nullable(),
+  boot_error: import_zod7.z.string().nullable(),
+  shutdown_progress: import_zod7.z.string().nullable(),
+  image_version: import_zod7.z.string().nullable()
+});
+var ManagedUserSchema = import_zod7.z.object({
+  id: import_zod7.z.number(),
+  username: import_zod7.z.string()
+});
+var CvmNodeSchema = import_zod7.z.object({
+  id: import_zod7.z.number(),
+  name: import_zod7.z.string(),
+  region_identifier: import_zod7.z.string().nullable().optional()
+});
+var CvmNetworkUrlsSchema = import_zod7.z.object({
+  app: import_zod7.z.string(),
+  instance: import_zod7.z.string()
+});
+var CvmInfoSchema = import_zod7.z.object({
+  hosted: VmInfoSchema,
+  name: import_zod7.z.string(),
+  managed_user: ManagedUserSchema.nullable(),
+  node: CvmNodeSchema.nullable(),
+  listed: import_zod7.z.boolean().default(false),
+  status: import_zod7.z.string(),
+  in_progress: import_zod7.z.boolean().default(false),
+  dapp_dashboard_url: import_zod7.z.string().nullable(),
+  syslog_endpoint: import_zod7.z.string().nullable(),
+  allow_upgrade: import_zod7.z.boolean().default(false),
+  project_id: import_zod7.z.string().nullable(),
+  // HashedId is represented as string in JS
+  project_type: import_zod7.z.string().nullable(),
+  billing_period: import_zod7.z.string().nullable(),
+  kms_info: KmsInfoSchema.nullable(),
+  vcpu: import_zod7.z.number().nullable(),
+  memory: import_zod7.z.number().nullable(),
+  disk_size: import_zod7.z.number().nullable(),
+  gateway_domain: import_zod7.z.string().nullable(),
+  public_urls: import_zod7.z.array(CvmNetworkUrlsSchema)
+});
+var CvmLegacyDetailSchema = import_zod7.z.object({
+  id: import_zod7.z.number(),
+  name: import_zod7.z.string(),
+  status: import_zod7.z.string(),
+  in_progress: import_zod7.z.boolean().optional().default(false),
+  teepod_id: import_zod7.z.number().nullable(),
+  teepod: CvmNodeSchema.optional().nullable(),
+  app_id: import_zod7.z.string(),
+  vm_uuid: import_zod7.z.string().nullable(),
+  instance_id: import_zod7.z.string().nullable(),
+  vcpu: import_zod7.z.number(),
+  memory: import_zod7.z.number(),
+  disk_size: import_zod7.z.number(),
+  base_image: import_zod7.z.string().nullable(),
+  encrypted_env_pubkey: import_zod7.z.string().nullable(),
+  listed: import_zod7.z.boolean().optional().default(false),
+  project_id: import_zod7.z.string().optional().nullable(),
+  project_type: import_zod7.z.string().optional().nullable(),
+  public_sysinfo: import_zod7.z.boolean().optional().default(false),
+  public_logs: import_zod7.z.boolean().optional().default(false),
+  dapp_dashboard_url: import_zod7.z.string().optional().nullable(),
+  syslog_endpoint: import_zod7.z.string().optional().nullable(),
+  kms_info: KmsInfoSchema.optional().nullable(),
+  contract_address: import_zod7.z.string().optional().nullable(),
+  deployer_address: import_zod7.z.string().optional().nullable(),
+  scheduled_delete_at: import_zod7.z.string().optional().nullable(),
+  public_urls: import_zod7.z.array(CvmNetworkUrlsSchema).optional().default([]),
+  gateway_domain: import_zod7.z.string().optional().nullable()
+});
+var VMSchema = import_zod7.z.object({
+  id: import_zod7.z.number(),
+  name: import_zod7.z.string(),
+  status: import_zod7.z.string(),
+  teepod_id: import_zod7.z.number(),
+  teepod: CvmNodeSchema.optional().nullable(),
+  user_id: import_zod7.z.number().optional().nullable(),
+  app_id: import_zod7.z.string(),
+  vm_uuid: import_zod7.z.string().nullable(),
+  instance_id: import_zod7.z.string().nullable(),
+  app_url: import_zod7.z.string().optional().nullable(),
+  base_image: import_zod7.z.string().nullable(),
+  vcpu: import_zod7.z.number(),
+  memory: import_zod7.z.number(),
+  disk_size: import_zod7.z.number(),
+  manifest_version: import_zod7.z.number().optional().nullable(),
+  version: import_zod7.z.string().optional().nullable(),
+  runner: import_zod7.z.string().optional().nullable(),
+  docker_compose_file: import_zod7.z.string().optional().nullable(),
+  features: import_zod7.z.array(import_zod7.z.string()).optional().nullable(),
+  created_at: import_zod7.z.string(),
+  // datetime serialized as ISO string
+  encrypted_env_pubkey: import_zod7.z.string().nullable()
+});
+
+// src/types/cvm_id.ts
+var import_zod8 = require("zod");
+var CvmIdObjectSchema = import_zod8.z.object({
+  /** Direct CVM ID (any format) */
+  id: import_zod8.z.string().optional(),
+  /** UUID format (with or without dashes) */
+  uuid: import_zod8.z.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: import_zod8.z.string().optional(),
+  /** Instance ID (40 characters, optionally prefixed with 'instance_') */
+  instance_id: import_zod8.z.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 { cvmId } = GetCvmInfoRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}`);
+});
+
+// src/actions/cvms/get_cvm_list.ts
+var import_zod9 = require("zod");
+var GetCvmListRequestSchema = import_zod9.z.object({
+  page: import_zod9.z.number().int().min(1).optional(),
+  page_size: import_zod9.z.number().int().min(1).optional(),
+  node_id: import_zod9.z.number().int().min(1).optional(),
+  teepod_id: import_zod9.z.number().int().min(1).optional(),
+  user_id: import_zod9.z.string().optional()
+}).strict();
+var GetCvmListSchema = import_zod9.z.object({
+  items: import_zod9.z.array(CvmInfoSchema),
+  total: import_zod9.z.number(),
+  page: import_zod9.z.number(),
+  page_size: import_zod9.z.number(),
+  pages: import_zod9.z.number()
+}).strict();
+var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
+  const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
+  return await client.get("/cvms/paginated", { params: validatedRequest });
+});
+
+// src/actions/cvms/provision_cvm.ts
+var import_zod10 = require("zod");
+var ProvisionCvmSchema = import_zod10.z.object({
+  app_id: import_zod10.z.string().nullable().optional(),
+  app_env_encrypt_pubkey: import_zod10.z.string().nullable().optional(),
+  compose_hash: import_zod10.z.string(),
+  fmspc: import_zod10.z.string().nullable().optional(),
+  device_id: import_zod10.z.string().nullable().optional(),
+  os_image_hash: import_zod10.z.string().nullable().optional(),
+  teepod_id: import_zod10.z.number().nullable().optional(),
   // Will be transformed to node_id
-  node_id: import_zod6.z.number().nullable().optional(),
-  kms_id: import_zod6.z.string().nullable().optional()
+  node_id: import_zod10.z.number().nullable().optional(),
+  kms_id: import_zod10.z.string().nullable().optional()
 }).passthrough().transform((data) => {
   if ("teepod_id" in data && data.teepod_id !== void 0) {
     const { teepod_id, ...rest } = data;
@@ -806,33 +1011,33 @@ var ProvisionCvmSchema = import_zod6.z.object({
   }
   return data;
 });
-var ProvisionCvmRequestSchema = import_zod6.z.object({
-  node_id: import_zod6.z.number().optional(),
+var ProvisionCvmRequestSchema = import_zod10.z.object({
+  node_id: import_zod10.z.number().optional(),
   // recommended
-  teepod_id: import_zod6.z.number().optional(),
+  teepod_id: import_zod10.z.number().optional(),
   // deprecated, for compatibility
-  name: import_zod6.z.string(),
-  image: import_zod6.z.string(),
-  vcpu: import_zod6.z.number(),
-  memory: import_zod6.z.number(),
-  disk_size: import_zod6.z.number(),
-  compose_file: import_zod6.z.object({
-    allowed_envs: import_zod6.z.array(import_zod6.z.string()).optional(),
-    pre_launch_script: import_zod6.z.string().optional(),
-    docker_compose_file: import_zod6.z.string().optional(),
-    name: import_zod6.z.string().optional(),
-    kms_enabled: import_zod6.z.boolean().optional(),
-    public_logs: import_zod6.z.boolean().optional(),
-    public_sysinfo: import_zod6.z.boolean().optional(),
-    gateway_enabled: import_zod6.z.boolean().optional(),
+  name: import_zod10.z.string(),
+  image: import_zod10.z.string(),
+  vcpu: import_zod10.z.number(),
+  memory: import_zod10.z.number(),
+  disk_size: import_zod10.z.number(),
+  compose_file: import_zod10.z.object({
+    allowed_envs: import_zod10.z.array(import_zod10.z.string()).optional(),
+    pre_launch_script: import_zod10.z.string().optional(),
+    docker_compose_file: import_zod10.z.string().optional(),
+    name: import_zod10.z.string().optional(),
+    kms_enabled: import_zod10.z.boolean().optional(),
+    public_logs: import_zod10.z.boolean().optional(),
+    public_sysinfo: import_zod10.z.boolean().optional(),
+    gateway_enabled: import_zod10.z.boolean().optional(),
     // recommended
-    tproxy_enabled: import_zod6.z.boolean().optional()
+    tproxy_enabled: import_zod10.z.boolean().optional()
     // deprecated, for compatibility
   }),
-  listed: import_zod6.z.boolean().optional(),
-  instance_type: import_zod6.z.string().nullable().optional(),
-  kms_id: import_zod6.z.string().optional(),
-  env_keys: import_zod6.z.array(import_zod6.z.string()).optional()
+  listed: import_zod10.z.boolean().optional(),
+  instance_type: import_zod10.z.string().nullable().optional(),
+  kms_id: import_zod10.z.string().optional(),
+  env_keys: import_zod10.z.array(import_zod10.z.string()).optional()
 }).passthrough();
 function autofillComposeFileName(appCompose) {
   if (appCompose.compose_file && !appCompose.compose_file.name) {
@@ -876,54 +1081,515 @@ var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(Provis
   } else if (typeof body.teepod_id === "number") {
     console.warn("[phala/cloud] teepod_id is deprecated, please use node_id instead.");
   }
-  return await client.post("/cvms/provision", requestBody);
+  return await client.post("/cvms/provision", requestBody);
+});
+
+// src/actions/cvms/commit_cvm_provision.ts
+var import_zod11 = require("zod");
+var CommitCvmProvisionSchema = import_zod11.z.object({
+  id: import_zod11.z.number(),
+  name: import_zod11.z.string(),
+  status: import_zod11.z.string(),
+  teepod_id: import_zod11.z.number(),
+  teepod: import_zod11.z.object({
+    id: import_zod11.z.number(),
+    name: import_zod11.z.string()
+  }).nullable(),
+  user_id: import_zod11.z.number().nullable(),
+  app_id: import_zod11.z.string().nullable(),
+  vm_uuid: import_zod11.z.string().nullable(),
+  instance_id: import_zod11.z.string().nullable(),
+  app_url: import_zod11.z.string().nullable(),
+  base_image: import_zod11.z.string().nullable(),
+  vcpu: import_zod11.z.number(),
+  memory: import_zod11.z.number(),
+  disk_size: import_zod11.z.number(),
+  manifest_version: import_zod11.z.number().nullable(),
+  version: import_zod11.z.string().nullable(),
+  runner: import_zod11.z.string().nullable(),
+  docker_compose_file: import_zod11.z.string().nullable(),
+  features: import_zod11.z.array(import_zod11.z.string()).nullable(),
+  created_at: import_zod11.z.string(),
+  encrypted_env_pubkey: import_zod11.z.string().nullable().optional(),
+  app_auth_contract_address: import_zod11.z.string().nullable().optional(),
+  deployer_address: import_zod11.z.string().nullable().optional()
+}).passthrough();
+var CommitCvmProvisionRequestSchema = import_zod11.z.object({
+  encrypted_env: import_zod11.z.string().optional().nullable(),
+  app_id: import_zod11.z.string(),
+  compose_hash: import_zod11.z.string().optional(),
+  kms_id: import_zod11.z.string().optional(),
+  contract_address: import_zod11.z.string().optional(),
+  deployer_address: import_zod11.z.string().optional(),
+  env_keys: import_zod11.z.array(import_zod11.z.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
+var import_zod12 = require("zod");
+var LooseAppComposeSchema = import_zod12.z.object({
+  allowed_envs: import_zod12.z.array(import_zod12.z.string()).optional(),
+  docker_compose_file: import_zod12.z.string(),
+  features: import_zod12.z.array(import_zod12.z.string()).optional(),
+  name: import_zod12.z.string().optional(),
+  manifest_version: import_zod12.z.number().optional(),
+  kms_enabled: import_zod12.z.boolean().optional(),
+  public_logs: import_zod12.z.boolean().optional(),
+  public_sysinfo: import_zod12.z.boolean().optional(),
+  tproxy_enabled: import_zod12.z.boolean().optional(),
+  pre_launch_script: import_zod12.z.string().optional(),
+  env_pubkey: import_zod12.z.string().optional(),
+  salt: import_zod12.z.string().optional().nullable()
+}).passthrough();
+
+// src/actions/cvms/get_cvm_compose_file.ts
+var GetCvmComposeFileRequestSchema = CvmIdSchema;
+var { action: getCvmComposeFile, safeAction: safeGetCvmComposeFile } = defineAction(LooseAppComposeSchema, 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
+var import_zod13 = require("zod");
+var ProvisionCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
+  id: import_zod13.z.string().optional(),
+  uuid: import_zod13.z.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: import_zod13.z.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: import_zod13.z.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: import_zod13.z.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"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  request: data.app_compose,
+  update_env_vars: data.update_env_vars,
+  _raw: data
+}));
+var ProvisionCvmComposeFileUpdateResultSchema = import_zod13.z.object({
+  app_id: import_zod13.z.string().nullable(),
+  device_id: import_zod13.z.string().nullable(),
+  compose_hash: import_zod13.z.string(),
+  kms_info: KmsInfoSchema.nullable().optional()
+}).passthrough();
+var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
+  const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
+  return await client.post(
+    `/cvms/${validatedRequest.cvmId}/compose_file/provision`,
+    validatedRequest.request
+  );
+});
+
+// src/actions/cvms/commit_cvm_compose_file_update.ts
+var import_zod14 = require("zod");
+var CommitCvmComposeFileUpdateRequestSchema = import_zod14.z.object({
+  id: import_zod14.z.string().optional(),
+  uuid: import_zod14.z.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: import_zod14.z.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: import_zod14.z.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: import_zod14.z.string().min(1, "Compose hash is required"),
+  encrypted_env: import_zod14.z.string().optional(),
+  env_keys: import_zod14.z.array(import_zod14.z.string()).optional(),
+  update_env_vars: import_zod14.z.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"
+).transform((data) => ({
+  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
+  compose_hash: data.compose_hash,
+  encrypted_env: data.encrypted_env,
+  env_keys: data.env_keys,
+  update_env_vars: !!data.update_env_vars,
+  _raw: data
+}));
+var CommitCvmComposeFileUpdateSchema = import_zod14.z.any().transform(() => void 0);
+var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
+  CommitCvmComposeFileUpdateSchema,
+  async (client, request) => {
+    const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
+    return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
+      compose_hash: validatedRequest.compose_hash,
+      encrypted_env: validatedRequest.encrypted_env,
+      env_keys: validatedRequest.env_keys
+    });
+  }
+);
+
+// src/actions/kms/get_kms_info.ts
+var import_zod15 = require("zod");
+var GetKmsInfoRequestSchema = import_zod15.z.object({
+  kms_id: import_zod15.z.string().min(1, "KMS ID is required")
+});
+var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
+  const validatedRequest = GetKmsInfoRequestSchema.parse(request);
+  return await client.get(`/kms/${validatedRequest.kms_id}`);
+});
+
+// src/actions/kms/get_kms_list.ts
+var import_zod16 = require("zod");
+var GetKmsListRequestSchema = import_zod16.z.object({
+  page: import_zod16.z.number().int().min(1).optional(),
+  page_size: import_zod16.z.number().int().min(1).optional(),
+  is_onchain: import_zod16.z.boolean().optional()
+}).strict();
+var GetKmsListSchema = import_zod16.z.object({
+  items: import_zod16.z.array(KmsInfoSchema),
+  total: import_zod16.z.number(),
+  page: import_zod16.z.number(),
+  page_size: import_zod16.z.number(),
+  pages: import_zod16.z.number()
+}).strict();
+var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
+  const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
+  return await client.get("/kms", { params: validatedRequest });
+});
+
+// src/actions/kms/get_app_env_encrypt_pubkey.ts
+var import_zod17 = require("zod");
+var GetAppEnvEncryptPubKeyRequestSchema = import_zod17.z.object({
+  kms: import_zod17.z.string().min(1, "KMS ID or slug is required"),
+  app_id: import_zod17.z.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 = import_zod17.z.object({
+  public_key: import_zod17.z.string(),
+  signature: import_zod17.z.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/commit_cvm_provision.ts
-var import_zod7 = require("zod");
-var CommitCvmProvisionSchema = import_zod7.z.object({
-  id: import_zod7.z.number(),
-  name: import_zod7.z.string(),
-  status: import_zod7.z.string(),
-  teepod_id: import_zod7.z.number(),
-  teepod: import_zod7.z.object({
-    id: import_zod7.z.number(),
-    name: import_zod7.z.string()
-  }).nullable(),
-  user_id: import_zod7.z.number().nullable(),
-  app_id: import_zod7.z.string().nullable(),
-  vm_uuid: import_zod7.z.string().nullable(),
-  instance_id: import_zod7.z.string().nullable(),
-  app_url: import_zod7.z.string().nullable(),
-  base_image: import_zod7.z.string().nullable(),
-  vcpu: import_zod7.z.number(),
-  memory: import_zod7.z.number(),
-  disk_size: import_zod7.z.number(),
-  manifest_version: import_zod7.z.number().nullable(),
-  version: import_zod7.z.string().nullable(),
-  runner: import_zod7.z.string().nullable(),
-  docker_compose_file: import_zod7.z.string().nullable(),
-  features: import_zod7.z.array(import_zod7.z.string()).nullable(),
-  created_at: import_zod7.z.string(),
-  encrypted_env_pubkey: import_zod7.z.string().nullable().optional(),
-  app_auth_contract_address: import_zod7.z.string().nullable().optional(),
-  deployer_address: import_zod7.z.string().nullable().optional()
-}).passthrough();
-var CommitCvmProvisionRequestSchema = import_zod7.z.object({
-  encrypted_env: import_zod7.z.string().optional().nullable(),
-  app_id: import_zod7.z.string(),
-  compose_hash: import_zod7.z.string().optional(),
-  kms_id: import_zod7.z.string().optional(),
-  contract_address: import_zod7.z.string().optional(),
-  deployer_address: import_zod7.z.string().optional(),
-  env_keys: import_zod7.z.array(import_zod7.z.string()).optional().nullable()
-}).passthrough();
-var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
-  return await client.post("/cvms", payload);
+// src/actions/cvms/restart_cvm.ts
+var import_zod18 = require("zod");
+var RestartCvmRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    force: import_zod18.z.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
+var import_zod19 = require("zod");
+var DeleteCvmRequestSchema = CvmIdSchema;
+var { action: deleteCvm, safeAction: safeDeleteCvm } = defineAction(
+  import_zod19.z.void(),
+  async (client, request) => {
+    const { cvmId } = DeleteCvmRequestSchema.parse(request);
+    await client.delete(`/cvms/${cvmId}`);
+    return void 0;
+  }
+);
+
+// src/actions/cvms/get_cvm_stats.ts
+var import_zod20 = require("zod");
+var DiskInfoSchema = import_zod20.z.object({
+  name: import_zod20.z.string(),
+  mount_point: import_zod20.z.string(),
+  total_size: import_zod20.z.number(),
+  free_size: import_zod20.z.number()
+});
+var SystemInfoSchema = import_zod20.z.object({
+  os_name: import_zod20.z.string(),
+  os_version: import_zod20.z.string(),
+  kernel_version: import_zod20.z.string(),
+  cpu_model: import_zod20.z.string(),
+  num_cpus: import_zod20.z.number(),
+  total_memory: import_zod20.z.number(),
+  available_memory: import_zod20.z.number(),
+  used_memory: import_zod20.z.number(),
+  free_memory: import_zod20.z.number(),
+  total_swap: import_zod20.z.number(),
+  used_swap: import_zod20.z.number(),
+  free_swap: import_zod20.z.number(),
+  uptime: import_zod20.z.number(),
+  loadavg_one: import_zod20.z.number(),
+  loadavg_five: import_zod20.z.number(),
+  loadavg_fifteen: import_zod20.z.number(),
+  disks: import_zod20.z.array(DiskInfoSchema)
+});
+var CvmSystemInfoSchema = import_zod20.z.object({
+  is_online: import_zod20.z.boolean(),
+  is_public: import_zod20.z.boolean().default(false),
+  error: import_zod20.z.string().nullable(),
+  sysinfo: SystemInfoSchema.nullable(),
+  status: import_zod20.z.string().nullable(),
+  in_progress: import_zod20.z.boolean().default(false),
+  boot_progress: import_zod20.z.string().nullable(),
+  boot_error: import_zod20.z.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
+var import_zod21 = require("zod");
+var CvmNetworkUrlsSchema2 = import_zod21.z.object({
+  app: import_zod21.z.string(),
+  instance: import_zod21.z.string()
+});
+var CvmNetworkSchema = import_zod21.z.object({
+  is_online: import_zod21.z.boolean(),
+  is_public: import_zod21.z.boolean().default(true),
+  error: import_zod21.z.string().nullable(),
+  internal_ip: import_zod21.z.string().nullable(),
+  latest_handshake: import_zod21.z.string().nullable(),
+  public_urls: import_zod21.z.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
+var import_zod22 = require("zod");
+var GetCvmDockerComposeRequestSchema = CvmIdSchema;
+var { action: getCvmDockerCompose, safeAction: safeGetCvmDockerCompose } = defineAction(import_zod22.z.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
+var import_zod23 = require("zod");
+var ContainerInfoSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  names: import_zod23.z.array(import_zod23.z.string()),
+  image: import_zod23.z.string(),
+  image_id: import_zod23.z.string(),
+  command: import_zod23.z.string().nullable().optional(),
+  created: import_zod23.z.number(),
+  state: import_zod23.z.string(),
+  status: import_zod23.z.string(),
+  log_endpoint: import_zod23.z.string().nullable()
+});
+var CvmContainersStatsSchema = import_zod23.z.object({
+  is_online: import_zod23.z.boolean(),
+  is_public: import_zod23.z.boolean().default(true),
+  error: import_zod23.z.string().nullable(),
+  docker_compose_file: import_zod23.z.string().nullable(),
+  manifest_version: import_zod23.z.number().nullable(),
+  version: import_zod23.z.string().nullable(),
+  runner: import_zod23.z.string().nullable(),
+  features: import_zod23.z.array(import_zod23.z.string()).nullable(),
+  containers: import_zod23.z.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
+var import_zod24 = require("zod");
+var CertificateSubjectSchema = import_zod24.z.object({
+  common_name: import_zod24.z.string().nullable(),
+  organization: import_zod24.z.string().nullable(),
+  country: import_zod24.z.string().nullable(),
+  state: import_zod24.z.string().nullable(),
+  locality: import_zod24.z.string().nullable()
+});
+var CertificateIssuerSchema = import_zod24.z.object({
+  common_name: import_zod24.z.string().nullable(),
+  organization: import_zod24.z.string().nullable(),
+  country: import_zod24.z.string().nullable()
+});
+var CertificateSchema = import_zod24.z.object({
+  subject: CertificateSubjectSchema,
+  issuer: CertificateIssuerSchema,
+  serial_number: import_zod24.z.string(),
+  not_before: import_zod24.z.string(),
+  // datetime serialized as ISO string
+  not_after: import_zod24.z.string(),
+  // datetime serialized as ISO string
+  version: import_zod24.z.string(),
+  fingerprint: import_zod24.z.string(),
+  signature_algorithm: import_zod24.z.string(),
+  sans: import_zod24.z.array(import_zod24.z.string()).nullable(),
+  is_ca: import_zod24.z.boolean(),
+  position_in_chain: import_zod24.z.number().nullable(),
+  quote: import_zod24.z.string().nullable(),
+  app_id: import_zod24.z.string().nullable().optional(),
+  cert_usage: import_zod24.z.string().nullable().optional()
+});
+var EventLogSchema = import_zod24.z.object({
+  imr: import_zod24.z.number(),
+  event_type: import_zod24.z.number(),
+  digest: import_zod24.z.string(),
+  event: import_zod24.z.string(),
+  event_payload: import_zod24.z.string()
+});
+var TcbInfoSchema = import_zod24.z.object({
+  mrtd: import_zod24.z.string(),
+  rootfs_hash: import_zod24.z.string().nullable().optional(),
+  rtmr0: import_zod24.z.string(),
+  rtmr1: import_zod24.z.string(),
+  rtmr2: import_zod24.z.string(),
+  rtmr3: import_zod24.z.string(),
+  event_log: import_zod24.z.array(EventLogSchema),
+  app_compose: import_zod24.z.string()
+});
+var CvmAttestationSchema = import_zod24.z.object({
+  name: import_zod24.z.string().nullable(),
+  is_online: import_zod24.z.boolean(),
+  is_public: import_zod24.z.boolean().default(true),
+  error: import_zod24.z.string().nullable(),
+  app_certificates: import_zod24.z.array(CertificateSchema).nullable(),
+  tcb_info: TcbInfoSchema.nullable(),
+  compose_file: import_zod24.z.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
+var import_zod25 = require("zod");
+var UpdateCvmResourcesRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    vcpu: import_zod25.z.number().optional(),
+    memory: import_zod25.z.number().optional(),
+    disk_size: import_zod25.z.number().optional(),
+    instance_type: import_zod25.z.string().optional(),
+    allow_restart: import_zod25.z.boolean().optional()
+  })
+);
+var { action: updateCvmResources, safeAction: safeUpdateCvmResources } = defineAction(import_zod25.z.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
+var import_zod26 = require("zod");
+var UpdateCvmVisibilityRequestSchema = refineCvmId(
+  CvmIdObjectSchema.extend({
+    public_sysinfo: import_zod26.z.boolean(),
+    public_logs: import_zod26.z.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);
+  const allActions = {
+    getCurrentUser,
+    safeGetCurrentUser,
+    getAvailableNodes,
+    safeGetAvailableNodes,
+    listInstanceTypes,
+    safeListInstanceTypes,
+    listWorkspaces,
+    safeListWorkspaces,
+    getWorkspace,
+    safeGetWorkspace,
+    getCvmInfo,
+    safeGetCvmInfo,
+    getCvmList,
+    safeGetCvmList,
+    provisionCvm,
+    safeProvisionCvm,
+    commitCvmProvision,
+    safeCommitCvmProvision,
+    getCvmComposeFile,
+    safeGetCvmComposeFile,
+    provisionCvmComposeFileUpdate,
+    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,
+    safeGetKmsList,
+    getAppEnvEncryptPubKey,
+    safeGetAppEnvEncryptPubKey
+  };
+  return client.extend(allActions);
+}
+
 // src/actions/blockchains/deploy_app_auth.ts
-var import_zod8 = require("zod");
+var import_zod27 = require("zod");
 var import_viem3 = require("viem");
 var import_accounts2 = require("viem/accounts");
 
@@ -1590,25 +2256,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = import_zod8.z.object({
+var DeployAppAuthRequestBaseSchema = import_zod27.z.object({
   // Chain configuration (conditionally required)
-  chain: import_zod8.z.unknown().optional(),
-  rpcUrl: import_zod8.z.string().optional(),
+  chain: import_zod27.z.unknown().optional(),
+  rpcUrl: import_zod27.z.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: import_zod8.z.string(),
+  kmsContractAddress: import_zod27.z.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: import_zod8.z.string().optional(),
-  walletClient: import_zod8.z.unknown().optional(),
+  privateKey: import_zod27.z.string().optional(),
+  walletClient: import_zod27.z.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: import_zod8.z.unknown().optional(),
+  publicClient: import_zod27.z.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: import_zod8.z.boolean().optional().default(false),
-  deviceId: import_zod8.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: import_zod8.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: import_zod8.z.boolean().optional().default(false),
+  allowAnyDevice: import_zod27.z.boolean().optional().default(false),
+  deviceId: import_zod27.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  composeHash: import_zod27.z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
+  disableUpgrades: import_zod27.z.boolean().optional().default(false),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: import_zod8.z.boolean().optional().default(false),
-  minBalance: import_zod8.z.string().optional()
+  skipPrerequisiteChecks: import_zod27.z.boolean().optional().default(false),
+  minBalance: import_zod27.z.string().optional()
   // ETH amount as string, e.g., "0.01"
 }).passthrough();
 var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
@@ -1636,13 +2302,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = import_zod8.z.object({
-  appId: import_zod8.z.string(),
-  appAuthAddress: import_zod8.z.string(),
-  deployer: import_zod8.z.string(),
-  transactionHash: import_zod8.z.string(),
-  blockNumber: import_zod8.z.bigint().optional(),
-  gasUsed: import_zod8.z.bigint().optional()
+var DeployAppAuthSchema = import_zod27.z.object({
+  appId: import_zod27.z.string(),
+  appAuthAddress: import_zod27.z.string(),
+  deployer: import_zod27.z.string(),
+  transactionHash: import_zod27.z.string(),
+  blockNumber: import_zod27.z.bigint().optional(),
+  gasUsed: import_zod27.z.bigint().optional()
 }).passthrough();
 function parseDeploymentResult(receipt, deployer, kmsContractAddress) {
   try {
@@ -1888,7 +2554,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-var import_zod9 = require("zod");
+var import_zod28 = require("zod");
 var import_viem4 = require("viem");
 var import_accounts3 = require("viem/accounts");
 var appAuthAbi = [
@@ -1906,29 +2572,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = import_zod9.z.object({
+var AddComposeHashRequestSchema = import_zod28.z.object({
   // Chain configuration (conditionally required)
-  chain: import_zod9.z.unknown().optional(),
-  rpcUrl: import_zod9.z.string().optional(),
-  appId: import_zod9.z.string(),
-  composeHash: import_zod9.z.string(),
+  chain: import_zod28.z.unknown().optional(),
+  rpcUrl: import_zod28.z.string().optional(),
+  appId: import_zod28.z.string(),
+  composeHash: import_zod28.z.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: import_zod9.z.string().optional(),
-  walletClient: import_zod9.z.unknown().optional(),
+  privateKey: import_zod28.z.string().optional(),
+  walletClient: import_zod28.z.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: import_zod9.z.unknown().optional(),
+  publicClient: import_zod28.z.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: import_zod9.z.boolean().optional().default(false),
-  minBalance: import_zod9.z.string().optional(),
+  skipPrerequisiteChecks: import_zod28.z.boolean().optional().default(false),
+  minBalance: import_zod28.z.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: import_zod9.z.number().optional().default(12e4),
-  retryOptions: import_zod9.z.unknown().optional(),
-  signal: import_zod9.z.unknown().optional(),
+  timeout: import_zod28.z.number().optional().default(12e4),
+  retryOptions: import_zod28.z.unknown().optional(),
+  signal: import_zod28.z.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: import_zod9.z.function().optional(),
-  onTransactionSubmitted: import_zod9.z.function().optional(),
-  onTransactionConfirmed: import_zod9.z.function().optional()
+  onTransactionStateChange: import_zod28.z.function().optional(),
+  onTransactionSubmitted: import_zod28.z.function().optional(),
+  onTransactionConfirmed: import_zod28.z.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -1952,12 +2618,12 @@ var AddComposeHashRequestSchema = import_zod9.z.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = import_zod9.z.object({
-  composeHash: import_zod9.z.string(),
-  appId: import_zod9.z.string(),
-  transactionHash: import_zod9.z.string(),
-  blockNumber: import_zod9.z.bigint().optional(),
-  gasUsed: import_zod9.z.bigint().optional()
+var AddComposeHashSchema = import_zod28.z.object({
+  composeHash: import_zod28.z.string(),
+  appId: import_zod28.z.string(),
+  transactionHash: import_zod28.z.string(),
+  blockNumber: import_zod28.z.bigint().optional(),
+  gasUsed: import_zod28.z.bigint().optional()
 }).passthrough();
 function parseComposeHashResult(receipt, composeHash, appAuthAddress, appId) {
   console.log(receipt.logs);
@@ -2148,282 +2814,6 @@ async function safeAddComposeHash(request, parameters) {
   }
 }
 
-// src/actions/cvms/get_cvm_compose_file.ts
-var import_zod11 = require("zod");
-
-// src/types/app_compose.ts
-var import_zod10 = require("zod");
-var LooseAppComposeSchema = import_zod10.z.object({
-  allowed_envs: import_zod10.z.array(import_zod10.z.string()).optional(),
-  docker_compose_file: import_zod10.z.string(),
-  features: import_zod10.z.array(import_zod10.z.string()).optional(),
-  name: import_zod10.z.string().optional(),
-  manifest_version: import_zod10.z.number().optional(),
-  kms_enabled: import_zod10.z.boolean().optional(),
-  public_logs: import_zod10.z.boolean().optional(),
-  public_sysinfo: import_zod10.z.boolean().optional(),
-  tproxy_enabled: import_zod10.z.boolean().optional(),
-  pre_launch_script: import_zod10.z.string().optional()
-}).passthrough();
-
-// src/actions/cvms/get_cvm_compose_file.ts
-var GetCvmComposeFileRequestSchema = import_zod11.z.object({
-  id: import_zod11.z.string().optional(),
-  uuid: import_zod11.z.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: import_zod11.z.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: import_zod11.z.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
-var import_zod12 = require("zod");
-var ProvisionCvmComposeFileUpdateRequestSchema = import_zod12.z.object({
-  id: import_zod12.z.string().optional(),
-  uuid: import_zod12.z.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: import_zod12.z.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: import_zod12.z.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: import_zod12.z.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"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  request: data.app_compose,
-  update_env_vars: data.update_env_vars,
-  _raw: data
-}));
-var ProvisionCvmComposeFileUpdateResultSchema = import_zod12.z.object({
-  app_id: import_zod12.z.string().nullable(),
-  device_id: import_zod12.z.string().nullable(),
-  compose_hash: import_zod12.z.string(),
-  kms_info: KmsInfoSchema.nullable().optional()
-}).passthrough();
-var { action: provisionCvmComposeFileUpdate, safeAction: safeProvisionCvmComposeFileUpdate } = defineAction(ProvisionCvmComposeFileUpdateResultSchema, async (client, request) => {
-  const validatedRequest = ProvisionCvmComposeFileUpdateRequestSchema.parse(request);
-  return await client.post(
-    `/cvms/${validatedRequest.cvmId}/compose_file/provision`,
-    validatedRequest.request
-  );
-});
-
-// src/actions/cvms/commit_cvm_compose_file_update.ts
-var import_zod13 = require("zod");
-var CommitCvmComposeFileUpdateRequestSchema = import_zod13.z.object({
-  id: import_zod13.z.string().optional(),
-  uuid: import_zod13.z.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: import_zod13.z.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: import_zod13.z.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: import_zod13.z.string().min(1, "Compose hash is required"),
-  encrypted_env: import_zod13.z.string().optional(),
-  env_keys: import_zod13.z.array(import_zod13.z.string()).optional(),
-  update_env_vars: import_zod13.z.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"
-).transform((data) => ({
-  cvmId: data.id || data.uuid || data.app_id || data.instance_id,
-  compose_hash: data.compose_hash,
-  encrypted_env: data.encrypted_env,
-  env_keys: data.env_keys,
-  update_env_vars: !!data.update_env_vars,
-  _raw: data
-}));
-var CommitCvmComposeFileUpdateSchema = import_zod13.z.any().transform(() => void 0);
-var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
-  CommitCvmComposeFileUpdateSchema,
-  async (client, request) => {
-    const validatedRequest = CommitCvmComposeFileUpdateRequestSchema.parse(request);
-    return await client.patch(`/cvms/${validatedRequest.cvmId}/compose_file`, {
-      compose_hash: validatedRequest.compose_hash,
-      encrypted_env: validatedRequest.encrypted_env,
-      env_keys: validatedRequest.env_keys
-    });
-  }
-);
-
-// src/actions/kms/get_app_env_encrypt_pubkey.ts
-var import_zod14 = require("zod");
-var GetAppEnvEncryptPubKeyRequestSchema = import_zod14.z.object({
-  kms: import_zod14.z.string().min(1, "KMS ID or slug is required"),
-  app_id: import_zod14.z.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 = import_zod14.z.object({
-  public_key: import_zod14.z.string(),
-  signature: import_zod14.z.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/get_cvm_info.ts
-var import_zod15 = require("zod");
-var GetCvmInfoRequestSchema = import_zod15.z.object({
-  id: import_zod15.z.string().optional(),
-  uuid: import_zod15.z.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: import_zod15.z.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: import_zod15.z.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: getCvmInfo, safeAction: safeGetCvmInfo } = defineAction(CvmLegacyDetailSchema, async (client, request) => {
-  const validatedRequest = GetCvmInfoRequestSchema.parse(request);
-  return await client.get(`/cvms/${validatedRequest.cvmId}`);
-});
-
-// src/actions/cvms/get_cvm_list.ts
-var import_zod16 = require("zod");
-var GetCvmListRequestSchema = import_zod16.z.object({
-  page: import_zod16.z.number().int().min(1).optional(),
-  page_size: import_zod16.z.number().int().min(1).optional(),
-  node_id: import_zod16.z.number().int().min(1).optional()
-}).strict();
-var GetCvmListSchema = import_zod16.z.object({
-  items: import_zod16.z.array(CvmInfoSchema),
-  total: import_zod16.z.number(),
-  page: import_zod16.z.number(),
-  page_size: import_zod16.z.number(),
-  pages: import_zod16.z.number()
-}).strict();
-var { action: getCvmList, safeAction: safeGetCvmList } = defineAction(GetCvmListSchema, async (client, request) => {
-  const validatedRequest = GetCvmListRequestSchema.parse(request ?? {});
-  return await client.get("/cvms/paginated", { params: validatedRequest });
-});
-
-// src/actions/kms/get_kms_info.ts
-var import_zod17 = require("zod");
-var GetKmsInfoRequestSchema = import_zod17.z.object({
-  kms_id: import_zod17.z.string().min(1, "KMS ID is required")
-});
-var { action: getKmsInfo, safeAction: safeGetKmsInfo } = defineAction(KmsInfoSchema, async (client, request) => {
-  const validatedRequest = GetKmsInfoRequestSchema.parse(request);
-  return await client.get(`/kms/${validatedRequest.kms_id}`);
-});
-
-// src/actions/kms/get_kms_list.ts
-var import_zod18 = require("zod");
-var GetKmsListRequestSchema = import_zod18.z.object({
-  page: import_zod18.z.number().int().min(1).optional(),
-  page_size: import_zod18.z.number().int().min(1).optional(),
-  is_onchain: import_zod18.z.boolean().optional()
-}).strict();
-var GetKmsListSchema = import_zod18.z.object({
-  items: import_zod18.z.array(KmsInfoSchema),
-  total: import_zod18.z.number(),
-  page: import_zod18.z.number(),
-  page_size: import_zod18.z.number(),
-  pages: import_zod18.z.number()
-}).strict();
-var { action: getKmsList, safeAction: safeGetKmsList } = defineAction(GetKmsListSchema, async (client, request) => {
-  const validatedRequest = GetKmsListRequestSchema.parse(request ?? {});
-  return await client.get("/kms", { params: validatedRequest });
-});
-
-// src/actions/workspaces/list_workspaces.ts
-var import_zod19 = require("zod");
-var WorkspaceResponseSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  name: import_zod19.z.string(),
-  slug: import_zod19.z.string().nullable(),
-  tier: import_zod19.z.string(),
-  role: import_zod19.z.string(),
-  created_at: import_zod19.z.string()
-}).passthrough();
-var PaginationMetadataSchema = import_zod19.z.object({
-  has_more: import_zod19.z.boolean(),
-  next_cursor: import_zod19.z.string().nullable(),
-  total: import_zod19.z.number().nullable()
-}).passthrough();
-var ListWorkspacesSchema = import_zod19.z.object({
-  data: import_zod19.z.array(WorkspaceResponseSchema),
-  pagination: PaginationMetadataSchema
-}).passthrough();
-var { action: listWorkspaces, safeAction: safeListWorkspaces } = defineAction(ListWorkspacesSchema, async (client, request) => {
-  const queryParams = new URLSearchParams();
-  if (request?.cursor) queryParams.append("cursor", request.cursor);
-  if (request?.limit) queryParams.append("limit", request.limit.toString());
-  const url = queryParams.toString() ? `/workspaces?${queryParams.toString()}` : "/workspaces";
-  return await client.get(url);
-});
-
-// src/actions/workspaces/get_workspace.ts
-var { action: getWorkspace, safeAction: safeGetWorkspace } = defineAction(WorkspaceResponseSchema, async (client, teamSlug) => {
-  return await client.get(`/workspaces/${teamSlug}`);
-});
-
-// src/actions/list-instance-types.ts
-var import_zod20 = require("zod");
-var ListInstanceTypesRequestSchema = import_zod20.z.object({
-  page: import_zod20.z.number().int().min(1).optional().default(1),
-  page_size: import_zod20.z.number().int().min(1).max(1e3).optional().default(100)
-}).strict();
-var InstanceTypeSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  name: import_zod20.z.string(),
-  description: import_zod20.z.string(),
-  vcpu: import_zod20.z.number(),
-  memory_mb: import_zod20.z.number(),
-  hourly_rate: import_zod20.z.string(),
-  requires_gpu: import_zod20.z.boolean(),
-  public: import_zod20.z.boolean(),
-  enabled: import_zod20.z.boolean()
-}).passthrough();
-var PaginatedInstanceTypesSchema = import_zod20.z.object({
-  items: import_zod20.z.array(InstanceTypeSchema),
-  total: import_zod20.z.number(),
-  page: import_zod20.z.number(),
-  page_size: import_zod20.z.number(),
-  pages: import_zod20.z.number()
-}).strict();
-var { action: listInstanceTypes, safeAction: safeListInstanceTypes } = defineAction(PaginatedInstanceTypesSchema, async (client, request) => {
-  const validatedRequest = ListInstanceTypesRequestSchema.parse(request ?? {});
-  const queryParams = new URLSearchParams();
-  queryParams.append("page", validatedRequest.page.toString());
-  queryParams.append("page_size", validatedRequest.page_size.toString());
-  return await client.get(`/api/instance-types?${queryParams.toString()}`);
-});
-
 // src/parse_dotenv.ts
 var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseEnv(input) {
@@ -2469,18 +2859,31 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   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,
@@ -2497,8 +2900,15 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
   RequestError,
+  RestartCvmRequestSchema,
   SUPPORTED_CHAINS,
+  ShutdownCvmRequestSchema,
+  StartCvmRequestSchema,
+  StopCvmRequestSchema,
   TransactionError,
+  UpdateCvmResourcesRequestSchema,
+  UpdateCvmVisibilityRequestSchema,
+  VMSchema,
   VmInfoSchema,
   WalletError,
   WorkspaceResponseSchema,
@@ -2510,6 +2920,7 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   checkNetworkStatus,
   commitCvmComposeFileUpdate,
   commitCvmProvision,
+  createBaseClient,
   createClient,
   createClientsFromBrowser,
   createClientsFromPrivateKey,
@@ -2517,6 +2928,7 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   createTransactionTracker,
   defineAction,
   defineSimpleAction,
+  deleteCvm,
   deployAppAuth,
   encryptEnvVars,
   estimateTransactionGas,
@@ -2528,9 +2940,14 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   getAvailableNodes,
   getComposeHash,
   getCurrentUser,
+  getCvmAttestation,
   getCvmComposeFile,
+  getCvmContainersStats,
+  getCvmDockerCompose,
   getCvmInfo,
   getCvmList,
+  getCvmNetwork,
+  getCvmStats,
   getErrorMessage,
   getKmsInfo,
   getKmsList,
@@ -2541,16 +2958,24 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   parseEnvVars,
   provisionCvm,
   provisionCvmComposeFileUpdate,
+  refineCvmId,
+  restartCvm,
   safeAddComposeHash,
   safeCommitCvmComposeFileUpdate,
   safeCommitCvmProvision,
+  safeDeleteCvm,
   safeDeployAppAuth,
   safeGetAppEnvEncryptPubKey,
   safeGetAvailableNodes,
   safeGetCurrentUser,
+  safeGetCvmAttestation,
   safeGetCvmComposeFile,
+  safeGetCvmContainersStats,
+  safeGetCvmDockerCompose,
   safeGetCvmInfo,
   safeGetCvmList,
+  safeGetCvmNetwork,
+  safeGetCvmStats,
   safeGetKmsInfo,
   safeGetKmsList,
   safeGetWorkspace,
@@ -2558,8 +2983,19 @@ var import_verify_env_encrypt_public_key = require("@phala/dstack-sdk/verify-env
   safeListWorkspaces,
   safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate,
+  safeRestartCvm,
+  safeShutdownCvm,
+  safeStartCvm,
+  safeStopCvm,
+  safeUpdateCvmResources,
+  safeUpdateCvmVisibility,
   safeValidateActionParameters,
+  shutdownCvm,
+  startCvm,
+  stopCvm,
   switchToNetwork,
+  updateCvmResources,
+  updateCvmVisibility,
   validateActionParameters,
   validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey,