@watasu/sdk 0.1.25 → 0.1.40

package/dist/process.js

@@ -67,10 +67,10 @@ export class Process {
     async kill() {
         await this.handle.kill();
     }
-    async wait(timeout) {
+    async wait(timeoutMs) {
         if (!this.waitPromise)
             this.waitPromise = this.waitOnce();
-        return waitFor(this.waitPromise, timeout);
+        return waitFor(this.waitPromise, timeoutMs);
     }
     async waitOnce() {
         try {
@@ -126,7 +126,7 @@ export class ProcessManager {
     }
     async startAndWait(cmdOrOpts) {
         const process = await this.start(cmdOrOpts);
-        return process.wait(typeof cmdOrOpts === 'string' ? undefined : cmdOrOpts.timeout);
+        return process.wait(typeof cmdOrOpts === 'string' ? undefined : cmdOrOpts.timeoutMs);
     }
 }
 function processOpts(cmdOrOpts) {

package/dist/processSocket.d.ts

@@ -5,12 +5,13 @@ export declare class ProcessSocket implements AsyncIterable<ProcessFrame> {
     private readonly token;
     private readonly path;
     private readonly requestTimeoutMs;
+    private readonly headers;
     private ws?;
     private queue;
     private waiters;
     private closed;
     private keepalive?;
-    constructor(baseUrl: string, token: string, path: string, requestTimeoutMs?: number);
+    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;

package/dist/processSocket.js

@@ -8,20 +8,22 @@ export class ProcessSocket {
     token;
     path;
     requestTimeoutMs;
+    headers;
     ws;
     queue = [];
     waiters = [];
     closed = false;
     keepalive;
-    constructor(baseUrl, token, path, requestTimeoutMs = 60_000) {
+    constructor(baseUrl, token, path, requestTimeoutMs = 60_000, headers = {}) {
         this.baseUrl = baseUrl;
         this.token = token;
         this.path = path;
         this.requestTimeoutMs = requestTimeoutMs;
+        this.headers = headers;
     }
     async connect() {
         const ws = new WebSocket(wsUrl(this.baseUrl, this.path), {
-            headers: { Authorization: `Bearer ${this.token}` },
+            headers: { ...this.headers, Authorization: `Bearer ${this.token}` },
         });
         this.ws = ws;
         ws.on('message', (data) => this.onMessage(data));

package/dist/pty.d.ts

@@ -1,5 +1,5 @@
 import { CommandHandle, CommandStartOpts } from './commands.js';
-import { ConnectionConfig } from './connectionConfig.js';
+import { ConnectionConfig, type ConnectionOpts } from './connectionConfig.js';
 import { DataPlaneClient } from './transport.js';
 export interface PtySize {
     cols: number;
@@ -28,10 +28,10 @@ export declare class Pty {
     connect(pid: number | string, opts?: PtyConnectOpts): Promise<CommandHandle>;
     /** Send input bytes or text to a PTY. */
     sendStdin(pid: number | string, data: string | Uint8Array, opts?: PtyConnectOpts): Promise<void>;
-    /** Alias for `sendStdin`. */
+    /** Send input bytes or text to a PTY. */
     sendInput(pid: number | string, data: string | Uint8Array, opts?: PtyConnectOpts): Promise<void>;
     /** Resize a running PTY. */
     resize(pid: number | string, size: PtySize, opts?: PtyConnectOpts): Promise<void>;
     /** Kill a running PTY. */
-    kill(pid: number | string): Promise<boolean>;
+    kill(pid: number | string, opts?: Pick<ConnectionOpts, 'requestTimeoutMs' | 'signal'>): Promise<boolean>;
 }

package/dist/pty.js

@@ -11,21 +11,21 @@ export class Pty {
     }
     /** Create an interactive shell PTY and return its live command handle. */
     async create(opts) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, '/runtime/v1/process', opts.requestTimeoutMs ?? this.config.requestTimeoutMs).connect();
-        const envs = { TERM: 'xterm-256color', LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8', ...(opts.envVars ?? opts.envs ?? {}) };
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, '/runtime/v1/process', opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
+        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({
             type: 'start',
             cmd: '/bin/bash',
             args,
-            cwd: opts.cwd ?? opts.rootDir,
+            cwd: opts.cwd,
             user: opts.user,
             environment: envs,
             envs,
             stdin: true,
             pty: { cols: size.cols, rows: size.rows },
-            timeout_ms: opts.timeoutMs ?? opts.timeout ?? 60_000,
+            timeout_ms: opts.timeoutMs ?? 60_000,
         });
         const first = await nextStarted(socket);
         const pid = framePid(first);
@@ -35,7 +35,7 @@ export class Pty {
     }
     /** Connect to a running PTY by pid. */
     async connect(pid, opts = {}) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, `/runtime/v1/process/${pid}/connect?since=0`, opts.requestTimeoutMs ?? this.config.requestTimeoutMs).connect();
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, `/runtime/v1/process/${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);
@@ -50,7 +50,7 @@ export class Pty {
             await handle.disconnect();
         }
     }
-    /** Alias for `sendStdin`. */
+    /** Send input bytes or text to a PTY. */
     async sendInput(pid, data, opts = {}) {
         return this.sendStdin(pid, data, opts);
     }
@@ -65,9 +65,11 @@ export class Pty {
         }
     }
     /** Kill a running PTY. */
-    async kill(pid) {
+    async kill(pid, opts = {}) {
         await this.dataPlane.postJson(`/runtime/v1/process/${pid}/signal`, {
             json: { signal: 'SIGKILL' },
+            requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.signal,
         });
         return true;
     }

package/dist/sandbox.d.ts

@@ -6,6 +6,7 @@ import { Git } from './git.js';
 import { Pty } from './pty.js';
 import { ProcessManager } from './process.js';
 import { TerminalManager } from './terminal.js';
+import type { Volume } from './volume.js';
 export interface SandboxCreateOpts extends ConnectionOpts {
     /** Template slug to create. Defaults to "base". */
     template?: string;
@@ -19,7 +20,16 @@ export interface SandboxCreateOpts extends ConnectionOpts {
     team?: string;
     /** MCP gateway configuration to launch inside an `mcp-gateway` sandbox. */
     mcp?: McpServer;
-    volumeMounts?: unknown;
+    /** Timeout lifecycle policy. Defaults to killing the sandbox at timeout. */
+    lifecycle?: SandboxLifecycle;
+    /** Persistent volumes to mount, keyed by guest path. */
+    volumeMounts?: Record<string, string | Volume | {
+        name: string;
+    }>;
+}
+export interface SandboxLifecycle {
+    onTimeout: 'kill' | 'pause';
+    autoResume?: boolean;
 }
 export type SandboxNetworkSelector = string | string[];
 export interface SandboxNetworkUpdate {
@@ -53,15 +63,25 @@ export interface SandboxListOpts extends ConnectionOpts {
     /** Team slug to list within. */
     team?: string;
 }
+type SandboxRequestOpts = Pick<ConnectionOpts, 'requestTimeoutMs' | 'signal'>;
 export interface SandboxInfo {
     sandboxId: string;
     templateId?: string;
     name?: string;
     state?: string;
+    lifecycle?: SandboxInfoLifecycle;
+    volumeMounts?: Array<{
+        name: string;
+        path: string;
+    }>;
     metadata: Record<string, string>;
     startedAt?: string;
     endAt?: string;
 }
+export interface SandboxInfoLifecycle {
+    onTimeout: 'kill' | 'pause' | string;
+    autoResume: boolean;
+}
 export interface SandboxMetrics {
     sandboxId?: string;
     state?: string;
@@ -71,6 +91,12 @@ export interface SandboxMetrics {
     memoryMb?: number;
     raw: Record<string, unknown>;
 }
+export interface SandboxMetricsOpts extends ConnectionOpts {
+    /** Start time for the metrics. Defaults to the sandbox start time. */
+    start?: Date;
+    /** End time for the metrics. Defaults to the current time. */
+    end?: Date;
+}
 export interface SnapshotInfo {
     snapshotId: string;
     sandboxId?: string;
@@ -114,7 +140,6 @@ export interface SnapshotListOpts extends ConnectionOpts {
 export interface RestoreSnapshotOpts extends ConnectionOpts {
     checkpointId?: string | number;
     snapshotId?: string | number;
-    timeout?: number;
     timeoutMs?: number;
 }
 /** Paginator for listing sandbox snapshots. */
@@ -148,14 +173,12 @@ export declare class Sandbox {
     /** Default sandbox lifetime in milliseconds. */
     static readonly defaultSandboxTimeoutMs = 300000;
     files: Filesystem;
-    filesystem: Filesystem;
     commands: Commands;
     process: ProcessManager;
     pty: Pty;
     terminal: TerminalManager;
     git: Git;
     cwd: string | undefined;
-    envVars: Record<string, string>;
     readonly sandboxId: string;
     private readonly mcpPort;
     private mcpToken;
@@ -178,28 +201,21 @@ export declare class Sandbox {
     static create(template: string, opts?: SandboxCreateOpts): Promise<Sandbox>;
     /** Connect to an existing sandbox and return it with a fresh data-plane session. */
     static connect(sandboxId: string, opts?: SandboxConnectOpts): Promise<Sandbox>;
-    /** Alias for `connect`. */
-    static reconnect(sandboxId: string, opts?: SandboxConnectOpts): Promise<Sandbox>;
-    static reconnect(opts: SandboxConnectOpts & {
-        sandboxID: string;
-    }): Promise<Sandbox>;
     /** Refresh this sandbox's data-plane session in place. */
     connect(opts?: SandboxConnectOpts): Promise<this>;
     /** Resume a paused sandbox by id. */
     static resume(sandboxId: string, opts?: SandboxConnectOpts): Promise<boolean>;
     /** Pause a sandbox by id. Returns false when it was already paused. */
     static betaPause(sandboxId: string, opts?: ConnectionOpts): Promise<boolean>;
-    /** Alias for `betaPause`. */
+    /** Pause a sandbox by id. */
     static pause(sandboxId: string, opts?: ConnectionOpts): Promise<boolean>;
     /** Destroy a sandbox by id. */
     static kill(sandboxId: string, opts?: ConnectionOpts | string): Promise<boolean>;
     /** Fetch sandbox metrics by id. */
-    static getMetrics(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxMetrics[]>;
+    static getMetrics(sandboxId: string, opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
     /** Atomically replace a sandbox's network egress policy by id. */
     static updateNetwork(sandboxId: string, network: SandboxNetworkUpdate, opts?: SandboxNetworkUpdateOpts): Promise<void>;
     private static putNetwork;
-    /** Deprecated alias for `getInfo`. */
-    static getFullInfo(sandboxId: string, opts?: ConnectionOpts): Promise<SandboxInfo>;
     /** Create a Watasu checkpoint using snapshot naming. */
     static createSnapshot(sandboxId: string, opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
     /** List snapshots visible to the configured API key. */
@@ -207,21 +223,19 @@ export declare class Sandbox {
     /** Delete a snapshot by id. Returns `false` when the snapshot does not exist. */
     static deleteSnapshot(snapshotId: string, opts?: ConnectionOpts): Promise<boolean>;
     /** Destroy this sandbox. */
-    kill(): Promise<boolean>;
+    kill(opts?: SandboxRequestOpts): Promise<boolean>;
     /** Check if this sandbox is in a runtime-active lifecycle state. */
-    isRunning(opts?: Pick<ConnectionOpts, 'requestTimeoutMs'>): Promise<boolean>;
+    isRunning(opts?: SandboxRequestOpts): Promise<boolean>;
     /** Set a sandbox's lifetime by id. */
     static setTimeout(sandboxId: string, timeoutMs: number, opts?: ConnectionOpts): Promise<void>;
     /** Set this sandbox's lifetime. */
-    setTimeout(timeoutMs: number): Promise<void>;
-    /** Keep the sandbox alive for `duration` milliseconds. */
-    keepAlive(duration: number): Promise<void>;
+    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 the latest control-plane metadata for this sandbox. */
-    getInfo(): Promise<SandboxInfo>;
+    getInfo(opts?: SandboxRequestOpts): Promise<SandboxInfo>;
     /** Fetch latest sandbox metrics. */
-    getMetrics(opts?: ConnectionOpts): Promise<SandboxMetrics[]>;
+    getMetrics(opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
     /** Create a Watasu checkpoint using snapshot naming. */
     createSnapshot(opts?: CreateSnapshotOpts): Promise<SnapshotInfo>;
     /** Delete a snapshot by id. */
@@ -236,16 +250,10 @@ export declare class Sandbox {
     static list(opts?: SandboxListOpts | string): SandboxPaginator;
     /** Return the public hostname for an exposed sandbox port. */
     getHost(port: number): string;
-    /** Return the public hostname for the sandbox or an exposed sandbox port. */
-    getHostname(port?: number): string;
     /** Return the conventional MCP URL for this sandbox. */
     getMcpUrl(): string;
     /** Return the MCP gateway token when the sandbox contains one. */
     getMcpToken(): Promise<string | undefined>;
-    /** Return a protocol string for a secure or insecure sandbox URL. */
-    getProtocol(baseProtocol?: string, secure?: boolean): string;
-    /** Close the local SDK attachment. This does not destroy the sandbox. */
-    close(): Promise<void>;
     /** Get a signed URL that accepts a POST upload for a sandbox file path. */
     uploadUrl(path?: string, opts?: SandboxUrlOpts): Promise<string>;
     /** Get a signed URL that accepts a GET download for a sandbox file path. */
@@ -258,12 +266,17 @@ export declare class Sandbox {
     updateNetwork(network: SandboxNetworkUpdate, opts?: SandboxNetworkUpdateOpts): Promise<void>;
     /** Pause this sandbox. Returns false when it was already paused. */
     betaPause(opts?: ConnectionOpts): Promise<boolean>;
-    /** Alias for `betaPause`. */
+    /** Pause this sandbox. Returns false when it was already paused. */
     pause(opts?: ConnectionOpts): Promise<boolean>;
     /** Resume this sandbox and refresh its data-plane session. */
     resume(opts?: SandboxConnectOpts): Promise<boolean>;
     private fileUrl;
     /** POST JSON to the sandbox data-plane runtime API. */
     protected runtimePostJson(path: string, json: Record<string, unknown>, opts?: ConnectionOpts): Promise<Record<string, unknown>>;
+    /** GET JSON from the sandbox data-plane runtime API. */
+    protected runtimeGetJson(path: string, opts?: ConnectionOpts): Promise<Record<string, unknown>>;
+    /** DELETE JSON from the sandbox data-plane runtime API. */
+    protected runtimeDeleteJson(path: string, opts?: ConnectionOpts): Promise<Record<string, unknown>>;
     private configOptions;
 }
+export {};