@hyperbrowser/sdk 0.88.0 → 0.88.2

package/README.md

@@ -159,11 +159,15 @@ const main = async () => {
   const sandbox = await client.sandboxes.create({
     imageName: "ubuntu-24-node",
     region: "us-west",
+    cpu: 4,
+    memoryMiB: 4096,
+    diskMiB: 8192,
   });
 
   // Provide exactly one launch source:
   // snapshotName or imageName.
   // snapshotId requires snapshotName and imageId requires imageName.
+  // cpu, memoryMiB, and diskMiB are only available for image launches.
 
   const version = await sandbox.exec("node -v");
   console.log(version.stdout.trim());
@@ -240,6 +244,9 @@ Create a sandbox with pre-exposed ports:
 ```typescript
 const sandbox = await client.sandboxes.create({
   imageName: "node",
+  cpu: 2,
+  memoryMiB: 2048,
+  diskMiB: 8192,
   exposedPorts: [{ port: 3000, auth: true }],
 });
 

package/dist/services/sandboxes.d.ts

@@ -20,6 +20,9 @@ export declare class SandboxHandle {
     get runtime(): SandboxDetail["runtime"];
     get tokenExpiresAt(): string | null;
     get sessionUrl(): string;
+    get cpu(): number | null | undefined;
+    get memoryMiB(): number | null | undefined;
+    get diskMiB(): number | null | undefined;
     get exposedPorts(): SandboxExposeResult[];
     toJSON(): SandboxDetail;
     info(): Promise<SandboxDetail>;

package/dist/services/sandboxes.js

@@ -8,6 +8,67 @@ const process_1 = require("../sandbox/process");
 const terminal_1 = require("../sandbox/terminal");
 const base_2 = require("./base");
 const RUNTIME_SESSION_REFRESH_BUFFER_MS = 60000;
+const validateOptionalPositiveInteger = (value, fieldName) => {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isInteger(value) || value < 1) {
+        throw new client_1.HyperbrowserError(`${fieldName} must be a positive integer`, undefined);
+    }
+};
+const normalizeSandbox = (sandbox) => {
+    const { vcpus, memMiB, diskSizeMiB, ...rest } = sandbox;
+    return {
+        ...rest,
+        cpu: vcpus,
+        memoryMiB: memMiB,
+        diskMiB: diskSizeMiB,
+    };
+};
+const normalizeSandboxDetail = (detail) => {
+    const { token, tokenExpiresAt, ...sandbox } = detail;
+    return {
+        ...normalizeSandbox(sandbox),
+        token,
+        tokenExpiresAt,
+    };
+};
+const normalizeSandboxListResponse = (response) => ({
+    ...response,
+    sandboxes: response.sandboxes.map(normalizeSandbox),
+});
+const serializeCreateSandboxParams = (params) => {
+    if ("imageName" in params) {
+        validateOptionalPositiveInteger(params.cpu, "cpu");
+        validateOptionalPositiveInteger(params.memoryMiB, "memoryMiB");
+        validateOptionalPositiveInteger(params.diskMiB, "diskMiB");
+        return {
+            imageName: params.imageName,
+            imageId: params.imageId,
+            region: params.region,
+            enableRecording: params.enableRecording,
+            exposedPorts: params.exposedPorts,
+            timeoutMinutes: params.timeoutMinutes,
+            vcpus: params.cpu,
+            memMiB: params.memoryMiB,
+            diskSizeMiB: params.diskMiB,
+        };
+    }
+    const snapshotParams = params;
+    if (snapshotParams.cpu !== undefined ||
+        snapshotParams.memoryMiB !== undefined ||
+        snapshotParams.diskMiB !== undefined) {
+        throw new client_1.HyperbrowserError("cpu, memoryMiB, and diskMiB are only supported for image launches", undefined);
+    }
+    return {
+        snapshotName: snapshotParams.snapshotName,
+        snapshotId: snapshotParams.snapshotId,
+        region: snapshotParams.region,
+        enableRecording: snapshotParams.enableRecording,
+        exposedPorts: snapshotParams.exposedPorts,
+        timeoutMinutes: snapshotParams.timeoutMinutes,
+    };
+};
 const buildSandboxExposedUrl = (runtime, port) => {
     const baseUrl = new URL(runtime.baseUrl);
     const authority = baseUrl.port
@@ -45,6 +106,15 @@ class SandboxHandle {
     get sessionUrl() {
         return this.detail.sessionUrl;
     }
+    get cpu() {
+        return this.detail.cpu;
+    }
+    get memoryMiB() {
+        return this.detail.memoryMiB;
+    }
+    get diskMiB() {
+        return this.detail.diskMiB;
+    }
     get exposedPorts() {
         return (this.detail.exposedPorts ?? []).map((entry) => ({ ...entry }));
     }
@@ -215,7 +285,7 @@ class SandboxesService extends base_2.BaseService {
     }
     async list(params = {}) {
         try {
-            return await this.request("/sandboxes", undefined, {
+            const response = await this.request("/sandboxes", undefined, {
                 status: params.status,
                 start: params.start,
                 end: params.end,
@@ -223,6 +293,7 @@ class SandboxesService extends base_2.BaseService {
                 page: params.page,
                 limit: params.limit,
             });
+            return normalizeSandboxListResponse(response);
         }
         catch (error) {
             if (error instanceof client_1.HyperbrowserError) {
@@ -272,7 +343,8 @@ class SandboxesService extends base_2.BaseService {
     }
     async getDetail(id) {
         try {
-            return await this.request(`/sandbox/${id}`);
+            const detail = await this.request(`/sandbox/${id}`);
+            return normalizeSandboxDetail(detail);
         }
         catch (error) {
             if (error instanceof client_1.HyperbrowserError) {
@@ -328,10 +400,11 @@ class SandboxesService extends base_2.BaseService {
     }
     async createDetail(params) {
         try {
-            return await this.request("/sandbox", {
+            const detail = await this.request("/sandbox", {
                 method: "POST",
-                body: JSON.stringify(params),
+                body: JSON.stringify(serializeCreateSandboxParams(params)),
             });
+            return normalizeSandboxDetail(detail);
         }
         catch (error) {
             if (error instanceof client_1.HyperbrowserError) {

package/dist/types/sandbox.d.ts

@@ -27,6 +27,9 @@ export interface Sandbox {
     sessionUrl: string;
     duration: number;
     proxyBytesUsed: number;
+    cpu?: number | null;
+    memoryMiB?: number | null;
+    diskMiB?: number | null;
     runtime: SandboxRuntimeTarget;
     exposedPorts: SandboxExposeResult[];
 }
@@ -45,11 +48,17 @@ export type CreateSandboxParams = (SandboxCreateCommonParams & {
     snapshotId?: string;
     imageName?: never;
     imageId?: never;
+    cpu?: never;
+    memoryMiB?: never;
+    diskMiB?: never;
 }) | (SandboxCreateCommonParams & {
     snapshotName?: never;
     snapshotId?: never;
     imageName: string;
     imageId?: string;
+    cpu?: number;
+    memoryMiB?: number;
+    diskMiB?: number;
 });
 export interface SandboxListParams {
     status?: SandboxStatus;

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "@hyperbrowser/sdk",
-  "version": "0.88.0",
+  "version": "0.88.2",
   "description": "Node SDK for Hyperbrowser API",
   "author": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hyperbrowserai/node-sdk"
+  },
+  "homepage": "https://github.com/hyperbrowserai/node-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/hyperbrowserai/node-sdk/issues"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "commonjs",