@hyperbrowser/sdk 0.93.0 → 1.0.0

package/dist/services/volumes.js

@@ -1,24 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VolumesService = void 0;
-const client_1 = require("../client");
+const error_1 = require("../error");
+const normalize_1 = require("./normalize");
 const base_1 = require("./base");
+const normalizeVolume = (volume) => ({
+    ...volume,
+    size: (0, normalize_1.optionalInteger)(volume.size),
+    transferAmount: (0, normalize_1.optionalInteger)(volume.transferAmount),
+});
 class VolumesService extends base_1.BaseService {
     /**
      * Create a new sandbox volume.
      */
     async create(params) {
         try {
-            return await this.request("/volume", {
+            return normalizeVolume(await this.request("/volume", {
                 method: "POST",
                 body: JSON.stringify(params),
-            });
+            }));
         }
         catch (error) {
-            if (error instanceof client_1.HyperbrowserError) {
+            if (error instanceof error_1.HyperbrowserError) {
                 throw error;
             }
-            throw new client_1.HyperbrowserError("Failed to create volume", undefined);
+            throw new error_1.HyperbrowserError("Failed to create volume", undefined);
         }
     }
     /**
@@ -26,17 +32,24 @@ class VolumesService extends base_1.BaseService {
      */
     async list(params = {}) {
         try {
-            return await this.request("/volume", undefined, {
+            const response = await this.request("/volume", undefined, {
                 search: params.search,
                 page: params.page,
                 limit: params.limit,
             });
+            return {
+                ...response,
+                volumes: response.volumes.map(normalizeVolume),
+                totalCount: (0, normalize_1.optionalInteger)(response.totalCount),
+                page: (0, normalize_1.optionalInteger)(response.page),
+                perPage: (0, normalize_1.optionalInteger)(response.perPage),
+            };
         }
         catch (error) {
-            if (error instanceof client_1.HyperbrowserError) {
+            if (error instanceof error_1.HyperbrowserError) {
                 throw error;
             }
-            throw new client_1.HyperbrowserError("Failed to list volumes", undefined);
+            throw new error_1.HyperbrowserError("Failed to list volumes", undefined);
         }
     }
     /**
@@ -44,13 +57,13 @@ class VolumesService extends base_1.BaseService {
      */
     async get(id) {
         try {
-            return await this.request(`/volume/${id}`);
+            return normalizeVolume(await this.request(`/volume/${id}`));
         }
         catch (error) {
-            if (error instanceof client_1.HyperbrowserError) {
+            if (error instanceof error_1.HyperbrowserError) {
                 throw error;
             }
-            throw new client_1.HyperbrowserError(`Failed to get volume ${id}`, undefined);
+            throw new error_1.HyperbrowserError(`Failed to get volume ${id}`, undefined);
         }
     }
     /**
@@ -60,13 +73,15 @@ class VolumesService extends base_1.BaseService {
      */
     async delete(key) {
         try {
-            return await this.request(`/volume/${encodeURIComponent(key)}`, { method: "DELETE" });
+            return await this.request(`/volume/${encodeURIComponent(key)}`, {
+                method: "DELETE",
+            });
         }
         catch (error) {
-            if (error instanceof client_1.HyperbrowserError) {
+            if (error instanceof error_1.HyperbrowserError) {
                 throw error;
             }
-            throw new client_1.HyperbrowserError(`Failed to delete volume ${key}`, undefined);
+            throw new error_1.HyperbrowserError(`Failed to delete volume ${key}`, undefined);
         }
     }
 }

package/dist/types/index.d.ts

@@ -11,7 +11,7 @@ export { StartGrokComputerUseTaskParams, StartGrokComputerUseTaskResponse, GrokC
 export { StartMetaComputerUseTaskParams, StartMetaComputerUseTaskResponse, MetaComputerUseTaskStatusResponse, MetaComputerUseTaskResponse, MetaComputerUseTaskData, MetaComputerUseStepResponse, MetaComputerUseStepError, MetaComputerUseStepIncompleteDetails, MetaComputerUseStepReasoning, MetaComputerUseApiKeys, MetaComputerUseTaskMetadata, } from "./agents/meta-computer-use";
 export { StartJevComputerUseTaskParams, StartJevComputerUseTaskResponse, JevComputerUseTaskStatusResponse, JevComputerUseTaskResponse, JevComputerUseTaskData, JevComputerUseStepResponse, JevComputerUseApiKeys, JevComputerUseTaskMetadata, } from "./agents/jev-computer-use";
 export { BasicResponse, BrowserMemorySize, SessionStatus, Session, SessionDetail, SessionGetParams, SessionListParams, SessionListResponse, ScreenConfig, CaptchaEvaluationPageResult, CaptchaEvaluationParams, CaptchaEvaluationResponse, CaptchaEvaluationTarget, CaptchaEvaluationType, CaptchaSolverType, CreateSessionParams, CreateSessionSnapshotResponse, GetSessionDownloadsUrlResponse, GetSessionVideoRecordingUrlResponse, GetSessionRecordingUrlResponse, ImageCaptchaParam, UploadFileResponse, UploadFileOptions, GetActiveSessionsCountResponse, SessionEventLogListParams, SessionEventLogListResponse, SessionEventLog, SessionProfile, SessionLaunchState, SessionCreditBreakdown, StartSessionFromSnapshotParams, UpdateSessionProfileParams, UpdateSessionProxyLocationParams, UpdateSessionProxyParams, UpdateSessionScreenParams, UpdateSessionSolveCaptchasParams, UpdateSessionSolveCaptchasResponse, } from "./session";
-export { SandboxStatus, SandboxRuntimeTarget, SandboxNetworkPolicy, SandboxNetworkPolicyPatch, SandboxNetworkUpdateResult, Sandbox, SandboxDetail, SandboxVolumeMountType, SandboxVolumeMount, SandboxListParams, SandboxListResponse, SandboxImageSource, SandboxImageSummary, SandboxImageListParams, SandboxImageListResponse, SandboxSnapshotStatus, SandboxSnapshotSummary, SandboxSnapshotListParams, SandboxSnapshotListResponse, SandboxSnapshotDeleteResult, SandboxImageDeleteResult, SandboxImageBuildStatus, SandboxImageBuildUpload, SandboxImageBuild, CreateSandboxImageBuildParams, CompleteSandboxImageBuildParams, SandboxImageBuildCreateResult, SandboxImageBuildListParams, SandboxImageBuildListResponse, CreateSandboxParams, SandboxMemorySnapshotParams, SandboxMemorySnapshotResult, SandboxExposeParams, SandboxExposeResult, SandboxUnexposeResult, SandboxProcessStatus, SandboxExecParams, SandboxExecOptions, SandboxProcessSummary, SandboxProcessResult, SandboxProcessListParams, SandboxProcessListResponse, SandboxProcessWaitParams, SandboxProcessSignal, SandboxProcessStdinParams, SandboxProcessStreamEvent, SandboxFileType, SandboxFileInfo, SandboxFileWriteInfo, SandboxFileListOptions, SandboxFileReadFormat, SandboxFileReadOptions, SandboxFileWriteData, SandboxFileWriteEntry, SandboxFileTextWriteOptions, SandboxFileBytesWriteOptions, SandboxFileMakeDirOptions, SandboxFileCopyParams, SandboxFileChmodParams, SandboxFileChownParams, SandboxFileTransferResult, SandboxFileSystemEventType, SandboxFileSystemEvent, SandboxWatchDirOptions, SandboxPresignFileParams, SandboxPresignedUrl, SandboxTerminalCreateParams, SandboxTerminalOutputChunk, SandboxTerminalStatus, SandboxTerminalWaitParams, SandboxTerminalKillParams, SandboxTerminalEvent, } from "./sandbox";
+export { SandboxStatus, SandboxRuntimeTarget, SandboxNetworkPolicy, SandboxNetworkPolicyPatch, SandboxNetworkUpdateResult, Sandbox, SandboxDetail, SandboxVolumeMountType, SandboxVolumeMount, SandboxListParams, SandboxListResponse, SandboxImageSource, SandboxImageSummary, SandboxImageListParams, SandboxImageListResponse, SandboxSnapshotStatus, SandboxSnapshotSummary, SandboxSnapshotListParams, SandboxSnapshotListResponse, SandboxSnapshotDeleteResult, SandboxImageDeleteResult, SandboxImageInit, SandboxImageBuildStatus, SandboxImageBuildInputFormat, SandboxImageBuildSourcePlatform, SandboxImageBuildUpload, SandboxImageBuild, SandboxBuildContextBundle, SandboxBuildContextMode, SandboxBuildContextManifest, SandboxDockerImageConfig, SandboxDockerImageLayer, SandboxDockerImageManifest, CreateSandboxImageBuildParams, ReuseSandboxDockerImageParams, CompleteSandboxImageBuildParams, SandboxImageBuildCreateResult, SandboxDockerImageReuseResult, SandboxImageBuildResolutionOutcome, SandboxImageBuildResolution, SandboxImageBuildWaitOptions, BuildSandboxImageFromDockerImageOptions, BuildSandboxImageFromDockerfileOptions, GetOrBuildSandboxImageOptions, SandboxImageBuildListParams, SandboxImageBuildListResponse, CreateSandboxParams, SandboxMemorySnapshotParams, SandboxMemorySnapshotResult, SandboxExposeParams, SandboxExposeResult, SandboxUnexposeResult, SandboxProcessStatus, SandboxExecParams, SandboxExecOptions, SandboxProcessSummary, SandboxProcessResult, SandboxProcessListParams, SandboxProcessListResponse, SandboxProcessWaitParams, SandboxProcessSignal, SandboxProcessStdinParams, SandboxProcessOutputEvent, SandboxProcessExitEvent, SandboxProcessStreamEvent, SandboxFileType, SandboxFileInfo, SandboxFileWriteInfo, SandboxFileListOptions, SandboxFileReadFormat, SandboxFileReadOptions, SandboxFileWriteData, SandboxFileWriteEntry, SandboxFileTextWriteOptions, SandboxFileBytesWriteOptions, SandboxFileMakeDirOptions, SandboxFileCopyParams, SandboxFileChmodParams, SandboxFileChownParams, SandboxFileTransferResult, SandboxFileSystemEventType, SandboxFileSystemEvent, SandboxWatchDirOptions, SandboxPresignFileParams, SandboxPresignedUrl, SandboxTerminalCreateParams, SandboxTerminalOutputChunk, SandboxTerminalStatus, SandboxTerminalWaitParams, SandboxTerminalKillParams, SandboxTerminalEvent, } from "./sandbox";
 export { CreateVolumeParams, Volume, VolumeListParams, VolumeListResponse, VolumeDeleteResult, } from "./volume";
 export { CreateProfileParams, ForkProfileParams, ProfileResponse, CreateProfileResponse, ProfileListParams, ProfileListResponse, } from "./profile";
 export { CreateExtensionParams, CreateExtensionResponse, ListExtensionsResponse, } from "./extension";
@@ -23,3 +23,4 @@ export { StartBatchFetchJobParams, GetBatchFetchJobParams, StartBatchFetchJobRes
 export { WebSearchParams, WebSearchResponse, WebSearchResponseData, WebSearchResultItem, WebSearchFilters, WebSearchLocation, WebSearchFiletype, WebSearchStatus, } from "./web/search";
 export { FetchStealthMode, FetchSanitizeMode, FetchWaitUntil, FetchScreenshotFormat, PageStatus, FetchOutputScreenshotOptions, FetchStorageStateOptions, FetchBrowserLocationOptions, PageData, FetchOutputMarkdown, FetchOutputHtml, FetchOutputLinks, FetchOutputScreenshot, FetchOutputJsonOptions, FetchOutputJson, FetchOutputBranding, FetchOutputFormat, FetchOutputOptions, FetchBrowserOptions, FetchNavigationOptions, FetchCacheOptions, } from "./web/common";
 export { BrandingProfile, BrandingColors, BrandingFont, BrandingFontRole, BrandingTypography, BrandingFontFamilies, BrandingFontStacks, BrandingFontSizes, BrandingSpacing, BrandingComponents, BrandingButtonStyle, BrandingInputStyle, BrandingBorderRadiusCorners, BrandingImages, BrandingPersonality, BrandingPersonalityTone, BrandingPersonalityEnergy, BrandingDesignSystem, BrandingDesignFramework, BrandingConfidence, BrandingColorScheme, } from "./web/branding";
+export type { StartSandboxFromSnapshotParams, SandboxRuntimeSession, SandboxFileUploadStream, SandboxFileUploadStreamOptions, SandboxFileDownloadStreamOptions, SandboxFileMoveParams, SandboxFileRenameOptions, SandboxFileWatchParams, SandboxFileWatchEvent, SandboxFileWatchStatus, SandboxFileWatchEventsParams, SandboxFileWatchStreamEvent, } from "./sandbox";

package/dist/types/sandbox.d.ts

@@ -4,7 +4,7 @@ import { SessionRegion } from "./constants";
 import { SessionLaunchState, SessionStatus } from "./session";
 export type SandboxStatus = SessionStatus;
 export interface SandboxNetworkPolicy {
-    allowInternetAccess: boolean;
+    allowInternetAccess?: boolean | null;
     allowOut: string[];
     denyOut: string[];
 }
@@ -22,6 +22,18 @@ export interface SandboxRuntimeTarget {
     baseUrl: string;
 }
 export interface Sandbox {
+    runtimeClass?: "firecracker" | "gvisor-cpu";
+    capabilities?: {
+        commands: boolean;
+        files: boolean;
+        pty: boolean;
+        gpu: boolean;
+        snapshots: boolean;
+        volumes: boolean;
+        exposedPorts: boolean;
+        internetAccess: boolean;
+        writableStorage: "memory";
+    };
     id: string;
     teamId: string;
     status: SandboxStatus;
@@ -30,21 +42,21 @@ export interface Sandbox {
     createdAt: string;
     updatedAt: string;
     closeReason?: string | null;
-    dataConsumed?: number;
-    proxyDataConsumed?: number;
-    usageType?: string;
+    dataConsumed?: number | null;
+    proxyDataConsumed?: number | null;
+    usageType?: string | null;
     jobId?: string | null;
     launchState?: SessionLaunchState | null;
     creditsUsed: number | null;
     region: SessionRegion;
     sessionUrl: string;
     duration: number;
-    proxyBytesUsed: number;
+    proxyBytesUsed?: number | null;
     cpu?: number | null;
     memoryMiB?: number | null;
     diskMiB?: number | null;
     timeoutMinutes?: number | null;
-    network?: SandboxNetworkPolicy;
+    network?: SandboxNetworkPolicy | null;
     runtime: SandboxRuntimeTarget;
     exposedPorts: SandboxExposeResult[];
 }
@@ -59,6 +71,7 @@ export interface SandboxVolumeMount {
     shared?: boolean;
 }
 interface SandboxCreateCommonParams {
+    runtimeClass?: "firecracker" | "gvisor-cpu";
     region?: SessionRegion;
     enableRecording?: boolean;
     exposedPorts?: SandboxExposeParams[];
@@ -100,13 +113,20 @@ export interface SandboxListResponse {
     perPage: number;
 }
 export type SandboxImageSource = "public" | "team";
+export interface SandboxImageInit {
+    env?: Record<string, string>;
+    command?: string;
+    args?: string[];
+    workingDir?: string;
+}
 export interface SandboxImageSummary {
     id: string;
     imageName: string;
     namespace: string;
     source?: SandboxImageSource;
-    imageInit?: Record<string, unknown> | null;
+    imageInit?: SandboxImageInit | Record<string, unknown> | null;
     uploaded: boolean;
+    ready?: boolean | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -134,7 +154,7 @@ export interface SandboxSnapshotSummary {
     vcpus?: number | null;
     memMiB?: number | null;
     diskSizeMiB?: number | null;
-    compatibilityTag: string;
+    compatibilityTag?: string | null;
     metadata: Record<string, unknown>;
     uploaded: boolean;
     createdAt: string;
@@ -163,7 +183,10 @@ export interface SandboxImageDeleteResult {
     uploaded?: boolean;
 }
 export type SandboxImageBuildStatus = "awaiting_upload" | "upload_verified" | "dispatching" | "building" | "verifying" | "completed" | "failed" | "canceled";
+export type SandboxImageBuildInputFormat = "rootfs_export_tar_gz" | "dockerfile_context_tar_gz" | "dockerfile_context_manifest_v1" | "docker_image_manifest_v1";
+export type SandboxImageBuildSourcePlatform = "linux/amd64";
 export interface SandboxImageBuildUpload {
+    sha256?: string | null;
     url: string;
     method: string;
     headers: Record<string, string>;
@@ -193,27 +216,150 @@ export interface SandboxImageBuild {
     createdAt?: string | null;
     updatedAt?: string | null;
 }
+export interface SandboxBuildContextBundle {
+    sha256: string;
+    sizeBytes: number;
+    uncompressedSizeBytes: number;
+    entryCount: number;
+}
+export type SandboxBuildContextMode = "sparse" | "full";
+export interface SandboxBuildContextManifest {
+    version: 1;
+    dockerfilePath: string;
+    contextMode: SandboxBuildContextMode;
+    fallbackReason?: string;
+    bundles: SandboxBuildContextBundle[];
+}
+export interface SandboxDockerImageConfig {
+    sha256: string;
+    sizeBytes: number;
+    dataBase64: string;
+}
+export interface SandboxDockerImageLayer {
+    sha256: string;
+    sizeBytes: number;
+}
+export interface SandboxDockerImageManifest {
+    version: 1;
+    imageDigest: string;
+    descriptor?: SandboxDockerImageConfig;
+    config: SandboxDockerImageConfig;
+    layers: SandboxDockerImageLayer[];
+}
 export interface CreateSandboxImageBuildParams {
     imageName: string;
     inputSha256: string;
     inputSizeBytes: number;
-    inputFormat?: "rootfs_export_tar_gz";
-    sourcePlatform?: "linux/amd64";
+    /** Builder vCPUs (sent as `vcpus`). */
+    builderCpus?: number;
+    /** Builder memory in MiB (sent as `memMiB`). */
+    builderMemoryMiB?: number;
+    /** Builder scratch disk in MiB (sent as `scratchMiB`). */
+    builderScratchMiB?: number;
+    inputFormat?: SandboxImageBuildInputFormat;
+    sourcePlatform?: SandboxImageBuildSourcePlatform;
     imageConfigUser?: string;
-    imageInit?: {
-        env?: Record<string, string>;
-        command?: string;
-        args?: string[];
-    };
+    imageInit?: SandboxImageInit;
+    dockerfilePath?: string;
+    contextManifest?: SandboxBuildContextManifest;
+    dockerImageManifest?: SandboxDockerImageManifest;
+}
+export interface ReuseSandboxDockerImageParams {
+    imageName: string;
+    sourceImageDigest: string;
+    sourcePlatform?: SandboxImageBuildSourcePlatform;
+    imageConfigUser?: string;
+    imageInit?: SandboxImageInit;
 }
 export interface CompleteSandboxImageBuildParams {
     inputSha256: string;
     inputSizeBytes: number;
-    inputFormat?: "rootfs_export_tar_gz";
+    inputFormat?: SandboxImageBuildInputFormat;
 }
 export interface SandboxImageBuildCreateResult {
     build: SandboxImageBuild;
-    upload: SandboxImageBuildUpload;
+    upload?: SandboxImageBuildUpload | null;
+    uploads?: SandboxImageBuildUpload[];
+}
+export interface SandboxDockerImageReuseResult {
+    hit: boolean;
+    build?: SandboxImageBuild | null;
+}
+export type SandboxImageBuildResolutionOutcome = "reused" | "joined" | "created";
+/**
+ * The result of resolving content-derived image inputs.
+ *
+ * `imageId` is populated only for a ready image. With `wait: false`, `build`
+ * identifies the submitted or joined build, which the caller can poll later.
+ */
+export interface SandboxImageBuildResolution {
+    outcome: SandboxImageBuildResolutionOutcome;
+    imageName: string;
+    imageId?: string;
+    build?: SandboxImageBuild;
+}
+export interface SandboxImageBuildWaitOptions {
+    signal?: AbortSignal;
+    /** Seconds between status polls. Defaults to 3. */
+    pollInterval?: number;
+    /** Seconds to wait before giving up. `null` waits forever. Defaults to 35 minutes. */
+    timeout?: number | null;
+}
+interface SandboxImageBuildCommonOptions {
+    /** Cancel this caller's polling; accepted builds and uploads continue independently. */
+    signal?: AbortSignal;
+    imageName: string;
+    platform?: string;
+    imageInit?: SandboxImageInit;
+    imageConfigUser?: string;
+    builderCpus?: number;
+    builderMemoryMiB?: number;
+    builderScratchMiB?: number;
+    /** Wait for the build to complete. Defaults to true. */
+    wait?: boolean;
+    pollInterval?: number;
+    waitTimeout?: number | null;
+    /** Directory for temporary packaging artifacts. */
+    tempDir?: string;
+    /** Per-upload inactivity timeout in seconds. */
+    uploadTimeout?: number | null;
+}
+export interface BuildSandboxImageFromDockerImageOptions extends SandboxImageBuildCommonOptions {
+    dockerImage: string;
+    expectedImageDigest?: string;
+}
+export interface BuildSandboxImageFromDockerfileOptions extends SandboxImageBuildCommonOptions {
+    contextPath: string;
+    dockerfile?: string;
+    /** Send the build context to Hyperbrowser (default) instead of building with local Docker. */
+    remote?: boolean;
+    remoteFullContext?: boolean;
+    expectedContextFingerprint?: string;
+    dockerTag?: string;
+    buildArgs?: Record<string, string>;
+}
+export interface GetOrBuildSandboxImageOptions {
+    /** Cancel this caller's polling; accepted builds and uploads continue independently. */
+    signal?: AbortSignal;
+    contextPath?: string;
+    dockerImage?: string;
+    imageNamePrefix?: string;
+    dockerfile?: string;
+    platform?: string;
+    remoteFullContext?: boolean;
+    expectedContextFingerprint?: string;
+    expectedImageDigest?: string;
+    imageInit?: SandboxImageInit;
+    imageConfigUser?: string;
+    builderCpus?: number;
+    builderMemoryMiB?: number;
+    builderScratchMiB?: number;
+    forceBuild?: boolean;
+    wait?: boolean;
+    pollInterval?: number;
+    waitTimeout?: number | null;
+    uploadTimeout?: number | null;
+    tempDir?: string;
 }
 export interface SandboxImageBuildListParams {
     status?: SandboxImageBuildStatus;
@@ -242,7 +388,7 @@ export interface SandboxExposeResult {
     port: number;
     auth: boolean;
     url: string;
-    browserUrl?: string;
+    browserUrl?: string | null;
     browserUrlExpiresAt?: string | null;
 }
 export interface SandboxUnexposeResult {
@@ -251,7 +397,11 @@ export interface SandboxUnexposeResult {
 }
 export type SandboxProcessStatus = "queued" | "running" | "exited" | "failed" | "killed" | "timed_out";
 export interface SandboxExecParams {
+    /** Cancel local collection without killing the detached command. */
+    signal?: AbortSignal;
     command: string;
+    /** Maximum combined stdout/stderr bytes collected locally. Defaults to 64 MiB. */
+    maxOutputBytes?: number;
     /** @deprecated Legacy compatibility only. Converted into a single shell command string. */
     args?: string[];
     cwd?: string;
@@ -267,12 +417,12 @@ export interface SandboxProcessSummary {
     id: string;
     status: SandboxProcessStatus;
     command: string;
-    args?: string[];
+    args?: string[] | null;
     cwd: string;
-    pid?: number;
+    pid?: number | null;
     exitCode?: number | null;
     startedAt: number;
-    completedAt?: number;
+    completedAt?: number | null;
 }
 export interface SandboxProcessResult {
     id: string;
@@ -281,8 +431,10 @@ export interface SandboxProcessResult {
     stdout: string;
     stderr: string;
     startedAt: number;
-    completedAt?: number;
-    error?: string;
+    completedAt?: number | null;
+    error?: string | null;
+    outputTruncated?: boolean;
+    lastSeq?: number | null;
 }
 export interface SandboxProcessListParams {
     status?: SandboxProcessStatus | SandboxProcessStatus[];
@@ -305,15 +457,17 @@ export interface SandboxProcessStdinParams {
     encoding?: "utf8" | "base64";
     eof?: boolean;
 }
-export type SandboxProcessStreamEvent = {
+export interface SandboxProcessOutputEvent {
     type: "stdout" | "stderr" | "system";
     seq: number;
     data: string;
     timestamp: number;
-} | {
+}
+export interface SandboxProcessExitEvent {
     type: "exit";
     result: SandboxProcessResult;
-};
+}
+export type SandboxProcessStreamEvent = SandboxProcessOutputEvent | SandboxProcessExitEvent;
 export type SandboxFileType = "file" | "dir";
 export interface SandboxFileInfo {
     path: string;
@@ -426,17 +580,17 @@ export interface SandboxTerminalOutputChunk {
 export interface SandboxTerminalStatus {
     id: string;
     command: string;
-    args?: string[];
+    args?: string[] | null;
     cwd: string;
-    pid?: number;
+    pid?: number | null;
     running: boolean;
     exitCode?: number | null;
-    error?: string;
+    error?: string | null;
     timedOut?: boolean;
     rows: number;
     cols: number;
     startedAt: number;
-    finishedAt?: number;
+    finishedAt?: number | null;
     output?: SandboxTerminalOutputChunk[];
 }
 export interface SandboxTerminalWaitParams {
@@ -453,4 +607,66 @@ export type SandboxTerminalEvent = ({
     type: "exit";
     status: SandboxTerminalStatus;
 };
+/** True streaming transfer inputs; strings in iterable chunks are UTF-8. */
+export type SandboxFileUploadStream = AsyncIterable<Uint8Array | string> | Iterable<Uint8Array | string>;
+export interface SandboxFileUploadStreamOptions {
+    contentLength?: number;
+    signal?: AbortSignal;
+}
+export interface SandboxFileDownloadStreamOptions {
+    signal?: AbortSignal;
+}
+export interface SandboxFileMoveParams {
+    source: string;
+    destination: string;
+    overwrite?: boolean;
+}
+export interface SandboxFileRenameOptions {
+    overwrite?: boolean;
+}
+export interface SandboxFileWatchParams {
+    recursive?: boolean;
+}
+export interface SandboxFileWatchEvent {
+    seq: number;
+    path: string;
+    op: string;
+    timestamp: number;
+}
+export interface SandboxFileWatchStatus {
+    id: string;
+    path: string;
+    recursive: boolean;
+    active: boolean;
+    error?: string | null;
+    createdAt: number;
+    stoppedAt?: number | null;
+    oldestSeq?: number;
+    lastSeq?: number;
+    eventCount?: number;
+    events?: SandboxFileWatchEvent[] | null;
+}
+export interface SandboxFileWatchEventsParams {
+    cursor?: number;
+    route?: "ws" | "stream";
+    signal?: AbortSignal;
+}
+export type SandboxFileWatchStreamEvent = {
+    type: "event";
+    event: SandboxFileWatchEvent;
+} | {
+    type: "done";
+    status: SandboxFileWatchStatus;
+};
+export type StartSandboxFromSnapshotParams = Extract<CreateSandboxParams, {
+    snapshotName: string;
+}>;
+export interface SandboxRuntimeSession {
+    sandboxId: string;
+    status: SandboxStatus;
+    region: SessionRegion;
+    token: string;
+    tokenExpiresAt: string | null;
+    runtime: SandboxRuntimeTarget;
+}
 export {};

package/dist/types/volume.d.ts

@@ -4,8 +4,8 @@ export interface CreateVolumeParams {
 export interface Volume {
     id: string;
     name: string;
-    size?: number;
-    transferAmount?: number;
+    size?: number | null;
+    transferAmount?: number | null;
 }
 export interface VolumeListParams {
     search?: string;
@@ -14,12 +14,12 @@ export interface VolumeListParams {
 }
 export interface VolumeListResponse {
     volumes: Volume[];
-    totalCount?: number;
-    page?: number;
-    perPage?: number;
+    totalCount?: number | null;
+    page?: number | null;
+    perPage?: number | null;
 }
 export interface VolumeDeleteResult {
     deleted: boolean;
-    id?: string;
-    name?: string;
+    id?: string | null;
+    name?: string | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperbrowser/sdk",
-  "version": "0.93.0",
+  "version": "1.0.0",
   "description": "Node SDK for Hyperbrowser API",
   "author": "",
   "repository": {
@@ -17,13 +17,15 @@
   "license": "MIT",
   "scripts": {
     "build": "tsc",
-    "lint": "eslint src/**/*.ts",
+    "lint": "eslint 'src/**/*.ts'",
     "prepare": "yarn build",
     "test": "vitest run",
-    "test:e2e": "vitest run tests/sandbox/e2e",
-    "test:integration": "vitest run tests/integration",
+    "test:unit": "vitest run --project unit",
+    "test:e2e": "vitest run --project e2e",
+    "test:integration": "vitest run --project integration",
     "test:watch": "vitest",
-    "format": "prettier --write 'src/**/*.ts'"
+    "format": "prettier --write 'src/**/*.ts'",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json"
   },
   "files": [
     "dist",
@@ -73,6 +75,14 @@
     "./tools": {
       "types": "./dist/tools/index.d.ts",
       "default": "./dist/tools/index.js"
+    },
+    "./image-builds": {
+      "types": "./dist/image-builds.d.ts",
+      "default": "./dist/image-builds.js"
+    },
+    "./sandbox": {
+      "types": "./dist/sandbox/index.d.ts",
+      "default": "./dist/sandbox/index.js"
     }
   },
   "typesVersions": {
@@ -82,7 +92,16 @@
       ],
       "tools": [
         "./dist/tools/index.d.ts"
+      ],
+      "image-builds": [
+        "./dist/image-builds.d.ts"
+      ],
+      "sandbox": [
+        "./dist/sandbox/index.d.ts"
       ]
     }
+  },
+  "engines": {
+    "node": ">=20.20.2"
   }
 }