@hyperbrowser/sdk 0.84.0 → 0.85.0

package/dist/services/base.js

@@ -6,6 +6,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseService = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const client_1 = require("../client");
+const RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504]);
+const RETRYABLE_NETWORK_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EAI_AGAIN",
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+]);
+const getRequestId = (response) => {
+    return response.headers.get("x-request-id") || response.headers.get("request-id") || undefined;
+};
+const isRetryableNetworkError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const networkError = error;
+    return (networkError.name === "AbortError" ||
+        networkError.type === "request-timeout" ||
+        (networkError.code ? RETRYABLE_NETWORK_CODES.has(networkError.code) : false));
+};
 class BaseService {
     constructor(apiKey, baseUrl, timeout = 30000) {
         this.apiKey = apiKey;
@@ -44,15 +64,26 @@ class BaseService {
             });
             if (!response.ok) {
                 let errorMessage;
+                let errorDetails;
+                let errorCode;
                 try {
                     const errorData = await response.json();
+                    errorDetails = errorData;
+                    errorCode = typeof errorData?.code === "string" ? errorData.code : undefined;
                     errorMessage =
                         errorData.message || errorData.error || `HTTP error! status: ${response.status}`;
                 }
                 catch {
                     errorMessage = `HTTP error! status: ${response.status}`;
                 }
-                throw new client_1.HyperbrowserError(errorMessage, response.status);
+                throw new client_1.HyperbrowserError(errorMessage, {
+                    statusCode: response.status,
+                    code: errorCode,
+                    requestId: getRequestId(response),
+                    retryable: RETRYABLE_STATUS_CODES.has(response.status),
+                    service: "control",
+                    details: errorDetails,
+                });
             }
             if (response.headers.get("content-length") === "0") {
                 return {};
@@ -61,14 +92,23 @@ class BaseService {
                 return (await response.json());
             }
             catch {
-                throw new client_1.HyperbrowserError("Failed to parse JSON response", response.status);
+                throw new client_1.HyperbrowserError("Failed to parse JSON response", {
+                    statusCode: response.status,
+                    requestId: getRequestId(response),
+                    retryable: false,
+                    service: "control",
+                });
             }
         }
         catch (error) {
             if (error instanceof client_1.HyperbrowserError) {
                 throw error;
             }
-            throw new client_1.HyperbrowserError(error instanceof Error ? error.message : "Unknown error occurred", undefined);
+            throw new client_1.HyperbrowserError(error instanceof Error ? error.message : "Unknown error occurred", {
+                retryable: isRetryableNetworkError(error),
+                service: "control",
+                cause: error,
+            });
         }
     }
 }

package/dist/services/sandboxes.d.ts

