@phala/cloud 0.1.1 → 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/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
      *