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

package/dist/index.mjs

@@ -1,78 +1,1411 @@
-import {
-  ApiErrorSchema,
+// src/client.ts
+import { ofetch } from "ofetch";
+import debug from "debug";
+
+// src/types/client.ts
+import { z } from "zod";
+var ApiErrorSchema = z.object({
+  detail: z.union([
+    z.string(),
+    z.array(
+      z.object({
+        msg: z.string(),
+        type: z.string().optional(),
+        ctx: z.record(z.unknown()).optional()
+      })
+    ),
+    z.record(z.unknown())
+  ]),
+  type: z.string().optional(),
+  code: z.string().optional()
+});
+var RequestError = class _RequestError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "RequestError";
+    this.isRequestError = true;
+    this.status = options?.status;
+    this.statusText = options?.statusText;
+    this.data = options?.data;
+    this.request = options?.request;
+    this.response = options?.response;
+    this.detail = options?.detail || message;
+    this.code = options?.code;
+    this.type = options?.type;
+  }
+  /**
+   * Create RequestError from FetchError
+   */
+  static fromFetchError(error) {
+    const parseResult = ApiErrorSchema.safeParse(error.data);
+    if (parseResult.success) {
+      return new _RequestError(error.message, {
+        status: error.status ?? void 0,
+        statusText: error.statusText ?? void 0,
+        data: error.data,
+        request: error.request ?? void 0,
+        response: error.response ?? void 0,
+        detail: parseResult.data.detail,
+        code: parseResult.data.code ?? void 0,
+        type: parseResult.data.type ?? void 0
+      });
+    }
+    return new _RequestError(error.message, {
+      status: error.status ?? void 0,
+      statusText: error.statusText ?? void 0,
+      data: error.data,
+      request: error.request ?? void 0,
+      response: error.response ?? void 0,
+      detail: error.data?.detail || "Unknown API error",
+      code: error.status?.toString() ?? void 0
+    });
+  }
+  /**
+   * Create RequestError from generic Error
+   */
+  static fromError(error, request) {
+    return new _RequestError(error.message, {
+      request: request ?? void 0,
+      detail: error.message
+    });
+  }
+};
+
+// src/client.ts
+var SUPPORTED_API_VERSIONS = ["2025-05-31"];
+var logger = debug("phala::api-client");
+function formatHeaders(headers) {
+  return Object.entries(headers).map(([key, value]) => `    -H "${key}: ${value}"`).join("\n");
+}
+function formatBody(body) {
+  if (!body) return "";
+  const bodyStr = typeof body === "string" ? body : JSON.stringify(body, null, 2);
+  return `    -d '${bodyStr.replace(/'/g, "\\'")}'`;
+}
+function formatResponse(status, statusText, headers, body) {
+  const headerEntries = [];
+  headers.forEach((value, key) => {
+    headerEntries.push(`${key}: ${value}`);
+  });
+  const headerStr = headerEntries.join("\n");
+  const bodyStr = typeof body === "string" ? body : JSON.stringify(body, null, 2);
+  return [
+    `< HTTP/1.1 ${status} ${statusText}`,
+    headerStr ? `< ${headerStr.replace(/\n/g, "\n< ")}` : "",
+    "",
+    bodyStr
+  ].filter(Boolean).join("\n");
+}
+var Client = class {
+  constructor(config = {}) {
+    const resolvedConfig = {
+      ...config,
+      apiKey: config.apiKey || process?.env?.PHALA_CLOUD_API_KEY,
+      baseURL: config.baseURL || process?.env?.PHALA_CLOUD_API_PREFIX || "https://cloud-api.phala.network/api/v1"
+    };
+    const version = resolvedConfig.version && SUPPORTED_API_VERSIONS.includes(resolvedConfig.version) ? resolvedConfig.version : SUPPORTED_API_VERSIONS[0];
+    this.config = resolvedConfig;
+    if (!resolvedConfig.useCookieAuth && !resolvedConfig.apiKey) {
+      throw new Error(
+        "API key is required. Provide it via config.apiKey or set PHALA_CLOUD_API_KEY environment variable."
+      );
+    }
+    const { apiKey, baseURL, timeout, headers, useCookieAuth, onResponseError, ...fetchOptions } = resolvedConfig;
+    const requestHeaders = {
+      "X-Phala-Version": version,
+      "Content-Type": "application/json"
+    };
+    if (headers && typeof headers === "object") {
+      Object.entries(headers).forEach(([key, value]) => {
+        if (typeof value === "string") {
+          requestHeaders[key] = value;
+        }
+      });
+    }
+    if (!useCookieAuth && apiKey) {
+      requestHeaders["X-API-Key"] = apiKey;
+    }
+    this.fetchInstance = ofetch.create({
+      baseURL,
+      timeout: timeout || 3e4,
+      headers: requestHeaders,
+      ...useCookieAuth ? { credentials: "include" } : {},
+      ...fetchOptions,
+      // Log request in cURL format
+      onRequest({ request, options }) {
+        if (logger.enabled) {
+          const method = options.method || "GET";
+          const url = typeof request === "string" ? request : request.url;
+          const fullUrl = url.startsWith("http") ? url : `${baseURL}${url}`;
+          const headerObj = {};
+          if (options.headers && typeof options.headers === "object") {
+            Object.entries(options.headers).forEach(([key, value]) => {
+              if (typeof value === "string") {
+                headerObj[key] = value;
+              }
+            });
+          }
+          const curlCommand = [
+            `> curl -X ${method} "${fullUrl}"`,
+            formatHeaders(headerObj),
+            options.body ? formatBody(options.body) : ""
+          ].filter(Boolean).join("\n");
+          logger("\n=== REQUEST ===\n%s\n", curlCommand);
+        }
+      },
+      // Log response in cURL format
+      onResponse({ request, response, options }) {
+        if (logger.enabled) {
+          const method = options.method || "GET";
+          const url = typeof request === "string" ? request : request.url;
+          logger(
+            "\n=== RESPONSE [%s %s] (%dms) ===\n%s\n",
+            method,
+            url,
+            response.headers.get("x-response-time") || "?",
+            formatResponse(response.status, response.statusText, response.headers, response._data)
+          );
+        }
+      },
+      // Generic handlers for response error (similar to request.ts)
+      onResponseError: ({ request, response, options }) => {
+        console.warn(`HTTP ${response.status}: ${response.url}`);
+        if (logger.enabled) {
+          const method = options.method || "GET";
+          const url = typeof request === "string" ? request : request.url;
+          logger(
+            "\n=== ERROR RESPONSE [%s %s] ===\n%s\n",
+            method,
+            url,
+            formatResponse(response.status, response.statusText, response.headers, response._data)
+          );
+        }
+        if (onResponseError) {
+          onResponseError({ request, response, options });
+        }
+      }
+    });
+  }
+  /**
+   * Get the underlying ofetch instance for advanced usage
+   */
+  get raw() {
+    return this.fetchInstance;
+  }
+  // ===== Direct methods (throw on error) =====
+  /**
+   * Perform GET request (throws on error)
+   */
+  async get(request, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "GET"
+    });
+  }
+  /**
+   * Perform POST request (throws on error)
+   */
+  async post(request, body, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "POST",
+      body
+    });
+  }
+  /**
+   * Perform PUT request (throws on error)
+   */
+  async put(request, body, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "PUT",
+      body
+    });
+  }
+  /**
+   * Perform PATCH request (throws on error)
+   */
+  async patch(request, body, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "PATCH",
+      body
+    });
+  }
+  /**
+   * Perform DELETE request (throws on error)
+   */
+  async delete(request, options) {
+    return this.fetchInstance(request, {
+      ...options,
+      method: "DELETE"
+    });
+  }
+  // ===== Safe methods (return SafeResult) =====
+  /**
+   * Safe wrapper for any request method (zod-style result)
+   */
+  async safeRequest(fn) {
+    try {
+      const data = await fn();
+      return { success: true, data };
+    } catch (error) {
+      if (error && typeof error === "object" && "data" in error) {
+        const requestError2 = RequestError.fromFetchError(error);
+        return { success: false, error: requestError2 };
+      }
+      if (error instanceof Error) {
+        const requestError2 = RequestError.fromError(error);
+        return { success: false, error: requestError2 };
+      }
+      const requestError = new RequestError("Unknown error occurred", {
+        detail: "Unknown error occurred"
+      });
+      return { success: false, error: requestError };
+    }
+  }
+  /**
+   * Safe GET request (returns SafeResult)
+   */
+  async safeGet(request, options) {
+    return this.safeRequest(() => this.get(request, options));
+  }
+  /**
+   * Safe POST request (returns SafeResult)
+   */
+  async safePost(request, body, options) {
+    return this.safeRequest(() => this.post(request, body, options));
+  }
+  /**
+   * Safe PUT request (returns SafeResult)
+   */
+  async safePut(request, body, options) {
+    return this.safeRequest(() => this.put(request, body, options));
+  }
+  /**
+   * Safe PATCH request (returns SafeResult)
+   */
+  async safePatch(request, body, options) {
+    return this.safeRequest(() => this.patch(request, body, options));
+  }
+  /**
+   * Safe DELETE request (returns SafeResult)
+   */
+  async safeDelete(request, options) {
+    return this.safeRequest(() => this.delete(request, options));
+  }
+  /**
+   * Extend client with additional actions
+   *
+   * @example
+   * ```typescript
+   * const client = createClient({ apiKey: 'xxx' })
+   *   .extend(publicActions)
+   *   .extend(cvmActions)
+   *
+   * await client.getCurrentUser() // Method call instead of function call
+   * ```
+   */
+  extend(actions) {
+    const actionsObj = typeof actions === "function" ? actions(this) : actions;
+    const extended = Object.create(this);
+    for (const [key, action] of Object.entries(actionsObj)) {
+      if (typeof action === "function") {
+        extended[key] = (...args) => action(this, ...args);
+      }
+    }
+    return extended;
+  }
+};
+function createClient(config = {}) {
+  return new Client(config);
+}
+
+// src/actions/get_current_user.ts
+import { z as z2 } from "zod";
+
+// src/utils/validate-parameters.ts
+function validateActionParameters(parameters) {
+  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
+    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
+      throw new Error("Invalid schema: must be a Zod schema object, false, or undefined");
+    }
+  }
+}
+function safeValidateActionParameters(parameters) {
+  if (parameters?.schema !== void 0 && parameters?.schema !== false) {
+    if (typeof parameters.schema !== "object" || parameters.schema === null || !("parse" in parameters.schema) || typeof parameters.schema.parse !== "function") {
+      return {
+        success: false,
+        error: {
+          name: "ZodError",
+          message: "Invalid schema: must be a Zod schema object, false, or undefined",
+          issues: [
+            {
+              code: "invalid_type",
+              expected: "object",
+              received: typeof parameters.schema,
+              path: ["schema"],
+              message: "Invalid schema: must be a Zod schema object, false, or undefined"
+            }
+          ]
+        }
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/utils/define-action.ts
+function defineSimpleAction(schema, fn) {
+  function action(client, parameters) {
+    return _actionImpl(client, parameters);
+  }
+  async function _actionImpl(client, parameters) {
+    validateActionParameters(parameters);
+    const response = await fn(client);
+    if (parameters?.schema === false) {
+      return response;
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.parse(response);
+  }
+  function safeAction(client, parameters) {
+    return _safeActionImpl(client, parameters);
+  }
+  async function _safeActionImpl(client, parameters) {
+    const parameterValidationError = safeValidateActionParameters(parameters);
+    if (parameterValidationError) {
+      return parameterValidationError;
+    }
+    const httpResult = await (async () => {
+      try {
+        const data = await fn(client);
+        return { success: true, data };
+      } catch (error) {
+        if (error && typeof error === "object" && "isRequestError" in error) {
+          return { success: false, error };
+        }
+        if (error && typeof error === "object" && "issues" in error) {
+          return { success: false, error };
+        }
+        return {
+          success: false,
+          error: {
+            name: "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    })();
+    if (!httpResult.success) {
+      return httpResult;
+    }
+    if (parameters?.schema === false) {
+      return { success: true, data: httpResult.data };
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.safeParse(httpResult.data);
+  }
+  return {
+    action,
+    safeAction
+  };
+}
+function defineAction(schema, fn) {
+  function action(client, ...args) {
+    const [params, parameters] = args;
+    return _actionImpl(client, params, parameters);
+  }
+  async function _actionImpl(client, params, parameters) {
+    validateActionParameters(parameters);
+    const response = await fn(client, params);
+    if (parameters?.schema === false) {
+      return response;
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.parse(response);
+  }
+  function safeAction(client, ...args) {
+    const [params, parameters] = args;
+    return _safeActionImpl(client, params, parameters);
+  }
+  async function _safeActionImpl(client, params, parameters) {
+    const parameterValidationError = safeValidateActionParameters(parameters);
+    if (parameterValidationError) {
+      return parameterValidationError;
+    }
+    const httpResult = await (async () => {
+      try {
+        const data = await fn(client, params);
+        return { success: true, data };
+      } catch (error) {
+        if (error && typeof error === "object" && "isRequestError" in error) {
+          return { success: false, error };
+        }
+        if (error && typeof error === "object" && "issues" in error) {
+          return { success: false, error };
+        }
+        return {
+          success: false,
+          error: {
+            name: "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    })();
+    if (!httpResult.success) {
+      return httpResult;
+    }
+    if (parameters?.schema === false) {
+      return { success: true, data: httpResult.data };
+    }
+    const actualSchema = parameters?.schema || schema;
+    return actualSchema.safeParse(httpResult.data);
+  }
+  return {
+    action,
+    safeAction
+  };
+}
+
+// src/actions/get_current_user.ts
+var CurrentUserSchema = z2.object({
+  username: z2.string(),
+  email: z2.string(),
+  credits: z2.number(),
+  granted_credits: z2.number(),
+  avatar: z2.string(),
+  team_name: z2.string(),
+  team_tier: z2.string()
+}).passthrough();
+var { action: getCurrentUser, safeAction: safeGetCurrentUser } = defineSimpleAction(
+  CurrentUserSchema,
+  async (client) => {
+    return await client.get("/auth/me");
+  }
+);
+
+// src/actions/get_available_nodes.ts
+import { z as z4 } from "zod";
+
+// src/types/kms_info.ts
+import { z as z3 } from "zod";
+
+// src/types/supported_chains.ts
+import { anvil, base, mainnet } from "viem/chains";
+var SUPPORTED_CHAINS = {
+  [mainnet.id]: mainnet,
+  [base.id]: base,
+  [anvil.id]: anvil
+};
+
+// src/types/kms_info.ts
+var KmsInfoBaseSchema = z3.object({
+  id: z3.string(),
+  slug: z3.string().nullable(),
+  url: z3.string(),
+  version: z3.string(),
+  chain_id: z3.number().nullable(),
+  kms_contract_address: z3.string().nullable().transform((val) => val),
+  gateway_app_id: z3.string().nullable().transform((val) => val)
+}).passthrough();
+var KmsInfoSchema = KmsInfoBaseSchema.transform((data) => {
+  if (data.chain_id != null) {
+    const chain = SUPPORTED_CHAINS[data.chain_id];
+    if (chain) {
+      return { ...data, chain };
+    }
+  }
+  return data;
+});
+
+// src/actions/get_available_nodes.ts
+var AvailableOSImageSchema = z4.object({
+  name: z4.string(),
+  is_dev: z4.boolean(),
+  version: z4.union([
+    z4.tuple([z4.number(), z4.number(), z4.number()]),
+    z4.tuple([z4.number(), z4.number(), z4.number(), z4.number()])
+  ]),
+  os_image_hash: z4.string().nullable().optional()
+}).passthrough();
+var TeepodCapacitySchema = z4.object({
+  teepod_id: z4.number(),
+  name: z4.string(),
+  listed: z4.boolean(),
+  resource_score: z4.number(),
+  remaining_vcpu: z4.number(),
+  remaining_memory: z4.number(),
+  remaining_cvm_slots: z4.number(),
+  images: z4.array(AvailableOSImageSchema),
+  support_onchain_kms: z4.boolean().optional(),
+  fmspc: z4.string().nullable().optional(),
+  device_id: z4.string().nullable().optional(),
+  region_identifier: z4.string().nullable().optional(),
+  default_kms: z4.string().nullable().optional(),
+  kms_list: z4.array(z4.string()).default([])
+}).passthrough();
+var ResourceThresholdSchema = z4.object({
+  max_instances: z4.number().nullable().optional(),
+  max_vcpu: z4.number().nullable().optional(),
+  max_memory: z4.number().nullable().optional(),
+  max_disk: z4.number().nullable().optional()
+}).passthrough();
+var AvailableNodesSchema = z4.object({
+  tier: z4.string(),
+  // TeamTier is string enum
+  capacity: ResourceThresholdSchema,
+  nodes: z4.array(TeepodCapacitySchema),
+  kms_list: z4.array(KmsInfoSchema)
+}).passthrough();
+var { action: getAvailableNodes, safeAction: safeGetAvailableNodes } = defineSimpleAction(
   AvailableNodesSchema,
-  CommitCvmComposeFileUpdateRequestSchema,
+  async (client) => {
+    return await client.get("/teepods/available");
+  }
+);
+
+// src/actions/list-instance-types.ts
+import { z as z5 } from "zod";
+var ListInstanceTypesRequestSchema = z5.object({
+  page: z5.number().int().min(1).optional().default(1),
+  page_size: z5.number().int().min(1).max(1e3).optional().default(100)
+}).strict();
+var InstanceTypeSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  description: z5.string(),
+  vcpu: z5.number(),
+  memory_mb: z5.number(),
+  hourly_rate: z5.string(),
+  requires_gpu: z5.boolean(),
+  public: z5.boolean(),
+  enabled: z5.boolean()
+}).passthrough();
+var PaginatedInstanceTypesSchema = z5.object({
+  items: z5.array(InstanceTypeSchema),
+  total: z5.number(),
+  page: z5.number(),
+  page_size: z5.number(),
+  pages: z5.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
+import { z as z6 } from "zod";
+var WorkspaceResponseSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  slug: z6.string().nullable(),
+  tier: z6.string(),
+  role: z6.string(),
+  created_at: z6.string()
+}).passthrough();
+var PaginationMetadataSchema = z6.object({
+  has_more: z6.boolean(),
+  next_cursor: z6.string().nullable(),
+  total: z6.number().nullable()
+}).passthrough();
+var ListWorkspacesSchema = z6.object({
+  data: z6.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
+import { z as z7 } from "zod";
+var VmInfoSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  status: z7.string(),
+  uptime: z7.string(),
+  app_url: z7.string().nullable(),
+  app_id: z7.string(),
+  instance_id: z7.string().nullable(),
+  configuration: z7.any().optional(),
+  // TODO: add VmConfiguration schema if needed
+  exited_at: z7.string().nullable(),
+  boot_progress: z7.string().nullable(),
+  boot_error: z7.string().nullable(),
+  shutdown_progress: z7.string().nullable(),
+  image_version: z7.string().nullable()
+});
+var ManagedUserSchema = z7.object({
+  id: z7.number(),
+  username: z7.string()
+});
+var CvmNodeSchema = z7.object({
+  id: z7.number(),
+  name: z7.string(),
+  region_identifier: z7.string().nullable().optional()
+});
+var CvmNetworkUrlsSchema = z7.object({
+  app: z7.string(),
+  instance: z7.string()
+});
+var CvmInfoSchema = z7.object({
+  hosted: VmInfoSchema,
+  name: z7.string(),
+  managed_user: ManagedUserSchema.nullable(),
+  node: CvmNodeSchema.nullable(),
+  listed: z7.boolean().default(false),
+  status: z7.string(),
+  in_progress: z7.boolean().default(false),
+  dapp_dashboard_url: z7.string().nullable(),
+  syslog_endpoint: z7.string().nullable(),
+  allow_upgrade: z7.boolean().default(false),
+  project_id: z7.string().nullable(),
+  // HashedId is represented as string in JS
+  project_type: z7.string().nullable(),
+  billing_period: z7.string().nullable(),
+  kms_info: KmsInfoSchema.nullable(),
+  vcpu: z7.number().nullable(),
+  memory: z7.number().nullable(),
+  disk_size: z7.number().nullable(),
+  gateway_domain: z7.string().nullable(),
+  public_urls: z7.array(CvmNetworkUrlsSchema)
+});
+var CvmLegacyDetailSchema = z7.object({
+  id: z7.number(),
+  name: z7.string(),
+  status: z7.string(),
+  in_progress: z7.boolean().optional().default(false),
+  teepod_id: z7.number().nullable(),
+  teepod: CvmNodeSchema.optional().nullable(),
+  app_id: z7.string(),
+  vm_uuid: z7.string().nullable(),
+  instance_id: z7.string().nullable(),
+  vcpu: z7.number(),
+  memory: z7.number(),
+  disk_size: z7.number(),
+  base_image: z7.string().nullable(),
+  encrypted_env_pubkey: z7.string().nullable(),
+  listed: z7.boolean().optional().default(false),
+  project_id: z7.string().optional().nullable(),
+  project_type: z7.string().optional().nullable(),
+  public_sysinfo: z7.boolean().optional().default(false),
+  public_logs: z7.boolean().optional().default(false),
+  dapp_dashboard_url: z7.string().optional().nullable(),
+  syslog_endpoint: z7.string().optional().nullable(),
+  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/types/cvm_id.ts
+import { z as z8 } from "zod";
+var CvmIdObjectSchema = z8.object({
+  /** Direct CVM ID (any format) */
+  id: z8.string().optional(),
+  /** 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 { cvmId } = GetCvmInfoRequestSchema.parse(request);
+  return await client.get(`/cvms/${cvmId}`);
+});
+
+// src/actions/cvms/get_cvm_list.ts
+import { z as z9 } from "zod";
+var GetCvmListRequestSchema = z9.object({
+  page: z9.number().int().min(1).optional(),
+  page_size: z9.number().int().min(1).optional(),
+  node_id: z9.number().int().min(1).optional(),
+  teepod_id: z9.number().int().min(1).optional(),
+  user_id: z9.string().optional()
+}).strict();
+var GetCvmListSchema = z9.object({
+  items: z9.array(CvmInfoSchema),
+  total: z9.number(),
+  page: z9.number(),
+  page_size: z9.number(),
+  pages: z9.number()
+}).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
+import { z as z10 } from "zod";
+var ProvisionCvmSchema = z10.object({
+  app_id: z10.string().nullable().optional(),
+  app_env_encrypt_pubkey: z10.string().nullable().optional(),
+  compose_hash: z10.string(),
+  fmspc: z10.string().nullable().optional(),
+  device_id: z10.string().nullable().optional(),
+  os_image_hash: z10.string().nullable().optional(),
+  teepod_id: z10.number().nullable().optional(),
+  // Will be transformed to node_id
+  node_id: z10.number().nullable().optional(),
+  kms_id: z10.string().nullable().optional()
+}).passthrough().transform((data) => {
+  if ("teepod_id" in data && data.teepod_id !== void 0) {
+    const { teepod_id, ...rest } = data;
+    return { ...rest, node_id: teepod_id };
+  }
+  return data;
+});
+var ProvisionCvmRequestSchema = z10.object({
+  node_id: z10.number().optional(),
+  // recommended
+  teepod_id: z10.number().optional(),
+  // deprecated, for compatibility
+  name: z10.string(),
+  image: z10.string(),
+  vcpu: z10.number(),
+  memory: z10.number(),
+  disk_size: z10.number(),
+  compose_file: z10.object({
+    allowed_envs: z10.array(z10.string()).optional(),
+    pre_launch_script: z10.string().optional(),
+    docker_compose_file: z10.string().optional(),
+    name: z10.string().optional(),
+    kms_enabled: z10.boolean().optional(),
+    public_logs: z10.boolean().optional(),
+    public_sysinfo: z10.boolean().optional(),
+    gateway_enabled: z10.boolean().optional(),
+    // recommended
+    tproxy_enabled: z10.boolean().optional()
+    // deprecated, for compatibility
+  }),
+  listed: z10.boolean().optional(),
+  instance_type: z10.string().nullable().optional(),
+  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;
+  }
+  const composeFile = { ...appCompose.compose_file };
+  if (typeof composeFile.gateway_enabled === "boolean" && typeof composeFile.tproxy_enabled === "boolean") {
+    delete composeFile.tproxy_enabled;
+  } else if (typeof composeFile.tproxy_enabled === "boolean" && typeof composeFile.gateway_enabled === "undefined") {
+    composeFile.gateway_enabled = composeFile.tproxy_enabled;
+    delete composeFile.tproxy_enabled;
+    if (typeof window !== "undefined" ? window.console : globalThis.console) {
+      console.warn(
+        "[phala/cloud] tproxy_enabled is deprecated, please use gateway_enabled instead. See docs for migration."
+      );
+    }
+  }
+  return {
+    ...appCompose,
+    compose_file: composeFile
+  };
+}
+var { action: provisionCvm, safeAction: safeProvisionCvm } = defineAction(ProvisionCvmSchema, async (client, appCompose) => {
+  const body = handleGatewayCompatibility(autofillComposeFileName(appCompose));
+  let requestBody = { ...body };
+  if (typeof body.node_id === "number") {
+    requestBody = { ...body, teepod_id: body.node_id };
+    delete requestBody.node_id;
+  } 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);
+});
+
+// src/actions/cvms/commit_cvm_provision.ts
+import { z as z11 } from "zod";
+var CommitCvmProvisionSchema = z11.object({
+  id: z11.number(),
+  name: z11.string(),
+  status: z11.string(),
+  teepod_id: z11.number(),
+  teepod: z11.object({
+    id: z11.number(),
+    name: z11.string()
+  }).nullable(),
+  user_id: z11.number().nullable(),
+  app_id: z11.string().nullable(),
+  vm_uuid: z11.string().nullable(),
+  instance_id: z11.string().nullable(),
+  app_url: z11.string().nullable(),
+  base_image: z11.string().nullable(),
+  vcpu: z11.number(),
+  memory: z11.number(),
+  disk_size: z11.number(),
+  manifest_version: z11.number().nullable(),
+  version: z11.string().nullable(),
+  runner: z11.string().nullable(),
+  docker_compose_file: z11.string().nullable(),
+  features: z11.array(z11.string()).nullable(),
+  created_at: z11.string(),
+  encrypted_env_pubkey: z11.string().nullable().optional(),
+  app_auth_contract_address: z11.string().nullable().optional(),
+  deployer_address: z11.string().nullable().optional()
+}).passthrough();
+var CommitCvmProvisionRequestSchema = z11.object({
+  encrypted_env: z11.string().optional().nullable(),
+  app_id: z11.string(),
+  compose_hash: z11.string().optional(),
+  kms_id: z11.string().optional(),
+  contract_address: z11.string().optional(),
+  deployer_address: z11.string().optional(),
+  env_keys: z11.array(z11.string()).optional().nullable()
+}).passthrough();
+var { action: commitCvmProvision, safeAction: safeCommitCvmProvision } = defineAction(CommitCvmProvisionSchema, async (client, payload) => {
+  return await client.post("/cvms", payload);
+});
+
+// src/types/app_compose.ts
+import { z as z12 } from "zod";
+var LooseAppComposeSchema = z12.object({
+  allowed_envs: z12.array(z12.string()).optional(),
+  docker_compose_file: z12.string(),
+  features: z12.array(z12.string()).optional(),
+  name: z12.string().optional(),
+  manifest_version: z12.number().optional(),
+  kms_enabled: z12.boolean().optional(),
+  public_logs: z12.boolean().optional(),
+  public_sysinfo: z12.boolean().optional(),
+  tproxy_enabled: z12.boolean().optional(),
+  pre_launch_script: z12.string().optional(),
+  env_pubkey: z12.string().optional(),
+  salt: z12.string().optional().nullable()
+}).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
+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(
+    (val) => !val.startsWith("app_") && val.length === 40,
+    "app_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("app_") ? val : `app_${val}`).optional(),
+  instance_id: z13.string().refine(
+    (val) => !val.startsWith("instance_") && val.length === 40,
+    "instance_id should be 40 characters without prefix"
+  ).transform((val) => val.startsWith("instance_") ? val : `instance_${val}`).optional(),
+  app_compose: LooseAppComposeSchema,
+  update_env_vars: z13.boolean().optional().nullable()
+}).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 = 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) => {
+  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
+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: 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: 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"
+).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 = z14.any().transform(() => void 0);
+var { action: commitCvmComposeFileUpdate, safeAction: safeCommitCvmComposeFileUpdate } = defineAction(
   CommitCvmComposeFileUpdateSchema,
-  CommitCvmProvisionRequestSchema,
-  CommitCvmProvisionSchema,
-  CurrentUserSchema,
-  CvmInfoSchema,
-  CvmLegacyDetailSchema,
-  CvmNetworkUrlsSchema,
-  CvmNodeSchema,
-  GetAppEnvEncryptPubKeyRequestSchema,
-  GetAppEnvEncryptPubKeySchema,
-  GetCvmComposeFileRequestSchema,
-  GetCvmInfoRequestSchema,
-  GetCvmListRequestSchema,
-  GetCvmListSchema,
-  GetKmsInfoRequestSchema,
-  GetKmsListRequestSchema,
-  GetKmsListSchema,
-  InstanceTypeSchema,
-  KmsInfoSchema,
-  ListInstanceTypesRequestSchema,
-  ListWorkspacesSchema,
-  ManagedUserSchema,
-  PaginatedInstanceTypesSchema,
-  PaginationMetadataSchema,
-  ProvisionCvmComposeFileUpdateRequestSchema,
-  ProvisionCvmComposeFileUpdateResultSchema,
-  ProvisionCvmRequestSchema,
-  ProvisionCvmSchema,
-  RequestError,
-  SUPPORTED_CHAINS,
-  VmInfoSchema,
-  WorkspaceResponseSchema,
-  commitCvmComposeFileUpdate,
-  commitCvmProvision,
-  createClient,
-  defineAction,
-  defineSimpleAction,
-  getAppEnvEncryptPubKey,
-  getAvailableNodes,
-  getCurrentUser,
-  getCvmComposeFile,
-  getCvmInfo,
-  getCvmList,
-  getKmsInfo,
-  getKmsList,
-  getWorkspace,
-  listInstanceTypes,
-  listWorkspaces,
-  provisionCvm,
-  provisionCvmComposeFileUpdate,
-  safeCommitCvmComposeFileUpdate,
-  safeCommitCvmProvision,
-  safeGetAppEnvEncryptPubKey,
-  safeGetAvailableNodes,
-  safeGetCurrentUser,
-  safeGetCvmComposeFile,
-  safeGetCvmInfo,
-  safeGetCvmList,
-  safeGetKmsInfo,
-  safeGetKmsList,
-  safeGetWorkspace,
-  safeListInstanceTypes,
-  safeListWorkspaces,
-  safeProvisionCvm,
-  safeProvisionCvmComposeFileUpdate,
-  safeValidateActionParameters,
-  validateActionParameters
-} from "./chunk-O5QBIXBA.mjs";
+  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
+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);
+  return await client.get(`/kms/${validatedRequest.kms_id}`);
+});
+
+// src/actions/kms/get_kms_list.ts
+import { z as z16 } from "zod";
+var GetKmsListRequestSchema = z16.object({
+  page: z16.number().int().min(1).optional(),
+  page_size: z16.number().int().min(1).optional(),
+  is_onchain: z16.boolean().optional()
+}).strict();
+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 ?? {});
+  return await client.get("/kms", { params: validatedRequest });
+});
+
+// src/actions/kms/get_app_env_encrypt_pubkey.ts
+import { z as z17 } from "zod";
+var GetAppEnvEncryptPubKeyRequestSchema = z17.object({
+  kms: z17.string().min(1, "KMS ID or slug is required"),
+  app_id: z17.string().refine(
+    (val) => val.length === 40 || val.startsWith("0x") && val.length === 42,
+    "App ID must be exactly 40 characters or 42 characters with 0x prefix"
+  )
+}).strict();
+var GetAppEnvEncryptPubKeySchema = z17.object({
+  public_key: z17.string(),
+  signature: z17.string()
+}).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);
+  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
-import { z } from "zod";
+import { z as z27 } from "zod";
 import {
   createPublicClient as createPublicClient2,
   createWalletClient as createWalletClient2,
@@ -750,25 +2083,25 @@ var kmsAuthAbi = [
     anonymous: false
   }
 ];
-var DeployAppAuthRequestBaseSchema = z.object({
+var DeployAppAuthRequestBaseSchema = z27.object({
   // Chain configuration (conditionally required)
-  chain: z.unknown().optional(),
-  rpcUrl: z.string().optional(),
+  chain: z27.unknown().optional(),
+  rpcUrl: z27.string().optional(),
   // Contract configuration (required)
-  kmsContractAddress: z.string(),
+  kmsContractAddress: z27.string(),
   // Authentication mode: either privateKey OR walletClient (required, mutually exclusive)
-  privateKey: z.string().optional(),
-  walletClient: z.unknown().optional(),
+  privateKey: z27.string().optional(),
+  walletClient: z27.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z.unknown().optional(),
+  publicClient: z27.unknown().optional(),
   // App configuration (optional)
-  allowAnyDevice: z.boolean().optional().default(false),
-  deviceId: z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  composeHash: z.string().optional().default("0000000000000000000000000000000000000000000000000000000000000000"),
-  disableUpgrades: z.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: z.boolean().optional().default(false),
-  minBalance: z.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(
@@ -796,13 +2129,13 @@ var DeployAppAuthRequestSchema = DeployAppAuthRequestBaseSchema.refine(
     path: ["chain"]
   }
 );
-var DeployAppAuthSchema = z.object({
-  appId: z.string(),
-  appAuthAddress: z.string(),
-  deployer: z.string(),
-  transactionHash: z.string(),
-  blockNumber: z.bigint().optional(),
-  gasUsed: z.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 {
@@ -1048,7 +2381,7 @@ async function safeDeployAppAuth(request, parameters) {
 }
 
 // src/actions/blockchains/add_compose_hash.ts
-import { z as z2 } from "zod";
+import { z as z28 } from "zod";
 import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
@@ -1072,29 +2405,29 @@ var appAuthAbi = [
     anonymous: false
   }
 ];
-var AddComposeHashRequestSchema = z2.object({
+var AddComposeHashRequestSchema = z28.object({
   // Chain configuration (conditionally required)
-  chain: z2.unknown().optional(),
-  rpcUrl: z2.string().optional(),
-  appId: z2.string(),
-  composeHash: z2.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: z2.string().optional(),
-  walletClient: z2.unknown().optional(),
+  privateKey: z28.string().optional(),
+  walletClient: z28.unknown().optional(),
   // Public client (optional, will create default if not provided)
-  publicClient: z2.unknown().optional(),
+  publicClient: z28.unknown().optional(),
   // Validation configuration (optional)
-  skipPrerequisiteChecks: z2.boolean().optional().default(false),
-  minBalance: z2.string().optional(),
+  skipPrerequisiteChecks: z28.boolean().optional().default(false),
+  minBalance: z28.string().optional(),
   // ETH amount as string, e.g., "0.01"
   // Transaction control options
-  timeout: z2.number().optional().default(12e4),
-  retryOptions: z2.unknown().optional(),
-  signal: z2.unknown().optional(),
+  timeout: z28.number().optional().default(12e4),
+  retryOptions: z28.unknown().optional(),
+  signal: z28.unknown().optional(),
   // Progress callbacks
-  onTransactionStateChange: z2.function().optional(),
-  onTransactionSubmitted: z2.function().optional(),
-  onTransactionConfirmed: z2.function().optional()
+  onTransactionStateChange: z28.function().optional(),
+  onTransactionSubmitted: z28.function().optional(),
+  onTransactionConfirmed: z28.function().optional()
 }).passthrough().refine(
   (data) => {
     const hasPrivateKey = !!data.privateKey;
@@ -1118,12 +2451,12 @@ var AddComposeHashRequestSchema = z2.object({
     path: ["chain"]
   }
 );
-var AddComposeHashSchema = z2.object({
-  composeHash: z2.string(),
-  appId: z2.string(),
-  transactionHash: z2.string(),
-  blockNumber: z2.bigint().optional(),
-  gasUsed: z2.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);
@@ -1360,18 +2693,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,
@@ -1388,8 +2734,15 @@ export {
   ProvisionCvmRequestSchema,
   ProvisionCvmSchema,
   RequestError,
+  RestartCvmRequestSchema,
   SUPPORTED_CHAINS,
+  ShutdownCvmRequestSchema,
+  StartCvmRequestSchema,
+  StopCvmRequestSchema,
   TransactionError,
+  UpdateCvmResourcesRequestSchema,
+  UpdateCvmVisibilityRequestSchema,
+  VMSchema,
   VmInfoSchema,
   WalletError,
   WorkspaceResponseSchema,
@@ -1401,13 +2754,15 @@ export {
   checkNetworkStatus,
   commitCvmComposeFileUpdate,
   commitCvmProvision,
-  createClient,
+  createClient as createBaseClient,
+  createClient2 as createClient,
   createClientsFromBrowser,
   createClientsFromPrivateKey,
   createNetworkClients,
   createTransactionTracker,
   defineAction,
   defineSimpleAction,
+  deleteCvm,
   deployAppAuth,
   encryptEnvVars2 as encryptEnvVars,
   estimateTransactionGas,
@@ -1419,9 +2774,14 @@ export {
   getAvailableNodes,
   getComposeHash2 as getComposeHash,
   getCurrentUser,
+  getCvmAttestation,
   getCvmComposeFile,
+  getCvmContainersStats,
+  getCvmDockerCompose,
   getCvmInfo,
   getCvmList,
+  getCvmNetwork,
+  getCvmStats,
   getErrorMessage,
   getKmsInfo,
   getKmsList,
@@ -1432,16 +2792,24 @@ export {
   parseEnvVars,
   provisionCvm,
   provisionCvmComposeFileUpdate,
+  refineCvmId,
+  restartCvm,
   safeAddComposeHash,
   safeCommitCvmComposeFileUpdate,
   safeCommitCvmProvision,
+  safeDeleteCvm,
   safeDeployAppAuth,
   safeGetAppEnvEncryptPubKey,
   safeGetAvailableNodes,
   safeGetCurrentUser,
+  safeGetCvmAttestation,
   safeGetCvmComposeFile,
+  safeGetCvmContainersStats,
+  safeGetCvmDockerCompose,
   safeGetCvmInfo,
   safeGetCvmList,
+  safeGetCvmNetwork,
+  safeGetCvmStats,
   safeGetKmsInfo,
   safeGetKmsList,
   safeGetWorkspace,
@@ -1449,8 +2817,19 @@ export {
   safeListWorkspaces,
   safeProvisionCvm,
   safeProvisionCvmComposeFileUpdate,
+  safeRestartCvm,
+  safeShutdownCvm,
+  safeStartCvm,
+  safeStopCvm,
+  safeUpdateCvmResources,
+  safeUpdateCvmVisibility,
   safeValidateActionParameters,
+  shutdownCvm,
+  startCvm,
+  stopCvm,
   switchToNetwork,
+  updateCvmResources,
+  updateCvmVisibility,
   validateActionParameters,
   validateNetworkPrerequisites,
   verifyEnvEncryptPublicKey,