@@ -0,0 +1,56 @@
+import { SandboxFilesApi } from "../sandbox/files";
+import { SandboxProcessHandle, SandboxProcessesApi } from "../sandbox/process";
+import { SandboxTerminalApi } from "../sandbox/terminal";
+import { BasicResponse } from "../types/session";
+import { CreateSandboxParams, SandboxDetail, SandboxExposeParams, SandboxExposeResult, SandboxExecParams, SandboxMemorySnapshotParams, SandboxMemorySnapshotResult, SandboxProcessResult, SandboxRuntimeTarget } from "../types/sandbox";
+import { BaseService } from "./base";
+export declare class SandboxHandle {
+    private readonly service;
+    readonly processes: SandboxProcessesApi;
+    readonly files: SandboxFilesApi;
+    readonly terminal: SandboxTerminalApi;
+    readonly pty: SandboxTerminalApi;
+    private readonly transport;
+    private detail;
+    private runtimeSession;
+    constructor(service: SandboxesService, detail: SandboxDetail);
+    get id(): string;
+    get status(): SandboxDetail["status"];
+    get region(): SandboxDetail["region"];
+    get runtime(): SandboxDetail["runtime"];
+    get tokenExpiresAt(): string | null;
+    get sessionUrl(): string;
+    toJSON(): SandboxDetail;
+    info(): Promise<SandboxDetail>;
+    refresh(): Promise<SandboxHandle>;
+    connect(): Promise<SandboxHandle>;
+    stop(): Promise<BasicResponse>;
+    createMemorySnapshot(params?: SandboxMemorySnapshotParams): Promise<SandboxMemorySnapshotResult>;
+    expose(params: SandboxExposeParams): Promise<SandboxExposeResult>;
+    getExposedUrl(port: number): string;
+    exec(input: string | SandboxExecParams): Promise<SandboxProcessResult>;
+    getProcess(processId: string): Promise<SandboxProcessHandle>;
+    private hydrate;
+    private resolveRuntimeConnection;
+    private resolveRuntimeSocketConnectionInfo;
+    private isRuntimeSessionExpiring;
+    private ensureRuntimeSession;
+    private applyRuntimeSession;
+    private clearRuntimeSession;
+    private assertRuntimeAvailable;
+    private static toRuntimeSession;
+}
+export declare class SandboxesService extends BaseService {
+    readonly runtimeTimeout: number;
+    readonly runtimeProxyOverride?: string;
+    constructor(apiKey: string, baseUrl: string, timeout: number, runtimeProxyOverride?: string);
+    create(params: CreateSandboxParams): Promise<SandboxHandle>;
+    get(id: string): Promise<SandboxHandle>;
+    connect(id: string): Promise<SandboxHandle>;
+    stop(id: string): Promise<BasicResponse>;
+    getDetail(id: string): Promise<SandboxDetail>;
+    attach(detail: SandboxDetail): SandboxHandle;
+    createMemorySnapshot(id: string, params?: SandboxMemorySnapshotParams): Promise<SandboxMemorySnapshotResult>;
+    expose(id: string, params: SandboxExposeParams, runtime?: SandboxRuntimeTarget): Promise<SandboxExposeResult>;
+    private createDetail;
+}

