@phala/cloud 0.1.1 → 0.2.0

package/dist/actions/index.d.ts

@@ -12,6 +12,7 @@ export { getCvmInfo, safeGetCvmInfo, CvmLegacyDetailSchema, GetCvmInfoRequestSch
 export { getCvmList, safeGetCvmList, GetCvmListSchema, GetCvmListRequestSchema, type GetCvmListRequest, type GetCvmListResponse, } from "./cvms/get_cvm_list";
 export { getKmsInfo, safeGetKmsInfo, GetKmsInfoRequestSchema, type GetKmsInfoRequest, } from "./kms/get_kms_info";
 export { getKmsList, safeGetKmsList, GetKmsListSchema, GetKmsListRequestSchema, type GetKmsListRequest, type GetKmsListResponse, } from "./kms/get_kms_list";
+export { nextAppIds, safeNextAppIds, NextAppIdsSchema, NextAppIdsRequestSchema, type NextAppIdsRequest, type NextAppIds, } from "./kms/next_app_ids";
 export { listWorkspaces, safeListWorkspaces, WorkspaceResponseSchema, ListWorkspacesSchema, PaginationMetadataSchema, type WorkspaceResponse, type ListWorkspaces, type PaginationMetadata, type ListWorkspacesRequest, } from "./workspaces/list_workspaces";
 export { getWorkspace, safeGetWorkspace, } from "./workspaces/get_workspace";
 export { listInstanceTypes, safeListInstanceTypes, PaginatedInstanceTypesSchema, InstanceTypeSchema, type PaginatedInstanceTypes, type InstanceType, type ListInstanceTypesRequest, ListInstanceTypesRequestSchema, } from "./list-instance-types";
@@ -23,7 +24,11 @@ export { deleteCvm, safeDeleteCvm, DeleteCvmRequestSchema, type DeleteCvmRequest
 export { getCvmStats, safeGetCvmStats, CvmSystemInfoSchema, GetCvmStatsRequestSchema, type GetCvmStatsRequest, type CvmSystemInfo, } from "./cvms/get_cvm_stats";
 export { getCvmContainersStats, safeGetCvmContainersStats, CvmContainersStatsSchema, GetCvmContainersStatsRequestSchema, type GetCvmContainersStatsRequest, type CvmContainersStats, } from "./cvms/get_cvm_containers_stats";
 export { getCvmNetwork, safeGetCvmNetwork, CvmNetworkSchema, GetCvmNetworkRequestSchema, type GetCvmNetworkRequest, type CvmNetwork, } from "./cvms/get_cvm_network";
+export { getCvmState, safeGetCvmState, CvmStateSchema, GetCvmStateRequestSchema, type GetCvmStateRequest, type CvmState, } from "./cvms/get_cvm_state";
+export { watchCvmState, WatchCvmStateRequestSchema, type WatchCvmStateRequest, type WatchCvmStateOptions, type SSEEvent, WatchAbortedError, MaxRetriesExceededError, } from "./cvms/watch_cvm_state";
 export { getCvmAttestation, safeGetCvmAttestation, CvmAttestationSchema, GetCvmAttestationRequestSchema, type GetCvmAttestationRequest, type CvmAttestation, } from "./cvms/get_cvm_attestation";
 export { getCvmDockerCompose, safeGetCvmDockerCompose, GetCvmDockerComposeRequestSchema, type GetCvmDockerComposeRequest, } from "./cvms/get_cvm_docker_compose";
 export { updateCvmResources, safeUpdateCvmResources, UpdateCvmResourcesRequestSchema, type UpdateCvmResourcesRequest, } from "./cvms/update_cvm_resources";
 export { updateCvmVisibility, safeUpdateCvmVisibility, UpdateCvmVisibilityRequestSchema, type UpdateCvmVisibilityRequest, } from "./cvms/update_cvm_visibility";
+export { getAvailableOsImages, safeGetAvailableOsImages, OSImageVariantSchema, GetAvailableOSImagesResponseSchema, GetAvailableOSImagesRequestSchema, type OSImageVariant, type GetAvailableOSImagesResponse, type GetAvailableOSImagesRequest, } from "./cvms/get_available_os_images";
+export { updateOsImage, safeUpdateOsImage, UpdateOsImageRequestSchema, type UpdateOsImageRequest, } from "./cvms/update_os_image";

package/dist/actions/kms/next_app_ids.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { type Client } from "../../client";
+export declare const NextAppIdsRequestSchema: z.ZodObject<{
+    counts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    counts: number;
+}, {
+    counts?: number | undefined;
+}>;
+export declare const NextAppIdsSchema: z.ZodObject<{
+    app_ids: z.ZodArray<z.ZodObject<{
+        app_id: z.ZodString;
+        nonce: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        nonce: number;
+        app_id: string;
+    }, {
+        nonce: number;
+        app_id: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    app_ids: {
+        nonce: number;
+        app_id: string;
+    }[];
+}, {
+    app_ids: {
+        nonce: number;
+        app_id: string;
+    }[];
+}>;
+export type NextAppIdsRequest = z.infer<typeof NextAppIdsRequestSchema>;
+export type NextAppIds = z.infer<typeof NextAppIdsSchema>;
+declare const nextAppIds: {
+    (client: Client, params: {
+        counts: number;
+    }): Promise<{
+        app_ids: {
+            nonce: number;
+            app_id: string;
+        }[];
+    }>;
+    <T extends z.ZodTypeAny>(client: Client, params: {
+        counts: number;
+    }, parameters: {
+        schema: T;
+    }): Promise<z.TypeOf<T>>;
+    (client: Client, params: {
+        counts: number;
+    }, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+}, safeNextAppIds: {
+    (client: Client, params: {
+        counts: number;
+    }): Promise<import("../..").SafeResult<{
+        app_ids: {
+            nonce: number;
+            app_id: string;
+        }[];
+    }>>;
+    <T extends z.ZodTypeAny>(client: Client, params: {
+        counts: number;
+    }, parameters: {
+        schema: T;
+    }): Promise<import("../..").SafeResult<z.TypeOf<T>>>;
+    (client: Client, params: {
+        counts: number;
+    }, parameters: {
+        schema: false;
+    }): Promise<import("../..").SafeResult<unknown>>;
+};
+export { nextAppIds, safeNextAppIds };

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
      *

package/dist/create-client.d.ts

@@ -15,6 +15,7 @@ import { type CommitCvmComposeFileUpdateRequest, type CommitCvmComposeFileUpdate
 import { type GetKmsInfoRequest } from "./actions/kms/get_kms_info";
 import { type GetKmsListRequest, type GetKmsListResponse } from "./actions/kms/get_kms_list";
 import { type GetAppEnvEncryptPubKeyRequest, type GetAppEnvEncryptPubKey as GetAppEnvEncryptPubKeyResult } from "./actions/kms/get_app_env_encrypt_pubkey";
+import { type NextAppIdsRequest, type NextAppIds } from "./actions/kms/next_app_ids";
 import { type StartCvmRequest } from "./actions/cvms/start_cvm";
 import { type StopCvmRequest } from "./actions/cvms/stop_cvm";
 import { type ShutdownCvmRequest } from "./actions/cvms/shutdown_cvm";
@@ -27,6 +28,9 @@ import { type GetCvmContainersStatsRequest, type CvmContainersStats } from "./ac
 import { type GetCvmAttestationRequest, type CvmAttestation } from "./actions/cvms/get_cvm_attestation";
 import { type UpdateCvmResourcesRequest } from "./actions/cvms/update_cvm_resources";
 import { type UpdateCvmVisibilityRequest } from "./actions/cvms/update_cvm_visibility";
+import { type GetAvailableOSImagesRequest, type GetAvailableOSImagesResponse } from "./actions/cvms/get_available_os_images";
+import { type UpdateOsImageRequest } from "./actions/cvms/update_os_image";
+import { type GetCvmStateRequest, type CvmState } from "./actions/cvms/get_cvm_state";
 import type { KmsInfo } from "./types/kms_info";
 import type { VM } from "./types/cvm_info";
 import type { SafeResult } from "./types/client";
@@ -277,6 +281,20 @@ export interface Client extends BaseClient {
     safeGetAppEnvEncryptPubKey(request: GetAppEnvEncryptPubKeyRequest, parameters: {
         schema: false;
     }): Promise<SafeResult<unknown>>;
+    nextAppIds(request?: NextAppIdsRequest): Promise<NextAppIds>;
+    nextAppIds<T extends z.ZodTypeAny>(request: NextAppIdsRequest | undefined, parameters: {
+        schema: T;
+    }): Promise<z.infer<T>>;
+    nextAppIds(request: NextAppIdsRequest | undefined, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+    safeNextAppIds(request?: NextAppIdsRequest): Promise<SafeResult<NextAppIds>>;
+    safeNextAppIds<T extends z.ZodTypeAny>(request: NextAppIdsRequest | undefined, parameters: {
+        schema: T;
+    }): Promise<SafeResult<z.infer<T>>>;
+    safeNextAppIds(request: NextAppIdsRequest | undefined, parameters: {
+        schema: false;
+    }): Promise<SafeResult<unknown>>;
     startCvm(request: StartCvmRequest): Promise<VM>;
     startCvm<T extends z.ZodTypeAny>(request: StartCvmRequest, parameters: {
         schema: T;
@@ -445,4 +463,46 @@ export interface Client extends BaseClient {
     safeUpdateCvmVisibility(request: UpdateCvmVisibilityRequest, parameters: {
         schema: false;
     }): Promise<SafeResult<unknown>>;
+    getAvailableOsImages(request: GetAvailableOSImagesRequest): Promise<GetAvailableOSImagesResponse>;
+    getAvailableOsImages<T extends z.ZodTypeAny>(request: GetAvailableOSImagesRequest, parameters: {
+        schema: T;
+    }): Promise<z.infer<T>>;
+    getAvailableOsImages(request: GetAvailableOSImagesRequest, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+    safeGetAvailableOsImages(request: GetAvailableOSImagesRequest): Promise<SafeResult<GetAvailableOSImagesResponse>>;
+    safeGetAvailableOsImages<T extends z.ZodTypeAny>(request: GetAvailableOSImagesRequest, parameters: {
+        schema: T;
+    }): Promise<SafeResult<z.infer<T>>>;
+    safeGetAvailableOsImages(request: GetAvailableOSImagesRequest, parameters: {
+        schema: false;
+    }): Promise<SafeResult<unknown>>;
+    updateOsImage(request: UpdateOsImageRequest): Promise<void>;
+    updateOsImage<T extends z.ZodTypeAny>(request: UpdateOsImageRequest, parameters: {
+        schema: T;
+    }): Promise<z.infer<T>>;
+    updateOsImage(request: UpdateOsImageRequest, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+    safeUpdateOsImage(request: UpdateOsImageRequest): Promise<SafeResult<void>>;
+    safeUpdateOsImage<T extends z.ZodTypeAny>(request: UpdateOsImageRequest, parameters: {
+        schema: T;
+    }): Promise<SafeResult<z.infer<T>>>;
+    safeUpdateOsImage(request: UpdateOsImageRequest, parameters: {
+        schema: false;
+    }): Promise<SafeResult<unknown>>;
+    getCvmState(request: GetCvmStateRequest): Promise<CvmState>;
+    getCvmState<T extends z.ZodTypeAny>(request: GetCvmStateRequest, parameters: {
+        schema: T;
+    }): Promise<z.infer<T>>;
+    getCvmState(request: GetCvmStateRequest, parameters: {
+        schema: false;
+    }): Promise<unknown>;
+    safeGetCvmState(request: GetCvmStateRequest): Promise<SafeResult<CvmState>>;
+    safeGetCvmState<T extends z.ZodTypeAny>(request: GetCvmStateRequest, parameters: {
+        schema: T;
+    }): Promise<SafeResult<z.infer<T>>>;
+    safeGetCvmState(request: GetCvmStateRequest, parameters: {
+        schema: false;
+    }): Promise<SafeResult<unknown>>;
 }