@watasu/sdk 0.1.51 → 0.1.53

package/dist/codeInterpreter.d.ts

@@ -1,4 +1,4 @@
-import { Sandbox as BaseSandbox, SandboxConnectOpts, SandboxCreateOpts } from './sandbox.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 { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
 export type { ConnectionOpts, Username } from './connectionConfig.js';
@@ -138,7 +138,6 @@ export declare class OutputMessage {
     readonly error: boolean;
     constructor(line: string, timestamp?: number, error?: boolean);
     toString(): string;
-    toJSON(): Record<string, unknown>;
 }
 /** Structured exception raised by user code inside the sandbox. */
 export declare class ExecutionError {
@@ -146,7 +145,6 @@ export declare class ExecutionError {
     readonly value: string;
     readonly traceback: string;
     constructor(name: string, value: string, traceback: string);
-    toJSON(): Record<string, unknown>;
 }
 /** Rich result produced by the last expression of a code execution. */
 export declare class Result {
@@ -170,8 +168,8 @@ export declare class Result {
     toJSON(): Record<string, unknown>;
 }
 export interface Logs {
-    stdout: OutputMessage[];
-    stderr: OutputMessage[];
+    stdout: string[];
+    stderr: string[];
 }
 /** Complete result of a sandbox code execution. */
 export declare class Execution {
@@ -189,37 +187,33 @@ export declare class Context {
     readonly language: string;
     readonly cwd: string;
     constructor(id: string, language?: string, cwd?: string);
-    toJSON(): Record<string, unknown>;
 }
 /** Sandbox specialized for running Python code. */
 export declare class Sandbox extends BaseSandbox {
-    static readonly defaultTemplate = "code-interpreter";
-    static create(opts?: SandboxCreateOpts): Promise<Sandbox>;
-    static create(template: string, opts?: SandboxCreateOpts): Promise<Sandbox>;
-    static connect(sandboxId: string, opts?: SandboxConnectOpts): Promise<Sandbox>;
+    protected static readonly defaultTemplate: string;
+    protected get jupyterUrl(): string;
     /** Run Python code in the sandbox and return structured execution output. */
     runCode(code: string, opts?: RunCodeOpts & {
+        /**
+         * Language to use for code execution.
+         *
+         * If not defined, the default Python context is used.
+         */
         language?: RunCodeLanguage;
     }): Promise<Execution>;
     runCode(code: string, opts?: RunCodeOpts & {
-        context?: Context | string;
+        /**
+         * Context to run the code in.
+         */
+        context?: Context;
     }): Promise<Execution>;
     /** Create a persistent code context. */
     createCodeContext(opts?: CreateCodeContextOpts): Promise<Context>;
     /** Remove a persistent code context. */
-    removeCodeContext(context: Context | string, opts?: {
-        requestTimeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
+    removeCodeContext(context: Context | string): Promise<void>;
     /** List persistent code contexts. */
-    listCodeContexts(opts?: {
-        requestTimeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<Context[]>;
+    listCodeContexts(): Promise<Context[]>;
     /** Restart a persistent code context. */
-    restartCodeContext(context: Context | string, opts?: {
-        requestTimeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
+    restartCodeContext(context: Context | string): Promise<void>;
 }
 export { Sandbox as default };

package/dist/codeInterpreter.js

@@ -50,13 +50,6 @@ export class OutputMessage {
     toString() {
         return this.line;
     }
-    toJSON() {
-        return {
-            line: this.line,
-            timestamp: this.timestamp,
-            error: this.error,
-        };
-    }
 }
 /** Structured exception raised by user code inside the sandbox. */
 export class ExecutionError {
@@ -68,13 +61,6 @@ export class ExecutionError {
         this.value = value;
         this.traceback = traceback;
     }
-    toJSON() {
-        return {
-            name: this.name,
-            value: this.value,
-            traceback: this.traceback,
-        };
-    }
 }
 /** Rich result produced by the last expression of a code execution. */
 export class Result {
@@ -107,7 +93,7 @@ export class Result {
         this.javascript = stringValue(payload.javascript);
         this.data = recordOrUndefined(payload.data);
         this.chart = chartFromApi(payload.chart);
-        this.extra = record(payload.extra);
+        this.extra = resultExtra(payload);
         this.isMainResult = Boolean(isMainResult ?? payload.is_main_result ?? payload.isMainResult);
     }
     formats() {
@@ -128,10 +114,7 @@ export class Result {
             latex: this.latex,
             json: this.json,
             javascript: this.javascript,
-            data: this.data,
-            chart: this.chart,
             extra: Object.keys(this.extra).length === 0 ? undefined : this.extra,
-            is_main_result: this.isMainResult,
         });
     }
 }
@@ -153,13 +136,9 @@ export class Execution {
     }
     toJSON() {
         return {
-            results: this.results.map((result) => result.toJSON()),
-            logs: {
-                stdout: this.logs.stdout.map((message) => message.toJSON()),
-                stderr: this.logs.stderr.map((message) => message.toJSON()),
-            },
-            error: this.error?.toJSON() ?? null,
-            execution_count: this.executionCount,
+            results: this.results,
+            logs: this.logs,
+            error: this.error,
         };
     }
 }
@@ -173,22 +152,12 @@ export class Context {
         this.language = language;
         this.cwd = cwd;
     }
-    toJSON() {
-        return compactRecord({
-            id: this.id,
-            language: this.language,
-            cwd: this.cwd,
-        });
-    }
 }
 /** Sandbox specialized for running Python code. */
 export class Sandbox extends BaseSandbox {
     static defaultTemplate = 'code-interpreter';
-    static async create(templateOrOpts, opts = {}) {
-        return await super.create(templateOrOpts, opts);
-    }
-    static async connect(sandboxId, opts = {}) {
-        return await super.connect(sandboxId, opts);
+    get jupyterUrl() {
+        return this.runtimeBaseUrl;
     }
     async runCode(code, opts = {}) {
         if (typeof code !== 'string')
@@ -200,7 +169,7 @@ export class Sandbox extends BaseSandbox {
             code,
             language: opts.language,
             context_id: contextId(opts.context),
-            env_vars: opts.envs,
+            envs: opts.envs,
             timeout_ms: opts.timeoutMs,
         });
         const response = await this.runtimePostJson('/runtime/v1/code/run', payload, {
@@ -222,14 +191,12 @@ export class Sandbox extends BaseSandbox {
         });
         return contextFromApi(response);
     }
-    /** Remove a persistent code context. */
     async removeCodeContext(context, opts = {}) {
         await this.runtimeDeleteJson(`/runtime/v1/code/contexts/${encodeURIComponent(requireContextId(context))}`, {
             requestTimeoutMs: opts.requestTimeoutMs,
             signal: opts.signal,
         });
     }
-    /** List persistent code contexts. */
     async listCodeContexts(opts = {}) {
         const response = await this.runtimeGetJson('/runtime/v1/code/contexts', {
             requestTimeoutMs: opts.requestTimeoutMs,
@@ -238,7 +205,6 @@ export class Sandbox extends BaseSandbox {
         const contexts = Array.isArray(response) ? response : arrayOfUnknown(response.contexts);
         return contexts.map((item) => contextFromApi(record(item)));
     }
-    /** Restart a persistent code context. */
     async restartCodeContext(context, opts = {}) {
         await this.runtimePostJson(`/runtime/v1/code/contexts/${encodeURIComponent(requireContextId(context))}/restart`, {}, {
             requestTimeoutMs: opts.requestTimeoutMs,
@@ -251,16 +217,16 @@ function executionFromApi(payload) {
     const execution = record(payload.execution ?? payload);
     const logs = record(execution.logs);
     return new Execution(arrayOfRecords(execution.results).map((item) => new Result(item)), {
-        stdout: arrayOfUnknown(logs.stdout).map((item) => outputMessageFromApi(item, false)),
-        stderr: arrayOfUnknown(logs.stderr).map((item) => outputMessageFromApi(item, true)),
+        stdout: arrayOfUnknown(logs.stdout).map(outputLineFromApi),
+        stderr: arrayOfUnknown(logs.stderr).map(outputLineFromApi),
     }, executionErrorFromApi(execution.error), numberValue(execution.execution_count ?? execution.executionCount));
 }
-function outputMessageFromApi(value, error) {
+function outputLineFromApi(value) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
         const item = value;
-        return new OutputMessage(String(item.line ?? ''), numberValue(item.timestamp) ?? Date.now() / 1000, Boolean(item.error ?? error));
+        return String(item.line ?? item.text ?? '');
     }
-    return new OutputMessage(String(value), Date.now() / 1000, error);
+    return String(value);
 }
 function executionErrorFromApi(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -270,9 +236,9 @@ function executionErrorFromApi(value) {
 }
 async function emitCallbacks(execution, opts) {
     for (const message of execution.logs.stdout)
-        await opts.onStdout?.(message);
+        await opts.onStdout?.(new OutputMessage(message, Date.now() / 1000, false));
     for (const message of execution.logs.stderr)
-        await opts.onStderr?.(message);
+        await opts.onStderr?.(new OutputMessage(message, Date.now() / 1000, true));
     for (const result of execution.results)
         await opts.onResult?.(result);
     if (execution.error !== undefined)
@@ -297,6 +263,33 @@ function compactRecord(payload) {
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
+function resultExtra(payload) {
+    const extra = record(payload.extra);
+    for (const [key, value] of Object.entries(payload)) {
+        if (!knownResultKeys.has(key))
+            extra[key] = value;
+    }
+    return extra;
+}
+const knownResultKeys = new Set([
+    'plain',
+    'text',
+    'html',
+    'markdown',
+    'svg',
+    'png',
+    'jpeg',
+    'pdf',
+    'latex',
+    'json',
+    'javascript',
+    'data',
+    'chart',
+    'extra',
+    'type',
+    'is_main_result',
+    'isMainResult',
+]);
 function recordOrUndefined(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
 }

package/dist/connectionConfig.d.ts

@@ -1,6 +1,12 @@
 export declare const KEEPALIVE_PING_INTERVAL_SEC = 50;
 export declare const SESSION_OPERATION_REQUEST_TIMEOUT_MS = 150000;
 export type Username = string;
+export interface Logger {
+    debug?: (...args: unknown[]) => void;
+    info?: (...args: unknown[]) => void;
+    warn?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+}
 /** Connection options accepted by Watasu SDK entrypoints. */
 export interface ConnectionOpts {
     apiKey?: string;
@@ -14,12 +20,21 @@ export interface ConnectionOpts {
     headers?: Record<string, string>;
     apiHeaders?: Record<string, string>;
     debug?: boolean;
+    logger?: Logger;
     signal?: AbortSignal;
-    proxy?: unknown;
+    proxy?: string;
 }
 /** Resolved connection settings used by control-plane and data-plane clients. */
 export declare class ConnectionConfig {
+    static envdPort: number;
+    static get domain(): string;
+    static get apiUrl(): string;
+    static get sandboxUrl(): string | undefined;
+    static get debug(): boolean;
+    static get apiKey(): string | undefined;
+    static get accessToken(): string | undefined;
     readonly apiKey?: string;
+    readonly accessToken?: string;
     readonly domain: string;
     readonly apiUrl: string;
     /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
@@ -29,8 +44,9 @@ export declare class ConnectionConfig {
     readonly headers: Record<string, string>;
     readonly apiHeaders: Record<string, string>;
     readonly debug: boolean;
+    readonly logger?: Logger;
     readonly signal?: AbortSignal;
-    readonly proxy?: unknown;
+    readonly proxy?: string;
     constructor(opts?: ConnectionOpts);
     /** HTTP headers including the configured bearer token. */
     get authHeaders(): Record<string, string>;
@@ -38,14 +54,14 @@ export declare class ConnectionConfig {
     getSignal(requestTimeoutMs?: number, signal?: AbortSignal | undefined): AbortSignal | undefined;
     /** Return the sandbox data-plane API URL for a Watasu route token. */
     getSandboxUrl(sandboxId: string, opts: {
-        sandboxDomain?: string;
+        sandboxDomain: string;
         envdPort: number;
     }): string;
     /** Return the direct sandbox data-plane API URL for a Watasu route token. */
     getSandboxDirectUrl(sandboxId: string, opts: {
-        sandboxDomain?: string;
+        sandboxDomain: string;
         envdPort: number;
     }): string;
     /** Return the public hostname for a Watasu sandbox route token and port. */
-    getHost(sandboxId: string, port: number, sandboxDomain?: string): string;
+    getHost(sandboxId: string, port: number, sandboxDomain: string): string;
 }

package/dist/connectionConfig.js

@@ -2,7 +2,34 @@ export const KEEPALIVE_PING_INTERVAL_SEC = 50;
 export const SESSION_OPERATION_REQUEST_TIMEOUT_MS = 150_000;
 /** Resolved connection settings used by control-plane and data-plane clients. */
 export class ConnectionConfig {
+    static envdPort = 49983;
+    static get domain() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_DOMAIN ?? 'watasu.io';
+    }
+    static get apiUrl() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;
+    }
+    static get sandboxUrl() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_SANDBOX_URL;
+    }
+    static get debug() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        const value = (env.WATASU_DEBUG ?? 'false').toLowerCase();
+        return value === 'true' || value === '1';
+    }
+    static get apiKey() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_API_KEY ?? env.WATASU_ACCESS_TOKEN;
+    }
+    static get accessToken() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_ACCESS_TOKEN ?? this.apiKey;
+    }
     apiKey;
+    accessToken;
     domain;
     apiUrl;
     /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
@@ -12,20 +39,20 @@ export class ConnectionConfig {
     headers;
     apiHeaders;
     debug;
+    logger;
     signal;
     proxy;
     constructor(opts = {}) {
         const env = typeof process !== 'undefined' ? process.env : {};
-        this.apiKey =
-            opts.apiKey ??
-                opts.accessToken ??
-                env.WATASU_API_KEY;
-        this.domain = opts.domain ?? env.WATASU_DOMAIN ?? 'watasu.io';
-        this.apiUrl =
-            opts.apiUrl ?? env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;
-        this.sandboxUrl =
-            opts.sandboxUrl ??
-                env.WATASU_SANDBOX_URL;
+        const token = opts.apiKey ??
+            opts.accessToken ??
+            ConnectionConfig.apiKey ??
+            ConnectionConfig.accessToken;
+        this.apiKey = token;
+        this.accessToken = opts.accessToken ?? token;
+        this.domain = opts.domain ?? ConnectionConfig.domain;
+        this.apiUrl = opts.apiUrl ?? env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;
+        this.sandboxUrl = opts.sandboxUrl ?? ConnectionConfig.sandboxUrl;
         this.dataPlaneDomain =
             opts.dataPlaneDomain ??
                 env.WATASU_DATA_PLANE_DOMAIN ??
@@ -33,14 +60,16 @@ export class ConnectionConfig {
         this.requestTimeoutMs = opts.requestTimeoutMs ?? 60_000;
         this.headers = opts.headers ?? {};
         this.apiHeaders = opts.apiHeaders ?? {};
-        this.debug = opts.debug ?? false;
+        this.debug = opts.debug ?? ConnectionConfig.debug;
+        this.logger = opts.logger;
         this.signal = opts.signal;
         this.proxy = opts.proxy;
     }
     /** HTTP headers including the configured bearer token. */
     get authHeaders() {
-        return this.apiKey
-            ? { ...this.headers, ...this.apiHeaders, Authorization: `Bearer ${this.apiKey}` }
+        const token = this.accessToken ?? this.apiKey;
+        return token
+            ? { ...this.headers, ...this.apiHeaders, Authorization: `Bearer ${token}` }
             : { ...this.headers, ...this.apiHeaders };
     }
     /** Return an abort signal that follows the caller signal and optional timeout. */
@@ -61,7 +90,6 @@ export class ConnectionConfig {
         }
         return controller.signal;
     }
-    /** Return the sandbox data-plane API URL for a Watasu route token. */
     getSandboxUrl(sandboxId, opts) {
         if (this.sandboxUrl)
             return this.sandboxUrl;
@@ -69,11 +97,12 @@ export class ConnectionConfig {
             return `http://localhost:${opts.envdPort}`;
         return `https://${sandboxId}.sandbox.${opts.sandboxDomain ?? this.dataPlaneDomain}`;
     }
-    /** Return the direct sandbox data-plane API URL for a Watasu route token. */
     getSandboxDirectUrl(sandboxId, opts) {
-        return this.getSandboxUrl(sandboxId, opts);
+        return this.getSandboxUrl(sandboxId, {
+            sandboxDomain: opts.sandboxDomain ?? this.dataPlaneDomain,
+            envdPort: opts.envdPort,
+        });
     }
-    /** Return the public hostname for a Watasu sandbox route token and port. */
     getHost(sandboxId, port, sandboxDomain = this.dataPlaneDomain) {
         if (this.debug)
             return `localhost:${port}`;

package/dist/filesystem.d.ts

@@ -22,6 +22,11 @@ export interface EntryInfo {
     path: string;
     size?: number;
     mode?: number;
+    permissions?: string;
+    owner?: string;
+    group?: string;
+    modifiedTime?: Date;
+    symlinkTarget?: string;
     uid?: number;
     gid?: number;
     mtime?: number;
@@ -44,6 +49,7 @@ export interface WatchOpts {
     recursive?: boolean;
     includeEntry?: boolean;
     allowNetworkMounts?: boolean;
+    timeoutMs?: number;
     requestTimeoutMs?: number;
     signal?: AbortSignal;
     user?: string;

package/dist/filesystem.js

@@ -76,7 +76,7 @@ export class FilesystemWatcher {
             recursive: nextOpts.recursive ?? false,
             include_entry: nextOpts.includeEntry,
             allow_network_mounts: nextOpts.allowNetworkMounts,
-        }), nextOpts.requestTimeoutMs, this.dataPlane.headers).connect();
+        }), nextOpts.requestTimeoutMs ?? nextOpts.timeoutMs, this.dataPlane.headers).connect();
         this.handle = new WatchHandle(socket, socket, async (event) => {
             for (const listener of this.listeners)
                 await listener(event);
@@ -265,6 +265,11 @@ function entryInfo(value) {
         path: String(item.path ?? ''),
         size: numberValue(item.bytes ?? item.size),
         mode: numberValue(item.mode),
+        permissions: stringValue(item.permissions),
+        owner: stringValue(item.owner),
+        group: stringValue(item.group),
+        modifiedTime: dateValue(item.modified_time ?? item.modifiedTime ?? item.mtime ?? item.updated_at ?? item.updatedAt),
+        symlinkTarget: stringValue(item.symlink_target ?? item.symlinkTarget),
         uid: numberValue(item.uid),
         gid: numberValue(item.gid),
         mtime: numberValue(item.mtime),
@@ -274,6 +279,23 @@ function entryInfo(value) {
 function numberValue(value) {
     return typeof value === 'number' ? value : undefined;
 }
+function stringValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+function dateValue(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        if (!Number.isNaN(date.getTime()))
+            return date;
+    }
+    return undefined;
+}
 function recordOfStrings(value) {
     if (!value || typeof value !== 'object')
         return undefined;

package/dist/git.d.ts

@@ -169,5 +169,8 @@ export declare class Git {
     setConfig(key: string, value: string, opts?: GitConfigOpts): Promise<GitCommandResult>;
     /** Read a Git config value. */
     getConfig(key: string, opts?: GitConfigOpts): Promise<string>;
+    private getRemoteUrl;
+    private resolveRemoteName;
+    private hasUpstream;
     private run;
 }

package/dist/git.js

@@ -1,3 +1,4 @@
+import { InvalidArgumentError } from './errors.js';
 /** Git helper backed by sandbox data-plane routes. */
 export class Git {
     dataPlane;
@@ -162,6 +163,31 @@ export class Git {
         }, opts);
         return String(result.value ?? '');
     }
+    async getRemoteUrl(path, remote, opts = {}) {
+        const url = await this.remoteGet(path, remote, opts);
+        if (!url) {
+            throw new InvalidArgumentError(`Remote "${remote}" URL not found in repository.`);
+        }
+        return url;
+    }
+    async resolveRemoteName(path, remote, opts = {}) {
+        if (remote)
+            return remote;
+        const status = await this.status(path, opts);
+        const upstreamRemote = status.upstream?.split('/')[0];
+        if (upstreamRemote)
+            return upstreamRemote;
+        throw new InvalidArgumentError('Remote is required when the repository has no upstream remote.');
+    }
+    async hasUpstream(path, opts = {}) {
+        try {
+            const status = await this.status(path, opts);
+            return Boolean(status.upstream);
+        }
+        catch {
+            return false;
+        }
+    }
     async run(path, json, opts) {
         const payload = await this.dataPlane.postJson(path, {
             json: compact(json),
@@ -173,7 +199,7 @@ export class Git {
 }
 function gitOpts(opts) {
     return {
-        env_vars: opts.envs,
+        envs: opts.envs,
         user: opts.user,
         cwd: opts.cwd,
         timeout_seconds: opts.timeoutMs === undefined ? undefined : Math.ceil(opts.timeoutMs / 1000),

package/dist/pty.d.ts

@@ -1,16 +1,21 @@
-import { CommandHandle, CommandStartOpts } from './commands.js';
-import { ConnectionConfig, type ConnectionOpts } from './connectionConfig.js';
+import { CommandHandle } from './commands.js';
+import { ConnectionConfig, type ConnectionOpts, type Username } from './connectionConfig.js';
 import { DataPlaneClient } from './transport.js';
 export interface PtySize {
     cols: number;
     rows: number;
 }
-export interface PtyCreateOpts extends Omit<CommandStartOpts, 'background' | 'onStdout' | 'onStderr'> {
+export interface PtyCreateOpts extends Pick<ConnectionOpts, 'requestTimeoutMs' | 'signal'> {
     cols?: number;
     rows?: number;
     size?: PtySize;
     cmd?: string;
+    cwd?: string;
+    user?: Username;
+    envs?: Record<string, string>;
+    timeoutMs?: number;
     onData?: (data: Uint8Array) => void | Promise<void>;
+    onPty?: (data: Uint8Array) => void | Promise<void>;
 }
 export interface PtyConnectOpts {
     onData?: (data: Uint8Array) => void | Promise<void>;

package/dist/sandbox.d.ts

@@ -81,31 +81,55 @@ 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;
+    cpuCount?: number;
+    memoryMB?: number;
+    envdVersion?: string;
+    allowInternetAccess?: boolean;
+    network?: SandboxNetworkInfo;
+    sandboxDomain?: string;
     lifecycle?: SandboxInfoLifecycle;
     volumeMounts?: Array<{
         name: string;
         path: string;
     }>;
     metadata: Record<string, string>;
-    startedAt?: string;
-    endAt?: string;
+    startedAt?: Date;
+    endAt?: Date;
 }
 export interface SandboxInfoLifecycle {
     onTimeout: 'kill' | 'pause' | string;
     autoResume: boolean;
 }
+type SandboxConnectionDetails = {
+    sandboxId: string;
+    sandboxDomain: string | undefined;
+    envdVersion: string;
+    envdAccessToken: string | undefined;
+    trafficAccessToken: string | undefined;
+    connectionConfig: ConnectionConfig;
+    control: ControlClient;
+    session: unknown;
+    sandbox: Record<string, unknown>;
+    envs?: Record<string, string>;
+};
 export interface SandboxMetrics {
+    timestamp?: Date;
     sandboxId?: string;
     state?: string;
     node?: string;
     backend?: string;
     cpuCount?: number;
+    cpuUsedPct?: number;
+    memUsed?: number;
+    memTotal?: number;
+    memCache?: number;
+    diskUsed?: number;
+    diskTotal?: number;
     memoryMb?: number;
     raw: Record<string, unknown>;
 }
@@ -117,6 +141,7 @@ export interface SandboxMetricsOpts extends ConnectionOpts {
 }
 export interface SnapshotInfo {
     snapshotId: string;
+    names: string[];
     sandboxId?: string;
     name?: string;
     status?: string;
@@ -196,22 +221,28 @@ export declare class SandboxPaginator {
 /** Running Watasu sandbox with ready `files` and `commands` helpers. */
 export declare class Sandbox {
     /** Default template slug used when create is called without a template. */
-    static readonly defaultTemplate: string;
+    protected static readonly defaultTemplate: string;
     /** Default template slug used by MCP creation once Watasu supports it. */
-    static readonly defaultMcpTemplate: string;
+    protected static readonly defaultMcpTemplate: string;
     /** Default sandbox lifetime in milliseconds. */
-    static readonly defaultSandboxTimeoutMs = 300000;
-    files: Filesystem;
-    commands: Commands;
-    process: ProcessManager;
-    pty: Pty;
-    terminal: TerminalManager;
-    git: Git;
+    protected static readonly defaultSandboxTimeoutMs = 300000;
+    readonly files: Filesystem;
+    readonly commands: Commands;
+    readonly process: ProcessManager;
+    readonly pty: Pty;
+    readonly terminal: TerminalManager;
+    readonly git: Git;
     cwd: string | undefined;
     readonly sandboxId: string;
-    private readonly mcpPort;
-    private mcpToken;
-    private readonly config;
+    readonly sandboxDomain: string;
+    readonly trafficAccessToken?: string;
+    protected readonly mcpPort = 50005;
+    protected readonly envdPort = 49983;
+    protected readonly connectionConfig: ConnectionConfig;
+    protected readonly envdAccessToken?: string;
+    private readonly envdApiUrl;
+    private readonly envdDirectUrl;
+    private mcpToken?;
     private readonly control;
     private readonly envs;
     private dataPlane;
@@ -226,10 +257,13 @@ export declare class Sandbox {
     });
     /** Unique sandbox identifier. */
     get id(): string;
-    static create(opts?: SandboxCreateOpts): Promise<Sandbox>;
-    static create(template: string, opts?: SandboxCreateOpts): Promise<Sandbox>;
+    static create<S extends typeof Sandbox>(this: S, opts?: SandboxOpts): Promise<InstanceType<S>>;
+    static create<S extends typeof Sandbox>(this: S, template: string, opts?: SandboxOpts): Promise<InstanceType<S>>;
+    protected static createSandbox(template: string, timeoutMs: number, opts?: SandboxCreateOpts): Promise<SandboxConnectionDetails>;
+    protected static createSandbox(template: string | undefined, timeoutMs: number, opts?: SandboxCreateOpts): Promise<SandboxConnectionDetails>;
     /** Connect to an existing sandbox and return it with a fresh data-plane session. */
-    static connect(sandboxId: string, opts?: SandboxConnectOpts): Promise<Sandbox>;
+    static connect<S extends typeof Sandbox>(this: S, sandboxId: string, opts?: SandboxConnectOpts): Promise<InstanceType<S>>;
+    protected static connectSandbox(sandboxId: string, opts?: SandboxConnectOpts): Promise<SandboxConnectionDetails>;
     /** Refresh this sandbox's data-plane session in place. */
     connect(opts?: SandboxConnectOpts): Promise<this>;
     /** Resume a paused sandbox by id. */
@@ -239,7 +273,7 @@ export declare class Sandbox {
     /** 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>;
+    static kill(sandboxId: string, opts?: ConnectionOpts): Promise<boolean>;
     /** Fetch sandbox metrics by id. */
     static getMetrics(sandboxId: string, opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
     /** Atomically replace a sandbox's network egress policy by id. */
@@ -252,19 +286,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(opts?: SandboxRequestOpts): Promise<boolean>;
+    kill(opts?: Pick<SandboxOpts, 'requestTimeoutMs' | 'signal'>): Promise<boolean>;
     /** Check if this sandbox is in a runtime-active lifecycle state. */
-    isRunning(opts?: SandboxRequestOpts): Promise<boolean>;
+    isRunning(opts?: Pick<ConnectionOpts, 'requestTimeoutMs' | 'signal'>): 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, opts?: SandboxRequestOpts): Promise<void>;
+    setTimeout(timeoutMs: number, opts?: Pick<SandboxOpts, 'requestTimeoutMs' | 'signal'>): 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>;
+    getInfo(opts?: Pick<SandboxOpts, 'requestTimeoutMs' | 'signal'>): Promise<SandboxInfo>;
     /** Fetch latest sandbox metrics. */
     getMetrics(opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
     /** Create a Watasu checkpoint using snapshot naming. */
@@ -276,7 +310,7 @@ export declare class Sandbox {
     /** Restore a checkpoint into a new sandbox and return its control-plane info. */
     restore(opts?: RestoreSnapshotOpts | string | number): Promise<SandboxInfo>;
     /** Return a paginator for sandboxes visible to the configured API key. */
-    static list(opts?: SandboxListOpts | string): SandboxPaginator;
+    static list(opts?: SandboxListOpts): SandboxPaginator;
     /** Return the public hostname for an exposed sandbox port. */
     getHost(port: number): string;
     /** Return the conventional MCP URL for this sandbox. */
@@ -292,7 +326,7 @@ export declare class Sandbox {
     /** Get signed download URL metadata for a sandbox file path. */
     downloadUrlInfo(path: string, opts?: SandboxUrlOpts): Promise<FileUrlInfo>;
     /** Atomically replace this sandbox's network egress policy. */
-    updateNetwork(network: SandboxNetworkUpdate, opts?: SandboxNetworkUpdateOpts): Promise<void>;
+    updateNetwork(network: SandboxNetworkUpdate, opts?: Pick<SandboxOpts, 'requestTimeoutMs' | 'signal'>): Promise<void>;
     /** Pause this sandbox. Returns false when it was already paused. */
     betaPause(opts?: ConnectionOpts): Promise<boolean>;
     /** Pause this sandbox. Returns false when it was already paused. */
@@ -300,12 +334,14 @@ export declare class Sandbox {
     /** Resume this sandbox and refresh its data-plane session. */
     resume(opts?: SandboxConnectOpts): Promise<boolean>;
     private fileUrl;
+    /** Base URL for the sandbox data-plane runtime API. */
+    protected get runtimeBaseUrl(): string;
     /** 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;
+    private resolveApiOpts;
 }
 export {};

package/dist/sandbox.js

@@ -101,25 +101,37 @@ export class Sandbox {
     git;
     cwd;
     sandboxId;
+    sandboxDomain;
+    trafficAccessToken;
     mcpPort = 50005;
+    envdPort = 49983;
+    connectionConfig;
+    envdAccessToken;
+    envdApiUrl;
+    envdDirectUrl;
     mcpToken;
-    config;
     control;
     envs;
     dataPlane;
     sandbox;
     constructor(opts) {
         this.sandboxId = String(opts.sandboxId);
-        this.config = opts.connectionConfig;
-        this.control = opts.control ?? new ControlClient(this.config);
+        this.connectionConfig = opts.connectionConfig;
+        this.control = opts.control ?? new ControlClient(this.connectionConfig);
         this.envs = opts.envs ?? {};
         this.sandbox = opts.sandbox ?? {};
-        const dataPlane = dataPlaneFromSession(opts.session, this.config);
+        const session = record(opts.session);
+        this.sandboxDomain = stringValue(session.sandbox_domain ?? session.sandboxDomain ?? this.sandbox.sandbox_domain ?? this.sandbox.domain) ?? '';
+        this.trafficAccessToken = stringValue(session.traffic_access_token ?? session.trafficAccessToken ?? this.sandbox.traffic_access_token ?? this.sandbox.trafficAccessToken);
+        this.envdAccessToken = stringValue(session.envd_access_token ?? session.envdAccessToken ?? session.token);
+        const dataPlane = dataPlaneFromSession(opts.session, this.connectionConfig);
         this.dataPlane = dataPlane;
+        this.envdApiUrl = dataPlane.baseUrl;
+        this.envdDirectUrl = dataPlane.baseUrl;
         this.files = new Filesystem(dataPlane);
-        this.commands = new Commands(dataPlane, this.config, this.envs);
+        this.commands = new Commands(dataPlane, this.connectionConfig, this.envs);
         this.process = new ProcessManager(this.commands);
-        this.pty = new Pty(dataPlane, this.config);
+        this.pty = new Pty(dataPlane, this.connectionConfig);
         this.terminal = new TerminalManager(this.pty);
         this.git = new Git(dataPlane);
     }
@@ -133,42 +145,62 @@ export class Sandbox {
         const template = typeof templateOrOpts === 'string'
             ? templateOrOpts
             : templateOrOpts?.template ?? (sandboxOpts.mcp === undefined ? this.defaultTemplate : undefined);
-        const config = new ConnectionConfig(sandboxOpts);
+        const sandboxInfo = await this.createSandbox(template, sandboxOpts.timeoutMs ?? this.defaultSandboxTimeoutMs, sandboxOpts);
+        return new this({
+            sandboxId: sandboxInfo.sandboxId,
+            connectionConfig: sandboxInfo.connectionConfig,
+            control: sandboxInfo.control,
+            session: sandboxInfo.session,
+            sandbox: sandboxInfo.sandbox,
+            envs: sandboxInfo.envs,
+        });
+    }
+    static async createSandbox(template, timeoutMs, opts = {}) {
+        const config = new ConnectionConfig(opts);
         const control = new ControlClient(config);
         const sandboxPayload = {
-            timeout: Math.ceil((sandboxOpts.timeoutMs ?? 300_000) / 1000),
-            metadata: sandboxOpts.metadata ?? {},
-            env_vars: sandboxOpts.envs ?? {},
-            secure: sandboxOpts.secure ?? true,
-            allow_internet_access: sandboxOpts.allowInternetAccess ?? true,
+            timeout: Math.ceil(timeoutMs / 1000),
+            metadata: opts.metadata ?? {},
+            envs: opts.envs ?? {},
+            secure: opts.secure ?? true,
+            allow_internet_access: opts.allowInternetAccess ?? true,
         };
-        putIfPresent(sandboxPayload, 'template_id', template);
-        putIfPresent(sandboxPayload, 'mcp', sandboxOpts.mcp);
-        putIfPresent(sandboxPayload, 'lifecycle', lifecyclePayload(sandboxOpts.lifecycle));
-        putIfPresent(sandboxPayload, 'volume_mounts', volumeMountsPayload(sandboxOpts.volumeMounts));
-        Object.assign(sandboxPayload, networkUpdatePayload(sandboxOpts.network));
-        putIfPresent(sandboxPayload, 'team', sandboxOpts.team);
+        putIfPresent(sandboxPayload, 'template', template);
+        putIfPresent(sandboxPayload, 'mcp', opts.mcp);
+        putIfPresent(sandboxPayload, 'lifecycle', lifecyclePayload(opts.lifecycle));
+        putIfPresent(sandboxPayload, 'volume_mounts', volumeMountsPayload(opts.volumeMounts));
+        Object.assign(sandboxPayload, networkUpdatePayload(opts.network));
+        putIfPresent(sandboxPayload, 'team', opts.team);
         const response = await control.post('/sandboxes', {
             json: sandboxPayload,
-            requestTimeoutMs: sessionOperationRequestTimeout(config, sandboxOpts),
-            signal: sandboxOpts.signal,
+            requestTimeoutMs: sessionOperationRequestTimeout(config, opts),
+            signal: opts.signal,
         });
         const sandbox = record(response.sandbox ?? response);
         const sandboxId = sandbox.id ?? sandbox.sandbox_id;
         if (sandboxId === undefined)
             throw new SandboxError('create response did not include sandbox id');
-        const sandboxInstance = new this({
+        return sandboxConnectionDetails({
             sandboxId: String(sandboxId),
-            connectionConfig: config,
+            config,
             control,
             session: response.session,
             sandbox,
-            envs: sandboxOpts.envs,
+            envs: opts.envs,
         });
-        return sandboxInstance;
     }
     /** Connect to an existing sandbox and return it with a fresh data-plane session. */
     static async connect(sandboxId, opts = {}) {
+        const sandboxInfo = await this.connectSandbox(sandboxId, opts);
+        return new this({
+            sandboxId: sandboxInfo.sandboxId,
+            connectionConfig: sandboxInfo.connectionConfig,
+            control: sandboxInfo.control,
+            session: sandboxInfo.session,
+            sandbox: sandboxInfo.sandbox,
+        });
+    }
+    static async connectSandbox(sandboxId, opts = {}) {
         const config = new ConnectionConfig(opts);
         const control = new ControlClient(config);
         const info = await control.get(`/sandboxes/${sandboxId}`, {
@@ -180,9 +212,9 @@ export class Sandbox {
             requestTimeoutMs: sessionOperationRequestTimeout(config, opts),
             signal: opts.signal,
         });
-        return new this({
+        return sandboxConnectionDetails({
             sandboxId,
-            connectionConfig: config,
+            config,
             control,
             session: response.session,
             sandbox: record(response.sandbox ?? info.sandbox ?? {}),
@@ -192,18 +224,19 @@ export class Sandbox {
     async connect(opts = {}) {
         const response = await this.control.post(`/sandboxes/${this.sandboxId}/resume`, {
             json: opts.timeoutMs ? { timeout: Math.ceil(opts.timeoutMs / 1000) } : {},
-            requestTimeoutMs: sessionOperationRequestTimeout(this.config, opts),
+            requestTimeoutMs: sessionOperationRequestTimeout(this.connectionConfig, opts),
             signal: opts.signal,
         });
         this.sandbox = record(response.sandbox ?? this.sandbox);
-        const dataPlane = dataPlaneFromSession(response.session, this.config);
+        const dataPlane = dataPlaneFromSession(response.session, this.connectionConfig);
+        const mutable = this;
         this.dataPlane = dataPlane;
-        this.files = new Filesystem(dataPlane);
-        this.commands = new Commands(dataPlane, this.config, this.envs);
-        this.process = new ProcessManager(this.commands);
-        this.pty = new Pty(dataPlane, this.config);
-        this.terminal = new TerminalManager(this.pty);
-        this.git = new Git(dataPlane);
+        mutable.files = new Filesystem(dataPlane);
+        mutable.commands = new Commands(dataPlane, this.connectionConfig, this.envs);
+        mutable.process = new ProcessManager(this.commands);
+        mutable.pty = new Pty(dataPlane, this.connectionConfig);
+        mutable.terminal = new TerminalManager(this.pty);
+        mutable.git = new Git(dataPlane);
         return this;
     }
     /** Resume a paused sandbox by id. */
@@ -233,11 +266,10 @@ export class Sandbox {
     }
     /** Destroy a sandbox by id. */
     static async kill(sandboxId, opts = {}) {
-        const requestOpts = typeof opts === 'string' ? {} : opts;
-        const control = new ControlClient(new ConnectionConfig(typeof opts === 'string' ? { apiKey: opts } : opts));
+        const control = new ControlClient(new ConnectionConfig(opts));
         await control.delete(`/sandboxes/${sandboxId}`, {
-            requestTimeoutMs: requestOpts.requestTimeoutMs,
-            signal: requestOpts.signal,
+            requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.signal,
         });
         return true;
     }
@@ -357,19 +389,19 @@ export class Sandbox {
     }
     /** Fetch latest sandbox metrics. */
     async getMetrics(opts = {}) {
-        return Sandbox.getMetrics(this.sandboxId, { ...this.configOptions(), ...opts });
+        return Sandbox.getMetrics(this.sandboxId, { ...this.resolveApiOpts(), ...opts });
     }
     /** Create a Watasu checkpoint using snapshot naming. */
     async createSnapshot(opts = {}) {
-        return Sandbox.createSnapshot(this.sandboxId, { ...this.configOptions(), ...opts });
+        return Sandbox.createSnapshot(this.sandboxId, { ...this.resolveApiOpts(), ...opts });
     }
     /** Delete a snapshot by id. */
     async deleteSnapshot(snapshotId, opts = {}) {
-        return Sandbox.deleteSnapshot(snapshotId, { ...this.configOptions(), ...opts });
+        return Sandbox.deleteSnapshot(snapshotId, { ...this.resolveApiOpts(), ...opts });
     }
     /** List checkpoints for this sandbox using snapshot naming. */
     listSnapshots(opts = {}) {
-        return Sandbox.listSnapshots({ ...this.configOptions(), ...opts, sandboxId: this.sandboxId });
+        return Sandbox.listSnapshots({ ...this.resolveApiOpts(), ...opts, sandboxId: this.sandboxId });
     }
     /** Restore a checkpoint into a new sandbox and return its control-plane info. */
     async restore(opts = {}) {
@@ -391,17 +423,16 @@ export class Sandbox {
     }
     /** Return a paginator for sandboxes visible to the configured API key. */
     static list(opts = {}) {
-        const listOpts = typeof opts === 'string' ? { apiKey: opts } : opts;
-        return new SandboxPaginator(listOpts);
+        return new SandboxPaginator(opts);
     }
     /** Return the public hostname for an exposed sandbox port. */
     getHost(port) {
         const routeToken = this.sandbox.route_token ??
             this.sandbox.routeToken ??
-            routeTokenFromDataPlaneUrl(this.dataPlane.baseUrl, this.config.dataPlaneDomain);
+            routeTokenFromDataPlaneUrl(this.dataPlane.baseUrl, this.connectionConfig.dataPlaneDomain);
         if (typeof routeToken !== 'string')
             throw new SandboxError('port response did not include host or url');
-        return `p${port}-${routeToken}.sandbox.${this.config.dataPlaneDomain}`;
+        return `p${port}-${routeToken}.sandbox.${this.connectionConfig.dataPlaneDomain}`;
     }
     /** Return the conventional MCP URL for this sandbox. */
     getMcpUrl() {
@@ -442,12 +473,12 @@ export class Sandbox {
     }
     /** Atomically replace this sandbox's network egress policy. */
     async updateNetwork(network, opts = {}) {
-        const sandbox = await Sandbox.putNetwork(this.sandboxId, network, { ...this.configOptions(), ...opts });
+        const sandbox = await Sandbox.putNetwork(this.sandboxId, network, { ...this.resolveApiOpts(), ...opts });
         this.sandbox = sandbox ?? this.sandbox;
     }
     /** Pause this sandbox. Returns false when it was already paused. */
     async betaPause(opts = {}) {
-        return Sandbox.betaPause(this.sandboxId, { ...this.configOptions(), ...opts });
+        return Sandbox.betaPause(this.sandboxId, { ...this.resolveApiOpts(), ...opts });
     }
     /** Pause this sandbox. Returns false when it was already paused. */
     async pause(opts = {}) {
@@ -471,6 +502,10 @@ export class Sandbox {
         });
         return fileUrlInfo(record(payload.file_url ?? payload));
     }
+    /** Base URL for the sandbox data-plane runtime API. */
+    get runtimeBaseUrl() {
+        return this.dataPlane.baseUrl;
+    }
     /** POST JSON to the sandbox data-plane runtime API. */
     async runtimePostJson(path, json, opts = {}) {
         return this.dataPlane.postJson(path, {
@@ -493,18 +528,18 @@ export class Sandbox {
             signal: opts.signal,
         });
     }
-    configOptions() {
+    resolveApiOpts() {
         return {
-            apiKey: this.config.apiKey,
-            apiUrl: this.config.apiUrl,
-            sandboxUrl: this.config.sandboxUrl,
-            dataPlaneDomain: this.config.dataPlaneDomain,
-            requestTimeoutMs: this.config.requestTimeoutMs,
-            headers: this.config.headers,
-            apiHeaders: this.config.apiHeaders,
-            debug: this.config.debug,
-            signal: this.config.signal,
-            proxy: this.config.proxy,
+            apiKey: this.connectionConfig.apiKey,
+            apiUrl: this.connectionConfig.apiUrl,
+            sandboxUrl: this.connectionConfig.sandboxUrl,
+            dataPlaneDomain: this.connectionConfig.dataPlaneDomain,
+            requestTimeoutMs: this.connectionConfig.requestTimeoutMs,
+            headers: this.connectionConfig.headers,
+            apiHeaders: this.connectionConfig.apiHeaders,
+            debug: this.connectionConfig.debug,
+            signal: this.connectionConfig.signal,
+            proxy: this.connectionConfig.proxy,
         };
     }
 }
@@ -567,6 +602,21 @@ function fileUrlInfo(payload) {
         raw: payload,
     };
 }
+function sandboxConnectionDetails(opts) {
+    const session = record(opts.session);
+    return {
+        sandboxId: opts.sandboxId,
+        sandboxDomain: stringValue(session.sandbox_domain ?? session.sandboxDomain ?? opts.sandbox.sandbox_domain ?? opts.sandbox.domain),
+        envdVersion: stringValue(session.envd_version ?? session.envdVersion ?? opts.sandbox.envd_version ?? opts.sandbox.envdVersion) ?? '',
+        envdAccessToken: stringValue(session.envd_access_token ?? session.envdAccessToken ?? session.token),
+        trafficAccessToken: stringValue(session.traffic_access_token ?? session.trafficAccessToken ?? opts.sandbox.traffic_access_token ?? opts.sandbox.trafficAccessToken),
+        connectionConfig: opts.config,
+        control: opts.control,
+        session: opts.session,
+        sandbox: opts.sandbox,
+        envs: opts.envs,
+    };
+}
 function compactRecord(payload) {
     return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));
 }
@@ -581,15 +631,17 @@ function sandboxInfo(payload) {
         templateId: typeof payload.template_id === 'string' ? payload.template_id : templateSlug(payload.template),
         name: typeof payload.name === 'string' ? payload.name : undefined,
         state: typeof payload.state === 'string' ? payload.state : undefined,
+        cpuCount: numberValue(payload.cpu_count ?? payload.cpuCount),
+        memoryMB: numberValue(payload.memory_mb ?? payload.memoryMB ?? payload.memoryMb),
+        envdVersion: stringValue(payload.envd_version ?? payload.envdVersion),
+        allowInternetAccess: booleanValue(payload.allow_internet_access ?? payload.allowInternetAccess),
+        network: sandboxNetworkInfo(payload.network),
+        sandboxDomain: stringValue(payload.sandbox_domain ?? payload.sandboxDomain),
         lifecycle: sandboxLifecycleInfo(payload.lifecycle),
         volumeMounts: volumeMountsInfo(payload.volume_mounts ?? payload.volumeMounts),
         metadata: recordOfStrings(payload.metadata),
-        startedAt: typeof payload.started_at === 'string'
-            ? payload.started_at
-            : typeof payload.created_at === 'string' ? payload.created_at : undefined,
-        endAt: typeof payload.end_at === 'string'
-            ? payload.end_at
-            : typeof payload.deadline_at === 'string' ? payload.deadline_at : undefined,
+        startedAt: dateValue(payload.started_at ?? payload.startedAt ?? payload.created_at ?? payload.createdAt ?? payload.ready_at ?? payload.readyAt),
+        endAt: dateValue(payload.end_at ?? payload.endAt ?? payload.deadline_at ?? payload.deadlineAt),
     };
 }
 function lifecyclePayload(lifecycle) {
@@ -631,6 +683,10 @@ function sandboxLifecycleInfo(value) {
         autoResume: autoResume ?? false,
     };
 }
+function sandboxNetworkInfo(value) {
+    const item = record(value);
+    return Object.keys(item).length > 0 ? item : undefined;
+}
 function metricsList(value) {
     if (Array.isArray(value))
         return value.map((item) => metricsInfo(record(item)));
@@ -638,11 +694,18 @@ function metricsList(value) {
 }
 function metricsInfo(value) {
     return {
+        timestamp: dateValue(value.timestamp ?? value.time ?? value.created_at ?? value.createdAt),
         sandboxId: stringValue(value.sandbox_id ?? value.sandboxId),
         state: stringValue(value.state),
         node: stringValue(value.node),
         backend: stringValue(value.backend),
         cpuCount: numberValue(value.cpu_count ?? value.cpuCount),
+        cpuUsedPct: numberValue(value.cpu_used_pct ?? value.cpuUsedPct ?? value.cpu_pct ?? value.cpuPct),
+        memUsed: numberValue(value.mem_used ?? value.memUsed ?? value.memory_used ?? value.memoryUsed),
+        memTotal: numberValue(value.mem_total ?? value.memTotal ?? value.memory_total ?? value.memoryTotal),
+        memCache: numberValue(value.mem_cache ?? value.memCache ?? value.memory_cache ?? value.memoryCache),
+        diskUsed: numberValue(value.disk_used ?? value.diskUsed),
+        diskTotal: numberValue(value.disk_total ?? value.diskTotal),
         memoryMb: numberValue(value.memory_mb ?? value.memoryMb),
         raw: value,
     };
@@ -659,10 +722,12 @@ function snapshotInfo(value) {
     const id = value.snapshot_id ?? value.snapshotId ?? value.checkpoint_id ?? value.checkpointId ?? value.id;
     if (id === undefined)
         throw new SandboxError('snapshot response did not include id');
+    const name = stringValue(value.name);
     return {
         snapshotId: String(id),
+        names: arrayOfStrings(value.names ?? value.name ?? value.snapshot_names ?? value.snapshotNames),
         sandboxId: stringValue(value.sandbox_id ?? value.sandboxId),
-        name: stringValue(value.name),
+        name,
         status: stringValue(value.status),
         sizeBytes: numberValue(value.size_bytes ?? value.sizeBytes),
         createdAt: stringValue(value.created_at ?? value.createdAt),
@@ -677,9 +742,26 @@ function stringValue(value) {
         return String(value);
     return undefined;
 }
+function arrayOfStrings(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (value === undefined || value === null || value === '')
+        return [];
+    return [String(value)];
+}
 function numberValue(value) {
     return typeof value === 'number' ? value : undefined;
 }
+function dateValue(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        if (!Number.isNaN(date.getTime()))
+            return date;
+    }
+    return undefined;
+}
 function booleanValue(value) {
     if (typeof value === 'boolean')
         return value;

package/dist/template.d.ts

@@ -236,6 +236,8 @@ export declare class TemplateBase {
     setEnvs(envs: Record<string, string>): TemplateBuilder;
     skipCache(): TemplateBuilder;
     toBuildSpec(): BuildSpec;
+    private toJSON;
+    private serialize;
     private addPackages;
     private requireDevContainerTemplate;
     private addCopySource;

package/dist/template.js

@@ -167,7 +167,7 @@ export class TemplateBase {
         return tags.map((item) => templateTag(record(item)));
     }
     static async toJSON(template) {
-        return JSON.stringify(template.toBuildSpec());
+        return template.toJSON();
     }
     static toDockerfile(template) {
         return template.toDockerfile();
@@ -392,6 +392,12 @@ export class TemplateBase {
             spec.ready_cmd = this.readyCmd;
         return spec;
     }
+    async toJSON(_computeHashes = true) {
+        return JSON.stringify(this.serialize());
+    }
+    serialize(_steps) {
+        return this.toBuildSpec();
+    }
     addPackages(manager, packages) {
         this.packages[manager] = [...(this.packages[manager] ?? []), ...packages];
     }

package/dist/volume.d.ts

@@ -41,8 +41,11 @@ export interface VolumeEntryStat {
 export interface VolumeApiParams extends ConnectionOpts {
     team?: string;
 }
-export type VolumeConnectionConfig = ConnectionOpts;
-export declare const VolumeConnectionConfig: typeof ConnectionConfig;
+export type VolumeApiOpts = ConnectionOpts;
+export declare class VolumeConnectionConfig extends ConnectionConfig {
+    readonly token?: string;
+    constructor(volume: Volume, opts?: VolumeApiOpts);
+}
 export interface VolumeListOpts extends ConnectionOpts {
     team?: string;
 }
@@ -66,7 +69,6 @@ export interface VolumeMetadataOpts extends ConnectionOpts {
 export type VolumeAndToken = VolumeInfo & {
     token: string;
 };
-export type VolumeApiOpts = ConnectionOpts;
 export type VolumeMetadataOptions = Omit<VolumeMetadataOpts, keyof ConnectionOpts>;
 export type VolumeWriteOptions = Omit<VolumeWriteFileOpts, keyof ConnectionOpts>;
 /** Persistent volume that can be mounted into sandboxes and edited while detached. */
@@ -75,8 +77,12 @@ export declare class Volume {
     readonly id: string;
     readonly name: string;
     readonly token?: string;
+    readonly domain?: string;
+    readonly debug?: boolean;
+    readonly proxy?: string;
     private readonly config;
     private readonly control;
+    constructor(volumeId: string, name: string, token: string, domain?: string, debug?: boolean, proxy?: string);
     constructor(opts: {
         volumeId: string;
         name?: string;
@@ -87,13 +93,13 @@ export declare class Volume {
     /** Create a persistent volume and return a connected SDK object. */
     static create(name: string, opts?: VolumeApiParams): Promise<Volume>;
     /** Connect to an existing volume by id or name. */
-    static connect(volumeId: string, opts?: VolumeConnectionConfig): Promise<Volume>;
+    static connect(volumeId: string, opts?: VolumeApiOpts): Promise<Volume>;
     /** Fetch metadata for an existing volume by id or name. */
-    static getInfo(volumeId: string, opts?: VolumeConnectionConfig): Promise<VolumeInfo>;
+    static getInfo(volumeId: string, opts?: VolumeApiOpts): Promise<VolumeInfo>;
     /** List volumes visible to the configured API key. */
     static list(opts?: VolumeListOpts): Promise<VolumeInfo[]>;
     /** Destroy a volume by id or name. Returns false when it does not exist. */
-    static destroy(volumeId: string, opts?: VolumeConnectionConfig): Promise<boolean>;
+    static destroy(volumeId: string, opts?: VolumeApiOpts): Promise<boolean>;
     /** Fetch this volume's latest metadata. */
     getInfo(): Promise<VolumeInfo>;
     /** Fetch metadata for a path inside this volume. */

package/dist/volume.js

@@ -10,21 +10,41 @@ export var VolumeFileType;
     VolumeFileType["DIRECTORY"] = "directory";
     VolumeFileType["SYMLINK"] = "symlink";
 })(VolumeFileType || (VolumeFileType = {}));
-export const VolumeConnectionConfig = ConnectionConfig;
+export class VolumeConnectionConfig extends ConnectionConfig {
+    token;
+    constructor(volume, opts = {}) {
+        super(opts);
+        this.token = volume.token;
+    }
+}
 /** Persistent volume that can be mounted into sandboxes and edited while detached. */
 export class Volume {
     volumeId;
     id;
     name;
     token;
+    domain;
+    debug;
+    proxy;
     config;
     control;
-    constructor(opts) {
+    constructor(volumeOrOpts, name, token, domain, debug, proxy) {
+        const opts = typeof volumeOrOpts === 'string'
+            ? {
+                volumeId: volumeOrOpts,
+                name,
+                token,
+                connectionConfig: new ConnectionConfig({ domain, debug, proxy }),
+            }
+            : volumeOrOpts;
         this.volumeId = String(opts.volumeId);
         this.id = this.volumeId;
         this.name = opts.name ?? this.volumeId;
         this.token = opts.token;
         this.config = opts.connectionConfig;
+        this.domain = this.config.domain;
+        this.debug = this.config.debug;
+        this.proxy = this.config.proxy;
         this.control = opts.control ?? new ControlClient(this.config);
     }
     /** Create a persistent volume and return a connected SDK object. */

package/package.json

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