package/dist/services/sandboxes.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxesService = exports.SandboxHandle = void 0;
+const client_1 = require("../client");
+const files_1 = require("../sandbox/files");
+const base_1 = require("../sandbox/base");
+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 buildSandboxExposedUrl = (runtime, port) => {
+    const url = new URL(runtime.baseUrl);
+    url.hostname = `${port}-${url.hostname}`;
+    return url.toString().replace(/\/$/, "");
+};
+class SandboxHandle {
+    constructor(service, detail) {
+        this.service = service;
+        this.detail = detail;
+        this.runtimeSession = SandboxHandle.toRuntimeSession(detail);
+        this.transport = new base_1.RuntimeTransport((forceRefresh) => this.resolveRuntimeConnection(forceRefresh), service.runtimeTimeout, service.runtimeProxyOverride);
+        this.processes = new process_1.SandboxProcessesApi(this.transport);
+        this.files = new files_1.SandboxFilesApi(this.transport, () => this.resolveRuntimeSocketConnectionInfo(), service.runtimeProxyOverride);
+        this.terminal = new terminal_1.SandboxTerminalApi(this.transport, () => this.resolveRuntimeSocketConnectionInfo(), service.runtimeProxyOverride);
+        this.pty = this.terminal;
+    }
+    get id() {
+        return this.detail.id;
+    }
+    get status() {
+        return this.detail.status;
+    }
+    get region() {
+        return this.detail.region;
+    }
+    get runtime() {
+        return this.detail.runtime;
+    }
+    get tokenExpiresAt() {
+        return this.detail.tokenExpiresAt;
+    }
+    get sessionUrl() {
+        return this.detail.sessionUrl;
+    }
+    toJSON() {
+        return { ...this.detail };
+    }
+    async info() {
+        const detail = await this.service.getDetail(this.id);
+        this.hydrate(detail);
+        return this.toJSON();
+    }
+    async refresh() {
+        await this.info();
+        return this;
+    }
+    async connect() {
+        await this.ensureRuntimeSession(true);
+        return this;
+    }
+    async stop() {
+        const response = await this.service.stop(this.id);
+        this.clearRuntimeSession("closed");
+        return response;
+    }
+    async createMemorySnapshot(params = {}) {
+        return this.service.createMemorySnapshot(this.id, params);
+    }
+    async expose(params) {
+        return this.service.expose(this.id, params, this.runtime);
+    }
+    getExposedUrl(port) {
+        return buildSandboxExposedUrl(this.runtime, port);
+    }
+    async exec(input) {
+        const params = typeof input === "string"
+            ? {
+                command: input,
+            }
+            : input;
+        return this.processes.exec(params);
+    }
+    async getProcess(processId) {
+        return this.processes.get(processId);
+    }
+    hydrate(detail) {
+        this.detail = detail;
+        this.runtimeSession = SandboxHandle.toRuntimeSession(detail);
+    }
+    async resolveRuntimeConnection(forceRefresh = false) {
+        const session = await this.ensureRuntimeSession(forceRefresh);
+        return {
+            sandboxId: this.id,
+            baseUrl: session.runtime.baseUrl,
+            token: session.token,
+        };
+    }
+    async resolveRuntimeSocketConnectionInfo() {
+        const session = await this.ensureRuntimeSession();
+        return {
+            sandboxId: this.id,
+            baseUrl: session.runtime.baseUrl,
+            token: session.token,
+        };
+    }
+    isRuntimeSessionExpiring() {
+        if (!this.runtimeSession?.tokenExpiresAt) {
+            return false;
+        }
+        const expiresAt = Date.parse(this.runtimeSession.tokenExpiresAt);
+        if (Number.isNaN(expiresAt)) {
+            return false;
+        }
+        return expiresAt - Date.now() <= RUNTIME_SESSION_REFRESH_BUFFER_MS;
+    }
+    async ensureRuntimeSession(forceRefresh = false) {
+        this.assertRuntimeAvailable();
+        if (!forceRefresh && this.runtimeSession && !this.isRuntimeSessionExpiring()) {
+            return { ...this.runtimeSession };
+        }
+        const detail = await this.service.getDetail(this.id);
+        this.hydrate(detail);
+        if (!this.runtimeSession) {
+            throw new client_1.HyperbrowserError(`Sandbox ${this.id} is not running`, {
+                statusCode: 409,
+                code: "sandbox_not_running",
+                retryable: false,
+                service: "runtime",
+            });
+        }
+        return { ...this.runtimeSession };
+    }
+    applyRuntimeSession(session) {
+        this.runtimeSession = { ...session };
+        this.detail = {
+            ...this.detail,
+            status: session.status,
+            region: session.region,
+            runtime: session.runtime,
+            token: session.token,
+            tokenExpiresAt: session.tokenExpiresAt,
+        };
+    }
+    clearRuntimeSession(status = this.detail.status) {
+        this.runtimeSession = null;
+        this.detail = {
+            ...this.detail,
+            status,
+            token: null,
+            tokenExpiresAt: null,
+        };
+    }
+    assertRuntimeAvailable() {
+        if (this.detail.status === "closed" || this.detail.status === "error") {
+            throw new client_1.HyperbrowserError(`Sandbox ${this.id} is not running`, {
+                statusCode: 409,
+                code: "sandbox_not_running",
+                retryable: false,
+                service: "runtime",
+            });
+        }
+    }
+    static toRuntimeSession(detail) {
+        if (!detail.token) {
+            return null;
+        }
+        return {
+            sandboxId: detail.id,
+            status: detail.status,
+            region: detail.region,
+            token: detail.token,
+            tokenExpiresAt: detail.tokenExpiresAt,
+            runtime: detail.runtime,
+        };
+    }
+}
+exports.SandboxHandle = SandboxHandle;
+class SandboxesService extends base_2.BaseService {
+    constructor(apiKey, baseUrl, timeout, runtimeProxyOverride) {
+        super(apiKey, baseUrl, timeout);
+        this.runtimeTimeout = timeout;
+        this.runtimeProxyOverride = runtimeProxyOverride;
+    }
+    async create(params) {
+        const detail = await this.createDetail(params);
+        return this.attach(detail);
+    }
+    async get(id) {
+        const detail = await this.getDetail(id);
+        return this.attach(detail);
+    }
+    async connect(id) {
+        const handle = await this.get(id);
+        await handle.connect();
+        return handle;
+    }
+    async stop(id) {
+        try {
+            return await this.request(`/sandbox/${id}/stop`, {
+                method: "PUT",
+            });
+        }
+        catch (error) {
+            if (error instanceof client_1.HyperbrowserError) {
+                throw error;
+            }
+            throw new client_1.HyperbrowserError(`Failed to stop sandbox ${id}`, undefined);
+        }
+    }
+    async getDetail(id) {
+        try {
+            return await this.request(`/sandbox/${id}`);
+        }
+        catch (error) {
+            if (error instanceof client_1.HyperbrowserError) {
+                throw error;
+            }
+            throw new client_1.HyperbrowserError(`Failed to get sandbox ${id}`, undefined);
+        }
+    }
+    attach(detail) {
+        return new SandboxHandle(this, detail);
+    }
+    async createMemorySnapshot(id, params = {}) {
+        try {
+            return await this.request(`/sandbox/${id}/snapshot`, {
+                method: "POST",
+                body: JSON.stringify(params),
+            });
+        }
+        catch (error) {
+            if (error instanceof client_1.HyperbrowserError) {
+                throw error;
+            }
+            throw new client_1.HyperbrowserError(`Failed to create memory snapshot for sandbox ${id}`, undefined);
+        }
+    }
+    async expose(id, params, runtime) {
+        try {
+            const response = await this.request(`/sandbox/${id}/expose`, {
+                method: "POST",
+                body: JSON.stringify(params),
+            });
+            const targetRuntime = runtime ?? (await this.getDetail(id)).runtime;
+            return {
+                port: response.port,
+                auth: response.auth,
+                url: buildSandboxExposedUrl(targetRuntime, response.port),
+            };
+        }
+        catch (error) {
+            if (error instanceof client_1.HyperbrowserError) {
+                throw error;
+            }
+            throw new client_1.HyperbrowserError(`Failed to expose port ${params.port} for sandbox ${id}`);
+        }
+    }
+    async createDetail(params) {
+        try {
+            return await this.request("/sandbox", {
+                method: "POST",
+                body: JSON.stringify(params),
+            });
+        }
+        catch (error) {
+            if (error instanceof client_1.HyperbrowserError) {
+                throw error;
+            }
+            throw new client_1.HyperbrowserError("Failed to create sandbox", undefined);
+        }
+    }
+}
+exports.SandboxesService = SandboxesService;

