@watasu/sdk 0.1.67 → 0.1.70

package/dist/codeInterpreter.d.ts

@@ -1,5 +1,5 @@
 import { Sandbox as BaseSandbox } from './sandbox.js';
-export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, SandboxOverloadedError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
 export type { ConnectionOpts, Username } from './connectionConfig.js';
 export { ControlClient as ApiClient } from './transport.js';

package/dist/codeInterpreter.js

@@ -1,6 +1,6 @@
 import { InvalidArgumentError } from './errors.js';
 import { Sandbox as BaseSandbox } from './sandbox.js';
-export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, SandboxOverloadedError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
 export { ControlClient as ApiClient } from './transport.js';
 export { ALL_TRAFFIC, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';

package/dist/commands.d.ts

@@ -94,21 +94,28 @@ export interface CommandConnectOpts extends CommandRequestOpts {
 export type Stdout = string;
 export type Stderr = string;
 export type PtyOutput = Uint8Array;
+type ProcessReconnect = (cursor: number) => Promise<{
+    socket: ProcessSocket;
+    events: AsyncIterable<ProcessFrame>;
+}>;
 /** Live handle for one sandbox process stream. */
 export declare class CommandHandle implements Partial<CommandResult> {
     readonly pid: number | string;
-    private readonly socket;
+    private socket;
     private readonly handleKill;
-    private readonly events;
+    private events;
     private readonly onStdout?;
     private readonly onStderr?;
     private readonly onPty?;
     private readonly onExit?;
+    private readonly reconnect?;
     private _stdout;
     private _stderr;
     private result?;
     private readonly pending;
-    constructor(pid: number | string, socket: ProcessSocket, handleKill: () => Promise<boolean>, events: AsyncIterable<ProcessFrame>, onStdout?: ((data: string) => void | Promise<void>) | undefined, onStderr?: ((data: string) => void | Promise<void>) | undefined, onPty?: ((data: Uint8Array) => void | Promise<void>) | undefined, onExit?: ((exitCode: number) => void | Promise<void>) | undefined);
+    private nextCursor;
+    private disconnected;
+    constructor(pid: number | string, socket: ProcessSocket, handleKill: () => Promise<boolean>, events: AsyncIterable<ProcessFrame>, onStdout?: ((data: string) => void | Promise<void>) | undefined, onStderr?: ((data: string) => void | Promise<void>) | undefined, onPty?: ((data: Uint8Array) => void | Promise<void>) | undefined, onExit?: ((exitCode: number) => void | Promise<void>) | undefined, reconnect?: ProcessReconnect | undefined);
     get stdout(): string;
     get stderr(): string;
     get exitCode(): number | undefined;
@@ -129,6 +136,8 @@ export declare class CommandHandle implements Partial<CommandResult> {
     /** Detach the local stream without killing the process. */
     disconnect(): Promise<void>;
     private handleEvents;
+    private advanceCursor;
+    private reconnectStream;
 }
 /** Command runner for a sandbox data-plane session. */
 export declare class Commands {
@@ -174,4 +183,6 @@ export declare class Commands {
     stopProcess(pid: number | string, opts?: StopProcessOptions): Promise<ProcessStatus>;
     /** Start a command and return a live handle immediately. */
     start(cmd: string, opts?: CommandStartOpts): Promise<CommandHandle>;
+    private openProcessStream;
 }
+export {};

package/dist/commands.js

@@ -14,6 +14,9 @@ export class CommandExitError extends SandboxError {
     get stdout() { return this.result.stdout; }
     get stderr() { return this.result.stderr; }
 }
+const STREAM_RECONNECT_ATTEMPTS = 12;
+const STREAM_RECONNECT_BASE_DELAY_MS = 250;
+const STREAM_RECONNECT_MAX_DELAY_MS = 2_000;
 /** Live handle for one sandbox process stream. */
 export class CommandHandle {
     pid;
@@ -24,11 +27,14 @@ export class CommandHandle {
     onStderr;
     onPty;
     onExit;
+    reconnect;
     _stdout = '';
     _stderr = '';
     result;
     pending;
-    constructor(pid, socket, handleKill, events, onStdout, onStderr, onPty, onExit) {
+    nextCursor = 0;
+    disconnected = false;
+    constructor(pid, socket, handleKill, events, onStdout, onStderr, onPty, onExit, reconnect) {
         this.pid = pid;
         this.socket = socket;
         this.handleKill = handleKill;
@@ -37,6 +43,7 @@ export class CommandHandle {
         this.onStderr = onStderr;
         this.onPty = onPty;
         this.onExit = onExit;
+        this.reconnect = reconnect;
         this.pending = this.handleEvents();
     }
     get stdout() { return this._stdout; }
@@ -70,11 +77,14 @@ export class CommandHandle {
     }
     /** Detach the local stream without killing the process. */
     async disconnect() {
+        this.disconnected = true;
         this.socket.close();
     }
     async handleEvents() {
-        try {
+        while (!this.disconnected && !this.result) {
+            let streamError;
             for await (const frame of this.events) {
+                this.advanceCursor(frame);
                 const type = frame.type;
                 if (type === 'started' || type === 'ready' || type === 'pong')
                     continue;
@@ -103,16 +113,51 @@ export class CommandHandle {
                         stderr: this._stderr,
                     };
                     await this.onExit?.(exitCode);
+                    this.socket.close();
                     return;
                 }
                 else if (type === 'error') {
-                    throw new SandboxError(String(frame.message ?? frame.code ?? 'process error'));
+                    streamError = new SandboxError(String(frame.message ?? frame.code ?? 'process error'));
+                    if (!isReconnectableStreamError(streamError))
+                        throw streamError;
+                    break;
                 }
             }
+            if (this.result || this.disconnected)
+                return;
+            if (!this.reconnect) {
+                this.socket.close();
+                if (streamError)
+                    throw streamError;
+                return;
+            }
+            await this.reconnectStream();
         }
-        finally {
+    }
+    advanceCursor(frame) {
+        const cursor = numberValue(frame.cursor);
+        if (cursor !== undefined)
+            this.nextCursor = Math.max(this.nextCursor, cursor + 1);
+    }
+    async reconnectStream() {
+        let lastError;
+        for (let attempt = 0; attempt < STREAM_RECONNECT_ATTEMPTS && !this.disconnected; attempt += 1) {
             this.socket.close();
+            if (attempt > 0)
+                await sleep(reconnectDelayMs(attempt));
+            try {
+                const next = await this.reconnect(this.nextCursor);
+                this.socket = next.socket;
+                this.events = next.events;
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
         }
+        if (lastError instanceof Error)
+            throw lastError;
+        throw new SandboxError('process websocket closed before exit and could not reconnect');
     }
 }
 /** Command runner for a sandbox data-plane session. */
@@ -177,11 +222,9 @@ export class Commands {
     }
     /** Reconnect to a live process stream by pid starting at a cursor. */
     async connectSince(pid, cursor = 0, opts = {}) {
-        const encodedPid = encodeURIComponent(String(pid));
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery(`/runtime/v1/process/${encodedPid}/connect`, { since: cursor }), opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
-        const first = await nextStarted(socket);
-        const actualPid = framePid(first) ?? pid;
-        return new CommandHandle(actualPid, socket, () => this.kill(actualPid), socket, opts.onStdout, opts.onStderr, opts.onPty);
+        const stream = await this.openProcessStream(pid, cursor, opts);
+        const reconnect = async (nextCursor) => this.openProcessStream(stream.actualPid, nextCursor, opts);
+        return new CommandHandle(stream.actualPid, stream.socket, () => this.kill(stream.actualPid), stream.events, opts.onStdout, opts.onStderr, opts.onPty, undefined, reconnect);
     }
     /** Look up process status without attaching a WebSocket. */
     async process(pid, opts = {}) {
@@ -229,7 +272,18 @@ export class Commands {
         const pid = framePid(first);
         if (pid === undefined)
             throw new SandboxError('process started frame did not include pid');
-        return new CommandHandle(pid, socket, () => this.kill(pid), withFirst(first, socket), opts.onStdout, opts.onStderr, opts.onPty, opts.onExit);
+        const reconnect = async (nextCursor) => this.openProcessStream(pid, nextCursor, opts);
+        return new CommandHandle(pid, socket, () => this.kill(pid), withFirst(first, socket), opts.onStdout, opts.onStderr, opts.onPty, opts.onExit, reconnect);
+    }
+    async openProcessStream(pid, cursor, opts = {}) {
+        const encodedPid = encodeURIComponent(String(pid));
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery(`/runtime/v1/process/${encodedPid}/connect`, { since: cursor }), opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
+        const first = await nextStarted(socket);
+        return {
+            actualPid: framePid(first) ?? pid,
+            socket,
+            events: socket,
+        };
     }
 }
 function processStartConfig(cmd, opts) {
@@ -246,6 +300,15 @@ function waitFor(promise, timeoutMs) {
         promise.then(resolve, reject).finally(() => clearTimeout(timer));
     });
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function reconnectDelayMs(attempt) {
+    return Math.min(STREAM_RECONNECT_MAX_DELAY_MS, STREAM_RECONNECT_BASE_DELAY_MS * 2 ** Math.max(0, attempt - 1));
+}
+function isReconnectableStreamError(error) {
+    return error instanceof Error && /websocket|closed/i.test(error.message);
+}
 async function nextStarted(events) {
     for await (const frame of events) {
         if (frame.type === 'started')

package/dist/errors.d.ts

@@ -51,4 +51,7 @@ export declare class ApiError extends SandboxError {
     readonly code?: string | undefined;
     constructor(message: string, status: number, code?: string | undefined);
 }
+export declare class SandboxOverloadedError extends ApiError {
+    constructor(message?: string);
+}
 export declare function errorFromResponse(status: number, payload: unknown): Error;

package/dist/errors.js

@@ -104,11 +104,21 @@ export class ApiError extends SandboxError {
         this.name = 'ApiError';
     }
 }
+export class SandboxOverloadedError extends ApiError {
+    constructor(message = 'Sandbox is overloaded') {
+        super(message, 503, 'sandbox_overloaded');
+        this.name = 'SandboxOverloadedError';
+    }
+}
 export function errorFromResponse(status, payload) {
     const body = asRecord(payload);
+    const reason = asRecord(body.reason);
     const code = stringValue(body.error);
     const message = stringValue(body.message) ||
         listMessage(body.errors) ||
+        stringValue(reason.message) ||
+        listMessage(reason.errors) ||
+        stringValue(body.reason) ||
         code ||
         `Request failed with status ${status}`;
     if (code === 'not_enough_space')
@@ -117,6 +127,8 @@ export function errorFromResponse(status, payload) {
         return new FileNotFoundError(message);
     if (code === 'sandbox_not_found')
         return new SandboxNotFoundError(message);
+    if (code === 'sandbox_overloaded')
+        return new SandboxOverloadedError(message);
     if (code === 'git_auth')
         return new GitAuthError(message);
     if (code === 'git_upstream')

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, SandboxOverloadedError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
 export type { ConnectionOpts, Username } from './connectionConfig.js';
 export { ControlClient as ApiClient } from './transport.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, RateLimitError, SandboxError, SandboxNotFoundError, SandboxOverloadedError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
 export { ControlClient as ApiClient } from './transport.js';
 export { ALL_TRAFFIC, Sandbox, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';

package/dist/pty.d.ts

@@ -39,4 +39,5 @@ export declare class Pty {
     resize(pid: number | string, size: PtySize, opts?: PtyConnectOpts): Promise<void>;
     /** Kill a running PTY. */
     kill(pid: number | string, opts?: Pick<ConnectionOpts, 'requestTimeoutMs' | 'signal'>): Promise<boolean>;
+    private openPtyStream;
 }

package/dist/pty.js

@@ -32,14 +32,14 @@ export class Pty {
         const pid = framePid(first);
         if (pid === undefined)
             throw new SandboxError('PTY started frame did not include pid');
-        return new CommandHandle(pid, socket, () => this.kill(pid), withFirst(first, socket), undefined, undefined, opts.onData ?? opts.onPty);
+        const reconnect = async (cursor) => this.openPtyStream(pid, cursor, opts);
+        return new CommandHandle(pid, socket, () => this.kill(pid), withFirst(first, socket), undefined, undefined, opts.onData ?? opts.onPty, undefined, reconnect);
     }
     /** Connect to a running PTY by pid. */
     async connect(pid, opts = {}) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery(`/runtime/v1/process/${encodeURIComponent(String(pid))}/connect`, { since: 0 }), opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
-        const first = await nextStarted(socket);
-        const actualPid = framePid(first) ?? pid;
-        return new CommandHandle(actualPid, socket, () => this.kill(actualPid), withFirst(first, socket), undefined, undefined, opts.onData);
+        const stream = await this.openPtyStream(pid, 0, opts);
+        const reconnect = async (cursor) => this.openPtyStream(stream.actualPid, cursor, opts);
+        return new CommandHandle(stream.actualPid, stream.socket, () => this.kill(stream.actualPid), stream.events, undefined, undefined, opts.onData, undefined, reconnect);
     }
     /** Send input bytes or text to a PTY. */
     async sendStdin(pid, data, opts = {}) {
@@ -76,6 +76,15 @@ export class Pty {
         });
         return true;
     }
+    async openPtyStream(pid, cursor, opts = {}) {
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery(`/runtime/v1/process/${encodeURIComponent(String(pid))}/connect`, { since: cursor }), opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
+        const first = await nextStarted(socket);
+        return {
+            actualPid: framePid(first) ?? pid,
+            socket,
+            events: withFirst(first, socket),
+        };
+    }
 }
 async function nextStarted(events) {
     for await (const frame of events) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watasu/sdk",
-  "version": "0.1.67",
+  "version": "0.1.70",
   "type": "module",
   "license": "MIT OR Apache-2.0",
   "description": "TypeScript SDK for Watasu",