@phala/cloud 0.1.1-beta.3 → 0.1.2

package/dist/actions/cvms/get_cvm_attestation.d.ts

@@ -161,8 +161,8 @@ export declare const CvmAttestationSchema: z.ZodObject<{
     }>>;
     compose_file: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    error: string | null;
     name: string | null;
+    error: string | null;
     compose_file: string | null;
     is_online: boolean;
     is_public: boolean;
@@ -209,8 +209,8 @@ export declare const CvmAttestationSchema: z.ZodObject<{
         rootfs_hash?: string | null | undefined;
     } | null;
 }, {
-    error: string | null;
     name: string | null;
+    error: string | null;
     compose_file: string | null;
     is_online: boolean;
     app_certificates: {
@@ -279,8 +279,8 @@ export declare const GetCvmAttestationRequestSchema: z.ZodEffects<z.ZodEffects<z
 export type GetCvmAttestationRequest = CvmIdInput;
 declare const getCvmAttestation: {
     (client: import("../..").BaseClient, params: CvmIdInput): Promise<{
-        error: string | null;
         name: string | null;
+        error: string | null;
         compose_file: string | null;
         is_online: boolean;
         is_public: boolean;
@@ -335,8 +335,8 @@ declare const getCvmAttestation: {
     }): Promise<unknown>;
 }, safeGetCvmAttestation: {
     (client: import("../..").BaseClient, params: CvmIdInput): Promise<import("../..").SafeResult<{
-        error: string | null;
         name: string | null;
+        error: string | null;
         compose_file: string | null;
         is_online: boolean;
         is_public: boolean;

package/dist/actions/cvms/get_cvm_compose_file.d.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { type Client } from "../../client";
-import { LooseAppComposeSchema } from "../../types/app_compose";
 import { type CvmIdInput } from "../../types/cvm_id";
 /**
  * Get CVM compose file configuration
@@ -69,7 +68,7 @@ import { type CvmIdInput } from "../../types/cvm_id";
  * }
  * ```
  */
-export declare const GetCvmComposeFileResultSchema: z.ZodObject<{
+export declare const GetCvmComposeFileResultSchema: z.ZodEffects<z.ZodObject<{
     allowed_envs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     docker_compose_file: z.ZodString;
     features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -108,8 +107,39 @@ export declare const GetCvmComposeFileResultSchema: z.ZodObject<{
     pre_launch_script: z.ZodOptional<z.ZodString>;
     env_pubkey: z.ZodOptional<z.ZodString>;
     salt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">>, {
+    docker_compose_file: string;
+    name?: string | undefined;
+    public_sysinfo?: boolean | undefined;
+    public_logs?: boolean | undefined;
+    manifest_version?: number | undefined;
+    features?: string[] | undefined;
+    allowed_envs?: string[] | undefined;
+    pre_launch_script?: string | undefined;
+    kms_enabled?: boolean | undefined;
+    tproxy_enabled?: boolean | undefined;
+    env_pubkey?: string | undefined;
+    salt?: string | null | undefined;
+} & {
+    [k: string]: unknown;
+} & {
+    getHash: () => string;
+    toString: () => string;
+}, z.objectInputType<{
+    allowed_envs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    docker_compose_file: z.ZodString;
+    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    name: z.ZodOptional<z.ZodString>;
+    manifest_version: z.ZodOptional<z.ZodNumber>;
+    kms_enabled: z.ZodOptional<z.ZodBoolean>;
+    public_logs: z.ZodOptional<z.ZodBoolean>;
+    public_sysinfo: z.ZodOptional<z.ZodBoolean>;
+    tproxy_enabled: z.ZodOptional<z.ZodBoolean>;
+    pre_launch_script: z.ZodOptional<z.ZodString>;
+    env_pubkey: z.ZodOptional<z.ZodString>;
+    salt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, z.ZodTypeAny, "passthrough">>;
-export declare const CvmComposeFileSchema: z.ZodObject<{
+export declare const CvmComposeFileSchema: z.ZodEffects<z.ZodObject<{
     allowed_envs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     docker_compose_file: z.ZodString;
     features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -148,9 +178,40 @@ export declare const CvmComposeFileSchema: z.ZodObject<{
     pre_launch_script: z.ZodOptional<z.ZodString>;
     env_pubkey: z.ZodOptional<z.ZodString>;
     salt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">>, {
+    docker_compose_file: string;
+    name?: string | undefined;
+    public_sysinfo?: boolean | undefined;
+    public_logs?: boolean | undefined;
+    manifest_version?: number | undefined;
+    features?: string[] | undefined;
+    allowed_envs?: string[] | undefined;
+    pre_launch_script?: string | undefined;
+    kms_enabled?: boolean | undefined;
+    tproxy_enabled?: boolean | undefined;
+    env_pubkey?: string | undefined;
+    salt?: string | null | undefined;
+} & {
+    [k: string]: unknown;
+} & {
+    getHash: () => string;
+    toString: () => string;
+}, z.objectInputType<{
+    allowed_envs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    docker_compose_file: z.ZodString;
+    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    name: z.ZodOptional<z.ZodString>;
+    manifest_version: z.ZodOptional<z.ZodNumber>;
+    kms_enabled: z.ZodOptional<z.ZodBoolean>;
+    public_logs: z.ZodOptional<z.ZodBoolean>;
+    public_sysinfo: z.ZodOptional<z.ZodBoolean>;
+    tproxy_enabled: z.ZodOptional<z.ZodBoolean>;
+    pre_launch_script: z.ZodOptional<z.ZodString>;
+    env_pubkey: z.ZodOptional<z.ZodString>;
+    salt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, z.ZodTypeAny, "passthrough">>;
 export type CvmComposeFile = z.infer<typeof CvmComposeFileSchema>;
-export type GetCvmComposeFileResult = z.infer<typeof LooseAppComposeSchema>;
+export type GetCvmComposeFileResult = z.infer<typeof GetCvmComposeFileResultSchema>;
 export declare const GetCvmComposeFileRequestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     uuid: z.ZodOptional<z.ZodString>;
@@ -171,20 +232,25 @@ export declare const GetCvmComposeFileRequestSchema: z.ZodEffects<z.ZodEffects<z
 }, any>;
 export type GetCvmComposeFileRequest = CvmIdInput;
 declare const getCvmComposeFile: {
-    (client: Client, params: CvmIdInput): Promise<z.objectOutputType<{
-        allowed_envs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        docker_compose_file: z.ZodString;
-        features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        name: z.ZodOptional<z.ZodString>;
-        manifest_version: z.ZodOptional<z.ZodNumber>;
-        kms_enabled: z.ZodOptional<z.ZodBoolean>;
-        public_logs: z.ZodOptional<z.ZodBoolean>;
-        public_sysinfo: z.ZodOptional<z.ZodBoolean>;
-        tproxy_enabled: z.ZodOptional<z.ZodBoolean>;
-        pre_launch_script: z.ZodOptional<z.ZodString>;
-        env_pubkey: z.ZodOptional<z.ZodString>;
-        salt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    }, z.ZodTypeAny, "passthrough">>;
+    (client: Client, params: CvmIdInput): Promise<{
+        docker_compose_file: string;
+        name?: string | undefined;
+        public_sysinfo?: boolean | undefined;
+        public_logs?: boolean | undefined;
+        manifest_version?: number | undefined;
+        features?: string[] | undefined;
+        allowed_envs?: string[] | undefined;
+        pre_launch_script?: string | undefined;
+        kms_enabled?: boolean | undefined;
+        tproxy_enabled?: boolean | undefined;
+        env_pubkey?: string | undefined;
+        salt?: string | null | undefined;
+    } & {
+        [k: string]: unknown;
+    } & {
+        getHash: () => string;
+        toString: () => string;
+    }>;
     <T extends z.ZodTypeAny>(client: Client, params: CvmIdInput, parameters: {
         schema: T;
     }): Promise<z.TypeOf<T>>;
@@ -192,20 +258,25 @@ declare const getCvmComposeFile: {
         schema: false;
     }): Promise<unknown>;
 }, safeGetCvmComposeFile: {
-    (client: Client, params: CvmIdInput): Promise<import("../..").SafeResult<z.objectOutputType<{
-        allowed_envs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        docker_compose_file: z.ZodString;
-        features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        name: z.ZodOptional<z.ZodString>;
-        manifest_version: z.ZodOptional<z.ZodNumber>;
-        kms_enabled: z.ZodOptional<z.ZodBoolean>;
-        public_logs: z.ZodOptional<z.ZodBoolean>;
-        public_sysinfo: z.ZodOptional<z.ZodBoolean>;
-        tproxy_enabled: z.ZodOptional<z.ZodBoolean>;
-        pre_launch_script: z.ZodOptional<z.ZodString>;
-        env_pubkey: z.ZodOptional<z.ZodString>;
-        salt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    }, z.ZodTypeAny, "passthrough">>>;
+    (client: Client, params: CvmIdInput): Promise<import("../..").SafeResult<{
+        docker_compose_file: string;
+        name?: string | undefined;
+        public_sysinfo?: boolean | undefined;
+        public_logs?: boolean | undefined;
+        manifest_version?: number | undefined;
+        features?: string[] | undefined;
+        allowed_envs?: string[] | undefined;
+        pre_launch_script?: string | undefined;
+        kms_enabled?: boolean | undefined;
+        tproxy_enabled?: boolean | undefined;
+        env_pubkey?: string | undefined;
+        salt?: string | null | undefined;
+    } & {
+        [k: string]: unknown;
+    } & {
+        getHash: () => string;
+        toString: () => string;
+    }>>;
     <T extends z.ZodTypeAny>(client: Client, params: CvmIdInput, parameters: {
         schema: T;
     }): Promise<import("../..").SafeResult<z.TypeOf<T>>>;

package/dist/actions/cvms/provision_cvm.d.ts

@@ -34,7 +34,7 @@ import { type Client } from "../../client";
  *   disk_size: 10,
  *   compose_file: {
  *     docker_compose_file: docker_compose,
- *     name: 'my-app',
+ *     name: '',  // Internal field, use empty string
  *   },
  * };
  *

package/dist/actions/cvms/provision_cvm_compose_file_update.d.ts

@@ -214,6 +214,7 @@ export declare const ProvisionCvmComposeFileUpdateRequestSchema: z.ZodEffects<z.
 }>, {
     cvmId: string | undefined;
     request: {
+        update_env_vars: boolean | null | undefined;
         docker_compose_file: string;
         name?: string | undefined;
         public_sysinfo?: boolean | undefined;
@@ -226,10 +227,7 @@ export declare const ProvisionCvmComposeFileUpdateRequestSchema: z.ZodEffects<z.
         tproxy_enabled?: boolean | undefined;
         env_pubkey?: string | undefined;
         salt?: string | null | undefined;
-    } & {
-        [k: string]: unknown;
     };
-    update_env_vars: boolean | null | undefined;
     _raw: {
         app_compose: {
             docker_compose_file: string;

package/dist/client.d.ts

@@ -1,62 +1,130 @@
 import { ofetch, type FetchOptions, type FetchRequest } from "ofetch";
-import { type SafeResult, RequestError, type ClientConfig } from "./types/client";
+import { type Handler } from "mitt";
+import { type SafeResult, type ClientConfig } from "./types/client";
 import type { Prettify } from "./types/common";
+import { PhalaCloudError } from "./utils/errors";
 export type { SafeResult } from "./types/client";
+/**
+ * Client event types
+ */
+type ClientEvents = {
+    error: PhalaCloudError;
+};
 /**
  * HTTP Client class with ofetch compatibility
  */
 export declare class Client {
     protected fetchInstance: typeof ofetch;
     readonly config: ClientConfig;
+    private emitter;
     constructor(config?: ClientConfig);
     /**
      * Get the underlying ofetch instance for advanced usage
      */
     get raw(): import("ofetch").$Fetch;
     /**
-     * Perform GET request (throws on error)
+     * Listen for error events
+     * @param type - Event type ('error' or '*' for all events)
+     * @param handler - Event handler function
+     *
+     * @example
+     * ```typescript
+     * // Listen to error events
+     * client.on('error', (error) => {
+     *   console.error('API Error:', error.message);
+     * });
+     *
+     * // Listen to all events
+     * client.on('*', (type, error) => {
+     *   console.log('Event:', type, error);
+     * });
+     * ```
+     */
+    on<K extends keyof ClientEvents>(type: K, handler: Handler<ClientEvents[K]>): void;
+    on(type: "*", handler: Handler): void;
+    /**
+     * Remove event listener
+     * @param type - Event type ('error' or '*' for all events)
+     * @param handler - Event handler function to remove
+     *
+     * @example
+     * ```typescript
+     * const errorHandler = (error) => console.error(error);
+     * client.on('error', errorHandler);
+     * client.off('error', errorHandler);
+     * ```
+     */
+    off<K extends keyof ClientEvents>(type: K, handler?: Handler<ClientEvents[K]>): void;
+    off(type: "*", handler?: Handler): void;
+    /**
+     * Listen for event once (automatically removed after first trigger)
+     * @param type - Event type ('error' or '*' for all events)
+     * @param handler - Event handler function
+     *
+     * @example
+     * ```typescript
+     * client.once('error', (error) => {
+     *   console.error('First error:', error);
+     * });
+     * ```
+     */
+    once<K extends keyof ClientEvents>(type: K, handler: Handler<ClientEvents[K]>): void;
+    once(type: "*", handler: Handler): void;
+    /**
+     * Perform GET request (throws PhalaCloudError on error)
      */
     get<T = unknown>(request: FetchRequest, options?: Omit<FetchOptions, "method">): Promise<T>;
     /**
-     * Perform POST request (throws on error)
+     * Perform POST request (throws PhalaCloudError on error)
      */
     post<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<T>;
     /**
-     * Perform PUT request (throws on error)
+     * Perform PUT request (throws PhalaCloudError on error)
      */
     put<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<T>;
     /**
-     * Perform PATCH request (throws on error)
+     * Perform PATCH request (throws PhalaCloudError on error)
      */
     patch<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<T>;
     /**
-     * Perform DELETE request (throws on error)
+     * Perform DELETE request (throws PhalaCloudError on error)
      */
     delete<T = unknown>(request: FetchRequest, options?: Omit<FetchOptions, "method">): Promise<T>;
+    /**
+     * Convert any error to RequestError
+     */
+    private convertToRequestError;
+    /**
+     * Broadcast error to event listeners (fire-and-forget)
+     * @param requestError - The request error to handle
+     * @returns PhalaCloudError instance to throw immediately
+     */
+    private emitError;
     /**
      * Safe wrapper for any request method (zod-style result)
+     * Returns PhalaCloudError (all errors extend this base class)
      */
     private safeRequest;
     /**
      * Safe GET request (returns SafeResult)
      */
-    safeGet<T = unknown>(request: FetchRequest, options?: Omit<FetchOptions, "method">): Promise<SafeResult<T, RequestError>>;
+    safeGet<T = unknown>(request: FetchRequest, options?: Omit<FetchOptions, "method">): Promise<SafeResult<T, PhalaCloudError>>;
     /**
      * Safe POST request (returns SafeResult)
      */
-    safePost<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<SafeResult<T, RequestError>>;
+    safePost<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<SafeResult<T, PhalaCloudError>>;
     /**
      * Safe PUT request (returns SafeResult)
      */
-    safePut<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<SafeResult<T, RequestError>>;
+    safePut<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<SafeResult<T, PhalaCloudError>>;
     /**
      * Safe PATCH request (returns SafeResult)
      */
-    safePatch<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<SafeResult<T, RequestError>>;
+    safePatch<T = unknown>(request: FetchRequest, body?: RequestInit["body"] | Record<string, unknown>, options?: Omit<FetchOptions, "method" | "body">): Promise<SafeResult<T, PhalaCloudError>>;
     /**
      * Safe DELETE request (returns SafeResult)
      */
-    safeDelete<T = unknown>(request: FetchRequest, options?: Omit<FetchOptions, "method">): Promise<SafeResult<T, RequestError>>;
+    safeDelete<T = unknown>(request: FetchRequest, options?: Omit<FetchOptions, "method">): Promise<SafeResult<T, PhalaCloudError>>;
     /**
      * Extend client with additional actions
      *