package/dist/types/config.d.ts

@@ -2,4 +2,5 @@ export interface HyperbrowserConfig {
     apiKey?: string;
     baseUrl?: string;
     timeout?: number;
+    runtimeProxyOverride?: string;
 }

package/dist/types/index.d.ts

@@ -8,6 +8,7 @@ export { StartCuaTaskParams, StartCuaTaskResponse, CuaTaskStatusResponse, CuaTas
 export { StartHyperAgentTaskParams, StartHyperAgentTaskResponse, HyperAgentTaskStatusResponse, HyperAgentTaskResponse, HyperAgentTaskData, HyperAgentStep, HyperAgentOutput, HyperAgentActionOutput, HyperAgentApiKeys, HyperAgentTaskMetadata, HyperAgentOutputV110, HyperAgentStepV110, } from "./agents/hyper-agent";
 export { StartGeminiComputerUseTaskParams, StartGeminiComputerUseTaskResponse, GeminiComputerUseTaskStatusResponse, GeminiComputerUseTaskResponse, GeminiComputerUseTaskData, GeminiComputerUseStepResponse, GeminiComputerUseApiKeys, GeminiComputerUseTaskMetadata, } from "./agents/gemini-computer-use";
 export { BasicResponse, SessionStatus, Session, SessionDetail, SessionGetParams, SessionListParams, SessionListResponse, ScreenConfig, CreateSessionParams, GetSessionDownloadsUrlResponse, GetSessionVideoRecordingUrlResponse, GetSessionRecordingUrlResponse, ImageCaptchaParam, UploadFileResponse, UploadFileOptions, GetActiveSessionsCountResponse, SessionEventLogListParams, SessionEventLogListResponse, SessionEventLog, SessionProfile, SessionLaunchState, UpdateSessionProfileParams, } from "./session";
+export { SandboxStatus, SandboxRuntimeTarget, Sandbox, SandboxDetail, CreateSandboxParams, SandboxMemorySnapshotParams, SandboxMemorySnapshotResult, SandboxExposeParams, SandboxExposeResult, SandboxProcessStatus, SandboxExecParams, 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 { CreateProfileParams, ProfileResponse, CreateProfileResponse, ProfileListParams, ProfileListResponse, } from "./profile";
 export { CreateExtensionParams, CreateExtensionResponse, ListExtensionsResponse, } from "./extension";
 export { ExtractJobStatus, BrowserUseTaskStatus, BrowserUseLlm, ClaudeComputerUseLlm, CuaLlm, GeminiComputerUseLlm, ScrapeScreenshotFormat, ScrapeJobStatus, CrawlJobStatus, Country, State, ISO639_1, OperatingSystem, Platform, ScrapeFormat, ScrapeWaitUntil, ScrapePageStatus, CrawlPageStatus, RecordingStatus, DownloadsStatus, HyperAgentLlm, HyperAgentTaskStatus, ClaudeComputerUseTaskStatus, CuaTaskStatus, GeminiComputerUseTaskStatus, SessionEventLogType, SessionRegion, BrowserUseVersion, HyperAgentVersion, } from "./constants";

package/dist/types/sandbox.d.ts

@@ -0,0 +1,270 @@
+import type { Blob } from "buffer";
+import type { ReadableStream } from "node:stream/web";
+import { SessionRegion } from "./constants";
+import { SessionLaunchState, SessionStatus } from "./session";
+export type SandboxStatus = SessionStatus;
+export interface SandboxRuntimeTarget {
+    transport: "regional_proxy";
+    host: string;
+    baseUrl: string;
+}
+export interface Sandbox {
+    id: string;
+    teamId: string;
+    status: SandboxStatus;
+    endTime?: number | null;
+    startTime?: number | null;
+    createdAt: string;
+    updatedAt: string;
+    closeReason?: string | null;
+    dataConsumed?: number;
+    proxyDataConsumed?: number;
+    usageType?: string;
+    jobId?: string | null;
+    launchState?: SessionLaunchState | null;
+    creditsUsed: number | null;
+    region: SessionRegion;
+    sessionUrl: string;
+    duration: number;
+    proxyBytesUsed: number;
+    runtime: SandboxRuntimeTarget;
+}
+export interface SandboxDetail extends Sandbox {
+    token: string | null;
+    tokenExpiresAt: string | null;
+}
+interface SandboxCreateCommonParams {
+    region?: SessionRegion;
+    enableRecording?: boolean;
+    timeoutMinutes?: number;
+}
+export type CreateSandboxParams = (SandboxCreateCommonParams & {
+    snapshotName: string;
+    snapshotId?: string;
+    imageName?: never;
+    imageId?: never;
+}) | (SandboxCreateCommonParams & {
+    snapshotName?: never;
+    snapshotId?: never;
+    imageName: string;
+    imageId?: string;
+});
+export interface SandboxMemorySnapshotParams {
+    snapshotName?: string;
+}
+export interface SandboxMemorySnapshotResult {
+    snapshotName: string;
+    snapshotId: string;
+    namespace: string;
+    status: string;
+    imageName: string;
+    imageId: string;
+    imageNamespace: string;
+}
+export interface SandboxExposeParams {
+    port: number;
+    auth?: boolean;
+}
+export interface SandboxExposeResult {
+    port: number;
+    auth: boolean;
+    url: string;
+}
+export type SandboxProcessStatus = "queued" | "running" | "exited" | "failed" | "killed" | "timed_out";
+export interface SandboxExecParams {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    timeoutSec?: number;
+    useShell?: boolean;
+}
+export interface SandboxProcessSummary {
+    id: string;
+    status: SandboxProcessStatus;
+    command: string;
+    args?: string[];
+    cwd: string;
+    pid?: number;
+    exitCode?: number | null;
+    startedAt: number;
+    completedAt?: number;
+}
+export interface SandboxProcessResult {
+    id: string;
+    status: SandboxProcessStatus;
+    exitCode?: number | null;
+    stdout: string;
+    stderr: string;
+    startedAt: number;
+    completedAt?: number;
+    error?: string;
+}
+export interface SandboxProcessListParams {
+    status?: SandboxProcessStatus | SandboxProcessStatus[];
+    limit?: number;
+    cursor?: string | number;
+    createdAfter?: number;
+    createdBefore?: number;
+}
+export interface SandboxProcessListResponse {
+    data: SandboxProcessSummary[];
+    nextCursor?: string;
+}
+export interface SandboxProcessWaitParams {
+    timeoutMs?: number;
+    timeoutSec?: number;
+}
+export type SandboxProcessSignal = "TERM" | "KILL" | "INT" | "HUP" | "QUIT" | string;
+export interface SandboxProcessStdinParams {
+    data?: string | Uint8Array;
+    encoding?: "utf8" | "base64";
+    eof?: boolean;
+}
+export type SandboxProcessStreamEvent = {
+    type: "stdout" | "stderr" | "system";
+    seq: number;
+    data: string;
+    timestamp: number;
+} | {
+    type: "exit";
+    result: SandboxProcessResult;
+};
+export type SandboxFileType = "file" | "dir";
+export interface SandboxFileInfo {
+    path: string;
+    name: string;
+    type: SandboxFileType;
+    size: number;
+    mode: number;
+    permissions: string;
+    owner: string;
+    group: string;
+    modifiedTime?: Date;
+    symlinkTarget?: string;
+}
+export interface SandboxFileWriteInfo {
+    path: string;
+    name: string;
+    type?: SandboxFileType;
+}
+export interface SandboxFileListOptions {
+    depth?: number;
+}
+export type SandboxFileReadFormat = "text" | "bytes" | "blob" | "stream";
+export interface SandboxFileReadOptions {
+    offset?: number;
+    length?: number;
+    format?: SandboxFileReadFormat;
+}
+export type SandboxFileWriteData = string | Uint8Array | Buffer | ArrayBuffer | Blob | ReadableStream<Uint8Array>;
+export interface SandboxFileWriteEntry {
+    path: string;
+    data: SandboxFileWriteData;
+}
+export interface SandboxFileTextWriteOptions {
+    append?: boolean;
+    mode?: string;
+}
+export interface SandboxFileBytesWriteOptions {
+    append?: boolean;
+    mode?: string;
+}
+export interface SandboxFileRemoveOptions {
+    recursive?: boolean;
+}
+export interface SandboxFileMakeDirOptions {
+    parents?: boolean;
+    mode?: string;
+}
+export interface SandboxFileTransferResult {
+    path: string;
+    bytesWritten: number;
+}
+export interface SandboxFileCopyParams {
+    source: string;
+    destination: string;
+    recursive?: boolean;
+    overwrite?: boolean;
+}
+export interface SandboxFileChmodParams {
+    path: string;
+    mode: string;
+    recursive?: boolean;
+}
+export interface SandboxFileChownParams {
+    path: string;
+    uid?: number;
+    gid?: number;
+    recursive?: boolean;
+}
+export type SandboxFileSystemEventType = "chmod" | "create" | "remove" | "rename" | "write";
+export interface SandboxFileSystemEvent {
+    name: string;
+    type: SandboxFileSystemEventType;
+}
+export interface SandboxWatchDirOptions {
+    recursive?: boolean;
+    timeoutMs?: number;
+    onExit?: (error?: Error) => void | Promise<void>;
+}
+export interface SandboxPresignFileParams {
+    path: string;
+    expiresInSeconds?: number;
+    oneTime?: boolean;
+}
+export interface SandboxPresignedUrl {
+    token: string;
+    path: string;
+    method: string;
+    expiresAt: number;
+    url: string;
+}
+export interface SandboxTerminalCreateParams {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    useShell?: boolean;
+    rows?: number;
+    cols?: number;
+    timeoutMs?: number;
+}
+export interface SandboxTerminalOutputChunk {
+    seq: number;
+    data: string;
+    raw: Buffer;
+    timestamp: number;
+}
+export interface SandboxTerminalStatus {
+    id: string;
+    command: string;
+    args?: string[];
+    cwd: string;
+    pid?: number;
+    running: boolean;
+    exitCode?: number | null;
+    error?: string;
+    timedOut?: boolean;
+    rows: number;
+    cols: number;
+    startedAt: number;
+    finishedAt?: number;
+    output?: SandboxTerminalOutputChunk[];
+}
+export interface SandboxTerminalWaitParams {
+    timeoutMs?: number;
+    includeOutput?: boolean;
+}
+export interface SandboxTerminalKillParams {
+    signal?: string;
+    timeoutMs?: number;
+}
+export type SandboxTerminalEvent = ({
+    type: "output";
+} & SandboxTerminalOutputChunk) | {
+    type: "exit";
+    status: SandboxTerminalStatus;
+};
+export {};

package/dist/types/sandbox.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });