@watasu/sdk 0.1.40 → 0.1.50

package/dist/filesystem.d.ts

@@ -8,6 +8,13 @@ export declare enum FileType {
     /** Symbolic link. */
     SYMLINK = "symlink"
 }
+export declare enum FilesystemEventType {
+    CHMOD = "chmod",
+    CREATE = "create",
+    REMOVE = "remove",
+    RENAME = "rename",
+    WRITE = "write"
+}
 /** Metadata for one sandbox filesystem entry. */
 export interface EntryInfo {
     name: string;
@@ -27,7 +34,8 @@ export interface WriteEntry {
     data: WriteData;
 }
 export interface FilesystemEvent {
-    type: 'create' | 'write' | 'modify' | 'remove' | 'delete' | 'rename' | string;
+    name: string;
+    type: FilesystemEventType | string;
     path: string;
     entry?: EntryInfo;
     raw: Record<string, unknown>;
@@ -35,7 +43,10 @@ export interface FilesystemEvent {
 export interface WatchOpts {
     recursive?: boolean;
     includeEntry?: boolean;
+    allowNetworkMounts?: boolean;
     requestTimeoutMs?: number;
+    signal?: AbortSignal;
+    user?: string;
     onExit?: (error?: Error) => void | Promise<void>;
 }
 export interface FilesystemRequestOpts {
@@ -48,6 +59,7 @@ export interface FilesystemReadOpts extends FilesystemRequestOpts {
 }
 export interface FilesystemWriteOpts extends FilesystemRequestOpts {
     gzip?: boolean;
+    useOctetStream?: boolean;
     metadata?: Record<string, string>;
 }
 /** Live filesystem watcher. Call `stop()` to close the local watch stream. */

package/dist/filesystem.js

@@ -1,3 +1,4 @@
+import { gzipSync } from 'node:zlib';
 import { withQuery } from './transport.js';
 import { FileNotFoundError, InvalidArgumentError } from './errors.js';
 import { ProcessSocket, base64Encode } from './processSocket.js';
@@ -10,6 +11,14 @@ export var FileType;
     /** Symbolic link. */
     FileType["SYMLINK"] = "symlink";
 })(FileType || (FileType = {}));
+export var FilesystemEventType;
+(function (FilesystemEventType) {
+    FilesystemEventType["CHMOD"] = "chmod";
+    FilesystemEventType["CREATE"] = "create";
+    FilesystemEventType["REMOVE"] = "remove";
+    FilesystemEventType["RENAME"] = "rename";
+    FilesystemEventType["WRITE"] = "write";
+})(FilesystemEventType || (FilesystemEventType = {}));
 /** Live filesystem watcher. Call `stop()` to close the local watch stream. */
 export class WatchHandle {
     socket;
@@ -62,7 +71,12 @@ export class FilesystemWatcher {
         if (this.handle)
             return;
         const nextOpts = { ...this.opts, ...opts };
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery('/runtime/v1/files/watch', { path: this.path, recursive: nextOpts.recursive ?? false, include_entry: nextOpts.includeEntry }), nextOpts.requestTimeoutMs, this.dataPlane.headers).connect();
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery('/runtime/v1/files/watch', {
+            path: this.path,
+            recursive: nextOpts.recursive ?? false,
+            include_entry: nextOpts.includeEntry,
+            allow_network_mounts: nextOpts.allowNetworkMounts,
+        }), nextOpts.requestTimeoutMs, this.dataPlane.headers).connect();
         this.handle = new WatchHandle(socket, socket, async (event) => {
             for (const listener of this.listeners)
                 await listener(event);
@@ -109,8 +123,8 @@ export class Filesystem {
         if (Array.isArray(pathOrFiles)) {
             return this.writeFiles(pathOrFiles, dataOrOpts);
         }
-        const body = await writeDataToBytes(dataOrOpts);
-        const payload = await this.dataPlane.putJson(withQuery('/runtime/v1/files', { path: pathOrFiles, gzip: opts.gzip }), body, opts);
+        const body = maybeGzip(await writeDataToBytes(dataOrOpts), opts.gzip);
+        const payload = await this.dataPlane.putJson(withQuery('/runtime/v1/files', { path: pathOrFiles, gzip: opts.gzip }), body, requestOpts(opts, opts.gzip ? { 'content-encoding': 'gzip' } : undefined));
         return entryInfo(payload.file ?? payload);
     }
     /** Write raw bytes to a file. */
@@ -122,11 +136,12 @@ export class Filesystem {
         if (files.length === 0)
             return [];
         const payload = await this.dataPlane.postJson('/runtime/v1/files/write_files', {
-            ...opts,
+            ...requestOpts(opts),
             json: {
                 files: await Promise.all(files.map(async (file) => ({
                     path: file.path,
-                    data_base64: base64Encode(await writeDataToBytes(file.data)),
+                    data_base64: base64Encode(maybeGzip(await writeDataToBytes(file.data), opts.gzip)),
+                    ...(opts.gzip ? { gzip: true } : {}),
                 }))),
             },
         });
@@ -194,6 +209,19 @@ async function writeDataToBytes(data) {
         return readStreamToBytes(data);
     throw new InvalidArgumentError(`Unsupported file data type: ${Object.prototype.toString.call(data)}`);
 }
+function requestOpts(opts, headers) {
+    const out = {};
+    if (opts.requestTimeoutMs !== undefined)
+        out.requestTimeoutMs = opts.requestTimeoutMs;
+    if (opts.signal !== undefined)
+        out.signal = opts.signal;
+    if (headers !== undefined)
+        out.headers = headers;
+    return out;
+}
+function maybeGzip(bytes, enabled) {
+    return enabled ? new Uint8Array(gzipSync(bytes)) : bytes;
+}
 function toArrayBuffer(bytes) {
     const buffer = new ArrayBuffer(bytes.byteLength);
     new Uint8Array(buffer).set(bytes);
@@ -253,17 +281,32 @@ function recordOfStrings(value) {
 }
 function filesystemEvent(value) {
     const item = value && typeof value === 'object' ? value : {};
+    const path = String(item.path ?? '');
     return {
         type: normalizeEventType(String(item.type ?? 'modify')),
-        path: String(item.path ?? ''),
+        name: String(item.name ?? relativeName(path)),
+        path,
         entry: item.file && typeof item.file === 'object' ? entryInfo(item.file) : undefined,
         raw: item,
     };
 }
 function normalizeEventType(value) {
     if (value === 'delete')
-        return 'remove';
+        return FilesystemEventType.REMOVE;
     if (value === 'modify')
-        return 'write';
+        return FilesystemEventType.WRITE;
+    if (value === 'chmod')
+        return FilesystemEventType.CHMOD;
+    if (value === 'create')
+        return FilesystemEventType.CREATE;
+    if (value === 'remove')
+        return FilesystemEventType.REMOVE;
+    if (value === 'rename')
+        return FilesystemEventType.RENAME;
+    if (value === 'write')
+        return FilesystemEventType.WRITE;
     return value;
 }
+function relativeName(path) {
+    return path.split('/').filter(Boolean).pop() ?? '';
+}

package/dist/git.d.ts

@@ -50,13 +50,15 @@ export interface GitCredentialOpts extends GitRequestOpts {
     host?: string;
     protocol?: string;
 }
+export type GitDangerouslyAuthenticateOpts = GitCredentialOpts;
 export interface GitConfigureUserOpts extends GitRequestOpts {
-    scope?: 'global' | 'local';
+    scope?: GitConfigScope;
     path?: string;
 }
 export interface GitBranchOpts extends GitRequestOpts {
     force?: boolean;
 }
+export type GitDeleteBranchOpts = GitBranchOpts;
 export interface GitAddOpts extends GitRequestOpts {
     files?: string[];
     all?: boolean;
@@ -83,9 +85,10 @@ export interface GitRemoteAddOpts extends GitRequestOpts {
     overwrite?: boolean;
 }
 export interface GitConfigOpts extends GitRequestOpts {
-    scope?: 'global' | 'local';
+    scope?: GitConfigScope;
     path?: string;
 }
+export type GitConfigScope = 'global' | 'local' | 'system';
 export interface GitBranches {
     path?: string;
     branches: string[];

package/dist/index.d.ts

@@ -1,24 +1,36 @@
-export { ApiError, AuthenticationError, ConflictError, FileNotFoundError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, TimeoutError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
-export { Sandbox, SandboxPaginator, SnapshotPaginator } from './sandbox.js';
+export type { ConnectionOpts, Username } from './connectionConfig.js';
+export { ControlClient as ApiClient } from './transport.js';
+export { ALL_TRAFFIC, Sandbox, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';
 export { Sandbox as CodeInterpreterSandbox } from './codeInterpreter.js';
-export type { CreateSnapshotOpts, RestoreSnapshotOpts, SandboxCreateOpts, SandboxConnectOpts, SandboxInfo, SandboxInfoLifecycle, SandboxLifecycle, SandboxListOpts, SandboxMetrics, SandboxMetricsOpts, McpServer, McpServerName, SandboxNetworkSelector, SandboxNetworkUpdate, SandboxNetworkUpdateOpts, SandboxUrlOpts, SnapshotInfo, FileUrlInfo, } from './sandbox.js';
+export type { CreateSnapshotOpts, RestoreSnapshotOpts, SandboxApiOpts, SandboxCreateOpts, SandboxConnectOpts, SandboxInfo, SandboxInfoLifecycle, SandboxLifecycle, SandboxListOpts, SandboxMetrics, SandboxMetricsOpts, McpServer, McpServerName, SandboxNetworkInfo, SandboxNetworkOpts, SandboxNetworkRule, SandboxNetworkRuleInfo, SandboxNetworkRules, SandboxNetworkSelector, SandboxNetworkSelectorContext, SandboxNetworkTransform, SandboxNetworkUpdate, SandboxNetworkUpdateOpts, SandboxOpts, SandboxState, SandboxUrlOpts, SignatureOpts, SnapshotInfo, SnapshotListOpts, FileUrlInfo, } from './sandbox.js';
 export type { CreateCodeContextOpts, RunCodeLanguage, RunCodeOpts, } from './codeInterpreter.js';
 export { Context as CodeInterpreterContext, Execution as CodeInterpreterExecution, ExecutionError as CodeInterpreterExecutionError, OutputMessage as CodeInterpreterOutputMessage, Result as CodeInterpreterResult, } from './codeInterpreter.js';
 export { CommandExitError, CommandHandle, Commands } from './commands.js';
-export type { CommandResult, CommandStartOpts, ProcessInfo } from './commands.js';
+export type { CommandConnectOpts, CommandRequestOpts, CommandResult, CommandStartOpts, ProcessInfo, PtyOutput, Stderr, Stdout, } from './commands.js';
 export { Process, ProcessManager, ProcessMessage, ProcessOutput } from './process.js';
 export type { ProcessOpts } from './process.js';
-export { FileType, Filesystem, FilesystemWatcher, WatchHandle } from './filesystem.js';
+export { FileType, Filesystem, FilesystemEventType, FilesystemWatcher, WatchHandle, } from './filesystem.js';
 export type { EntryInfo, FilesystemEvent, FilesystemReadOpts, FilesystemRequestOpts, FilesystemWriteOpts, WatchOpts, WriteData, WriteEntry, WriteInfo, } from './filesystem.js';
 export { Git } from './git.js';
-export type { GitAddOpts, GitAuthOpts, GitBranches, GitBranchOpts, GitCloneOpts, GitCommandResult, GitConfigOpts, GitConfigureUserOpts, GitCredentialOpts, GitCommitOpts, GitFileStatus, GitInitOpts, GitPullOpts, GitPushOpts, GitRemoteAddOpts, GitResetMode, GitResetOpts, GitRestoreOpts, GitRequestOpts, GitStatus, } from './git.js';
+export type { GitAddOpts, GitAuthOpts, GitBranches, GitBranchOpts, GitCloneOpts, GitCommandResult, GitConfigScope, GitConfigOpts, GitConfigureUserOpts, GitCredentialOpts, GitCommitOpts, GitDangerouslyAuthenticateOpts, GitDeleteBranchOpts, GitFileStatus, GitInitOpts, GitPullOpts, GitPushOpts, GitRemoteAddOpts, GitResetMode, GitResetOpts, GitRestoreOpts, GitRequestOpts, GitStatus, } from './git.js';
 export { Pty } from './pty.js';
 export type { PtyConnectOpts, PtyCreateOpts, PtySize } from './pty.js';
 export { Terminal, TerminalManager, TerminalOutput } from './terminal.js';
 export type { TerminalOpts } from './terminal.js';
-export { Volume } from './volume.js';
-export type { VolumeApiParams, VolumeConnectionConfig, VolumeEntryStat, VolumeFileType, VolumeInfo, VolumeListFilesOpts, VolumeListOpts, VolumeMetadataOpts, VolumeReadFileOpts, VolumeReadFormat, VolumeWriteData, VolumeWriteFileOpts, } from './volume.js';
+export { Volume, VolumeConnectionConfig, VolumeFileType } from './volume.js';
+export type { VolumeAndToken, VolumeApiParams, VolumeApiOpts, VolumeEntryStat, VolumeInfo, VolumeListFilesOpts, VolumeListOpts, VolumeMetadataOpts, VolumeMetadataOptions, VolumeReadFileOpts, VolumeReadFormat, VolumeWriteData, VolumeWriteFileOpts, VolumeWriteOptions, } from './volume.js';
 export { ProcessSocket, base64DecodeBytes, base64DecodeText, base64Encode } from './processSocket.js';
-export { ReadyCmd, Template, TemplateBase, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
-export type { BuildInfo, BuildOptions, BuildStatusReason, CopyItem, GetBuildStatusOptions, LogEntry, ReadyCommand, TemplateBuildStatus, TemplateBuildStatusResponse, TemplateBuilder, TemplateClass, TemplateFactory, TemplateFinal, TemplateFromImage, TemplateOptions, TemplateTag, TemplateTagInfo, } from './template.js';
+export { ReadyCmd, Template, TemplateBase, LogEntry, LogEntryEnd, LogEntryStart, defaultBuildLogger, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
+export type { BuildInfo, BuildOptions, BuildStatusReason, CopyItem, GetBuildStatusOptions, LogEntryLevel, Logger, ReadyCommand, TemplateBuildStatus, TemplateBuildStatusResponse, TemplateBuilder, TemplateClass, TemplateFactory, TemplateFinal, TemplateFromImage, TemplateOptions, TemplateTag, TemplateTagInfo, } from './template.js';
+export interface components {
+    schemas: Record<string, unknown>;
+    responses: Record<string, unknown>;
+    parameters: Record<string, unknown>;
+    requestBodies: Record<string, unknown>;
+    headers: Record<string, unknown>;
+    pathItems: Record<string, unknown>;
+}
+export type paths = Record<string, unknown>;
+export { Sandbox as default } from './sandbox.js';

package/dist/index.js

@@ -1,14 +1,16 @@
-export { ApiError, AuthenticationError, ConflictError, FileNotFoundError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, TimeoutError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
-export { Sandbox, SandboxPaginator, SnapshotPaginator } from './sandbox.js';
+export { ControlClient as ApiClient } from './transport.js';
+export { ALL_TRAFFIC, Sandbox, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';
 export { Sandbox as CodeInterpreterSandbox } from './codeInterpreter.js';
 export { Context as CodeInterpreterContext, Execution as CodeInterpreterExecution, ExecutionError as CodeInterpreterExecutionError, OutputMessage as CodeInterpreterOutputMessage, Result as CodeInterpreterResult, } from './codeInterpreter.js';
 export { CommandExitError, CommandHandle, Commands } from './commands.js';
 export { Process, ProcessManager, ProcessMessage, ProcessOutput } from './process.js';
-export { FileType, Filesystem, FilesystemWatcher, WatchHandle } from './filesystem.js';
+export { FileType, Filesystem, FilesystemEventType, FilesystemWatcher, WatchHandle, } from './filesystem.js';
 export { Git } from './git.js';
 export { Pty } from './pty.js';
 export { Terminal, TerminalManager, TerminalOutput } from './terminal.js';
-export { Volume } from './volume.js';
+export { Volume, VolumeConnectionConfig, VolumeFileType } from './volume.js';
 export { ProcessSocket, base64DecodeBytes, base64DecodeText, base64Encode } from './processSocket.js';
-export { ReadyCmd, Template, TemplateBase, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
+export { ReadyCmd, Template, TemplateBase, LogEntry, LogEntryEnd, LogEntryStart, defaultBuildLogger, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
+export { Sandbox as default } from './sandbox.js';

package/dist/process.js

@@ -40,11 +40,15 @@ export class ProcessOutput {
             this._error = true;
     }
     replace(result) {
+        const streamedStdout = this.stdout;
+        const streamedStderr = this.stderr;
         this.messages = [];
-        if (result.stdout)
-            this.addStdout(processMessage(result.stdout, false));
-        if (result.stderr)
-            this.addStderr(processMessage(result.stderr, true));
+        const stdout = result.stdout || streamedStdout;
+        const stderr = result.stderr || streamedStderr;
+        if (stdout)
+            this.addStdout(processMessage(stdout, false));
+        if (stderr)
+            this.addStderr(processMessage(stderr, true));
         this.setExitCode(result.exitCode);
     }
 }

package/dist/processSocket.d.ts

@@ -9,19 +9,31 @@ export declare class ProcessSocket implements AsyncIterable<ProcessFrame> {
     private ws?;
     private queue;
     private waiters;
+    private ackWaiters;
     private closed;
     private keepalive?;
     constructor(baseUrl: string, token: string, path: string, requestTimeoutMs?: number, headers?: Record<string, string>);
     connect(): Promise<this>;
-    sendJson(payload: ProcessFrame): void;
-    sendStdin(data: string | Uint8Array): void;
-    closeStdin(): void;
+    sendJson(payload: ProcessFrame): Promise<void>;
+    sendStdin(data: string | Uint8Array, opts?: {
+        requestTimeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    closeStdin(opts?: {
+        requestTimeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
     close(): void;
     [Symbol.asyncIterator](): AsyncIterator<ProcessFrame>;
     private next;
     private onMessage;
     private finish;
     private flushDone;
+    private waitForControlAck;
+    private resolveControlAck;
+    private rejectControlAcks;
+    private removeControlAck;
+    private removeSignalListener;
 }
 export declare function base64Encode(bytes: Uint8Array): string;
 export declare function base64DecodeText(value: unknown): string;

package/dist/processSocket.js

@@ -12,6 +12,7 @@ export class ProcessSocket {
     ws;
     queue = [];
     waiters = [];
+    ackWaiters = new Map();
     closed = false;
     keepalive;
     constructor(baseUrl, token, path, requestTimeoutMs = 60_000, headers = {}) {
@@ -47,18 +48,41 @@ export class ProcessSocket {
         }, KEEPALIVE_PING_INTERVAL_SEC * 1000);
         return this;
     }
-    sendJson(payload) {
+    async sendJson(payload) {
         if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
             throw new SandboxError('process websocket is not connected');
         }
-        this.ws.send(JSON.stringify(payload));
+        await new Promise((resolve, reject) => {
+            this.ws.send(JSON.stringify(payload), (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
     }
-    sendStdin(data) {
+    async sendStdin(data, opts = {}) {
         const raw = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-        this.sendJson({ type: 'stdin', data: base64Encode(raw) });
+        const ack = this.waitForControlAck('stdin_ack', opts);
+        try {
+            await this.sendJson({ type: 'stdin', data: base64Encode(raw) });
+            await ack.promise;
+        }
+        catch (error) {
+            ack.cancel();
+            throw error;
+        }
     }
-    closeStdin() {
-        this.sendJson({ type: 'close_stdin' });
+    async closeStdin(opts = {}) {
+        const ack = this.waitForControlAck('close_stdin_ack', opts);
+        try {
+            await this.sendJson({ type: 'close_stdin' });
+            await ack.promise;
+        }
+        catch (error) {
+            ack.cancel();
+            throw error;
+        }
     }
     close() {
         this.closed = true;
@@ -86,6 +110,10 @@ export class ProcessSocket {
             const frame = JSON.parse(text);
             if (frame.type === 'pong' || frame.type === 'ready')
                 return;
+            if (frame.type === 'stdin_ack' || frame.type === 'close_stdin_ack') {
+                this.resolveControlAck(String(frame.type));
+                return;
+            }
             if (frame.type === 'error') {
                 this.finish(new SandboxError(String(frame.message ?? frame.code ?? 'process error')));
                 return;
@@ -112,6 +140,7 @@ export class ProcessSocket {
             else
                 this.queue.push(frame);
         }
+        this.rejectControlAcks(error ?? new SandboxError('process websocket closed before acknowledgement'));
         this.flushDone();
     }
     flushDone() {
@@ -119,6 +148,79 @@ export class ProcessSocket {
             waiter({ done: true, value: undefined });
         }
     }
+    waitForControlAck(type, opts = {}) {
+        if (opts.signal?.aborted) {
+            return {
+                promise: Promise.reject(new SandboxError('process control acknowledgement aborted')),
+                cancel: () => { },
+            };
+        }
+        let entry;
+        const promise = new Promise((resolve, reject) => {
+            const rejectWithAbort = () => {
+                this.removeControlAck(type, entry);
+                clearTimeout(entry.timer);
+                reject(new SandboxError('process control acknowledgement aborted'));
+            };
+            const timer = setTimeout(() => {
+                this.removeControlAck(type, entry);
+                this.removeSignalListener(entry);
+                reject(new TimeoutError());
+            }, opts.requestTimeoutMs ?? this.requestTimeoutMs);
+            entry = { resolve, reject, timer, signal: opts.signal };
+            if (opts.signal) {
+                entry.abort = rejectWithAbort;
+                opts.signal.addEventListener('abort', rejectWithAbort, { once: true });
+            }
+            const waiters = this.ackWaiters.get(type) ?? [];
+            waiters.push(entry);
+            this.ackWaiters.set(type, waiters);
+        });
+        return {
+            promise,
+            cancel: () => {
+                this.removeControlAck(type, entry);
+                clearTimeout(entry.timer);
+                if (entry.abort)
+                    opts.signal?.removeEventListener('abort', entry.abort);
+            },
+        };
+    }
+    resolveControlAck(type) {
+        const entry = this.ackWaiters.get(type)?.shift();
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        if (entry.abort)
+            this.removeSignalListener(entry);
+        entry.resolve();
+    }
+    rejectControlAcks(error) {
+        for (const waiters of this.ackWaiters.values()) {
+            for (const entry of waiters.splice(0)) {
+                clearTimeout(entry.timer);
+                if (entry.abort)
+                    this.removeSignalListener(entry);
+                entry.reject(error);
+            }
+        }
+        this.ackWaiters.clear();
+    }
+    removeControlAck(type, entry) {
+        const waiters = this.ackWaiters.get(type);
+        if (!waiters)
+            return;
+        const index = waiters.indexOf(entry);
+        if (index !== -1)
+            waiters.splice(index, 1);
+        if (waiters.length === 0)
+            this.ackWaiters.delete(type);
+    }
+    removeSignalListener(entry) {
+        if (entry.abort)
+            entry.signal?.removeEventListener('abort', entry.abort);
+        entry.abort = undefined;
+    }
 }
 export function base64Encode(bytes) {
     return Buffer.from(bytes).toString('base64');

package/dist/pty.js

@@ -15,7 +15,7 @@ export class Pty {
         const envs = { TERM: 'xterm-256color', LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8', ...(opts.envs ?? {}) };
         const size = opts.size ?? { cols: opts.cols ?? 80, rows: opts.rows ?? 24 };
         const args = opts.cmd === undefined ? ['-i', '-l'] : ['-l', '-c', opts.cmd];
-        socket.sendJson({
+        await socket.sendJson({
             type: 'start',
             cmd: '/bin/bash',
             args,

package/dist/sandbox.d.ts

@@ -7,6 +7,7 @@ import { Pty } from './pty.js';
 import { ProcessManager } from './process.js';
 import { TerminalManager } from './terminal.js';
 import type { Volume } from './volume.js';
+export declare const ALL_TRAFFIC = "0.0.0.0/0";
 export interface SandboxCreateOpts extends ConnectionOpts {
     /** Template slug to create. Defaults to "base". */
     template?: string;
@@ -31,7 +32,18 @@ export interface SandboxLifecycle {
     onTimeout: 'kill' | 'pause';
     autoResume?: boolean;
 }
-export type SandboxNetworkSelector = string | string[];
+export type SandboxNetworkTransform = {
+    headers?: Record<string, string>;
+};
+export type SandboxNetworkRule = {
+    transform?: SandboxNetworkTransform;
+};
+export type SandboxNetworkRules = Record<string, SandboxNetworkRule[]> | Map<string, SandboxNetworkRule[]>;
+export interface SandboxNetworkSelectorContext {
+    allTraffic: string;
+    rules: Map<string, SandboxNetworkRule[]>;
+}
+export type SandboxNetworkSelector = string | string[] | ((ctx: SandboxNetworkSelectorContext) => string[]);
 export interface SandboxNetworkUpdate {
     allowOut?: SandboxNetworkSelector;
     denyOut?: SandboxNetworkSelector;
@@ -41,9 +53,15 @@ export interface SandboxNetworkUpdate {
     egressProfile?: string;
     egressProfiles?: string[];
     networkClass?: string;
-    rules?: unknown;
+    rules?: SandboxNetworkRules;
     maskRequestHost?: string;
 }
+export type SandboxNetworkOpts = SandboxNetworkUpdate;
+export type SandboxNetworkInfo = SandboxNetworkUpdate;
+export type SandboxNetworkRuleInfo = Record<string, unknown>;
+export type SandboxOpts = SandboxCreateOpts;
+export type SandboxApiOpts = ConnectionOpts;
+export type SandboxState = string;
 export interface SandboxNetworkUpdateOpts extends ConnectionOpts {
 }
 export interface SandboxConnectOpts extends ConnectionOpts {
@@ -142,6 +160,17 @@ export interface RestoreSnapshotOpts extends ConnectionOpts {
     snapshotId?: string | number;
     timeoutMs?: number;
 }
+export interface SignatureOpts {
+    path: string;
+    operation: 'read' | 'write';
+    user?: string;
+    expirationInSeconds?: number;
+    envdAccessToken?: string;
+}
+export declare function getSignature({ path, operation, user, expirationInSeconds, envdAccessToken, }: SignatureOpts): Promise<{
+    signature: string;
+    expiration: number | null;
+}>;
 /** Paginator for listing sandbox snapshots. */
 export declare class SnapshotPaginator {
     private readonly opts;
@@ -195,7 +224,7 @@ export declare class Sandbox {
         sandbox?: Record<string, unknown>;
         envs?: Record<string, string>;
     });
-    /** Sandbox id alias used by SDK-compatible code. */
+    /** Unique sandbox identifier. */
     get id(): string;
     static create(opts?: SandboxCreateOpts): Promise<Sandbox>;
     static create(template: string, opts?: SandboxCreateOpts): Promise<Sandbox>;
@@ -232,6 +261,8 @@ export declare class Sandbox {
     setTimeout(timeoutMs: number, opts?: SandboxRequestOpts): Promise<void>;
     /** Fetch control-plane metadata for a sandbox by id. */
     static getInfo(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxInfo>;
+    /** Fetch full control-plane metadata for a sandbox by id. */
+    static getFullInfo(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxInfo>;
     /** Fetch the latest control-plane metadata for this sandbox. */
     getInfo(opts?: SandboxRequestOpts): Promise<SandboxInfo>;
     /** Fetch latest sandbox metrics. */
@@ -240,8 +271,6 @@ export declare class Sandbox {
     createSnapshot(opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
     /** Delete a snapshot by id. */
     deleteSnapshot(snapshotId: string, opts?: ConnectionOpts): Promise<boolean>;
-    /** Watasu-native alias for `createSnapshot`. */
-    checkpoint(opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
     /** List checkpoints for this sandbox using snapshot naming. */
     listSnapshots(opts?: Omit<SnapshotListOpts, 'sandboxId'>): SnapshotPaginator;
     /** Restore a checkpoint into a new sandbox and return its control-plane info. */