@watasu/sdk 0.1.30 → 0.1.50

package/dist/connectionConfig.d.ts

@@ -1,14 +1,20 @@
 export declare const KEEPALIVE_PING_INTERVAL_SEC = 50;
 export declare const SESSION_OPERATION_REQUEST_TIMEOUT_MS = 150000;
+export type Username = string;
 /** Connection options accepted by Watasu SDK entrypoints. */
 export interface ConnectionOpts {
     apiKey?: string;
     accessToken?: string;
     domain?: string;
     apiUrl?: string;
+    /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
+    sandboxUrl?: string;
     dataPlaneDomain?: string;
     requestTimeoutMs?: number;
     headers?: Record<string, string>;
+    apiHeaders?: Record<string, string>;
+    debug?: boolean;
+    signal?: AbortSignal;
     proxy?: unknown;
 }
 /** Resolved connection settings used by control-plane and data-plane clients. */
@@ -16,11 +22,30 @@ export declare class ConnectionConfig {
     readonly apiKey?: string;
     readonly domain: string;
     readonly apiUrl: string;
+    /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
+    readonly sandboxUrl?: string;
     readonly dataPlaneDomain: string;
     readonly requestTimeoutMs: number;
     readonly headers: Record<string, string>;
+    readonly apiHeaders: Record<string, string>;
+    readonly debug: boolean;
+    readonly signal?: AbortSignal;
     readonly proxy?: unknown;
     constructor(opts?: ConnectionOpts);
     /** HTTP headers including the configured bearer token. */
     get authHeaders(): Record<string, string>;
+    /** Return an abort signal that follows the caller signal and optional timeout. */
+    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;
+        envdPort: number;
+    }): string;
+    /** Return the direct sandbox data-plane API URL for a Watasu route token. */
+    getSandboxDirectUrl(sandboxId: string, opts: {
+        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;
 }

package/dist/connectionConfig.js

@@ -5,9 +5,14 @@ export class ConnectionConfig {
     apiKey;
     domain;
     apiUrl;
+    /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
+    sandboxUrl;
     dataPlaneDomain;
     requestTimeoutMs;
     headers;
+    apiHeaders;
+    debug;
+    signal;
     proxy;
     constructor(opts = {}) {
         const env = typeof process !== 'undefined' ? process.env : {};
@@ -18,18 +23,60 @@ export class ConnectionConfig {
         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;
         this.dataPlaneDomain =
             opts.dataPlaneDomain ??
                 env.WATASU_DATA_PLANE_DOMAIN ??
                 'watasuhost.com';
         this.requestTimeoutMs = opts.requestTimeoutMs ?? 60_000;
         this.headers = opts.headers ?? {};
+        this.apiHeaders = opts.apiHeaders ?? {};
+        this.debug = opts.debug ?? false;
+        this.signal = opts.signal;
         this.proxy = opts.proxy;
     }
     /** HTTP headers including the configured bearer token. */
     get authHeaders() {
         return this.apiKey
-            ? { ...this.headers, Authorization: `Bearer ${this.apiKey}` }
-            : { ...this.headers };
+            ? { ...this.headers, ...this.apiHeaders, Authorization: `Bearer ${this.apiKey}` }
+            : { ...this.headers, ...this.apiHeaders };
+    }
+    /** Return an abort signal that follows the caller signal and optional timeout. */
+    getSignal(requestTimeoutMs = this.requestTimeoutMs, signal = this.signal) {
+        if (requestTimeoutMs === undefined && signal === undefined)
+            return undefined;
+        const controller = new AbortController();
+        if (signal?.aborted)
+            controller.abort();
+        else
+            signal?.addEventListener('abort', () => controller.abort(), { once: true });
+        if (requestTimeoutMs > 0) {
+            const timeout = setTimeout(() => controller.abort(), requestTimeoutMs);
+            const maybeTimeout = timeout;
+            if (typeof maybeTimeout.unref === 'function')
+                maybeTimeout.unref();
+            controller.signal.addEventListener('abort', () => clearTimeout(timeout), { once: true });
+        }
+        return controller.signal;
+    }
+    /** Return the sandbox data-plane API URL for a Watasu route token. */
+    getSandboxUrl(sandboxId, opts) {
+        if (this.sandboxUrl)
+            return this.sandboxUrl;
+        if (this.debug)
+            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 the public hostname for a Watasu sandbox route token and port. */
+    getHost(sandboxId, port, sandboxDomain = this.dataPlaneDomain) {
+        if (this.debug)
+            return `localhost:${port}`;
+        return `p${port}-${sandboxId}.sandbox.${sandboxDomain}`;
     }
 }

package/dist/errors.d.ts

@@ -25,6 +25,27 @@ export declare class NotEnoughSpaceError extends SandboxError {
 export declare class FileNotFoundError extends NotFoundError {
     constructor(message?: string);
 }
+export declare class SandboxNotFoundError extends NotFoundError {
+    constructor(message?: string);
+}
+export declare class GitAuthError extends AuthenticationError {
+    constructor(message?: string);
+}
+export declare class GitUpstreamError extends SandboxError {
+    constructor(message?: string);
+}
+export declare class TemplateError extends SandboxError {
+    constructor(message?: string);
+}
+export declare class BuildError extends Error {
+    constructor(message?: string);
+}
+export declare class FileUploadError extends BuildError {
+    constructor(message?: string);
+}
+export declare class VolumeError extends Error {
+    constructor(message?: string);
+}
 export declare function unsupported(feature: string): never;
 export declare class NotImplementedError extends Error {
     constructor(message: string);

package/dist/errors.js

@@ -52,6 +52,48 @@ export class FileNotFoundError extends NotFoundError {
         this.name = 'FileNotFoundError';
     }
 }
+export class SandboxNotFoundError extends NotFoundError {
+    constructor(message = 'Sandbox not found') {
+        super(message);
+        this.name = 'SandboxNotFoundError';
+    }
+}
+export class GitAuthError extends AuthenticationError {
+    constructor(message = 'Git authentication failed') {
+        super(message);
+        this.name = 'GitAuthError';
+    }
+}
+export class GitUpstreamError extends SandboxError {
+    constructor(message = 'Git upstream tracking is missing') {
+        super(message);
+        this.name = 'GitUpstreamError';
+    }
+}
+export class TemplateError extends SandboxError {
+    constructor(message = 'Template error') {
+        super(message);
+        this.name = 'TemplateError';
+    }
+}
+export class BuildError extends Error {
+    constructor(message = 'Build error') {
+        super(message);
+        this.name = 'BuildError';
+    }
+}
+export class FileUploadError extends BuildError {
+    constructor(message = 'File upload failed') {
+        super(message);
+        this.name = 'FileUploadError';
+    }
+}
+export class VolumeError extends Error {
+    constructor(message = 'Volume error') {
+        super(message);
+        this.name = 'VolumeError';
+    }
+}
 export function unsupported(feature) {
     throw new NotImplementedError(`${feature} is not supported by Watasu yet`);
 }
@@ -78,6 +120,18 @@ export function errorFromResponse(status, payload) {
         listMessage(body.errors) ||
         code ||
         `Request failed with status ${status}`;
+    if (code === 'not_enough_space')
+        return new NotEnoughSpaceError(message);
+    if (code === 'file_not_found')
+        return new FileNotFoundError(message);
+    if (code === 'sandbox_not_found')
+        return new SandboxNotFoundError(message);
+    if (code === 'git_auth')
+        return new GitAuthError(message);
+    if (code === 'git_upstream')
+        return new GitUpstreamError(message);
+    if (code === 'template_error')
+        return new TemplateError(message);
     if (status === 401 || status === 403)
         return new AuthenticationError(message);
     if (status === 404)
@@ -90,10 +144,6 @@ export function errorFromResponse(status, payload) {
         return new InvalidArgumentError(message);
     if (status === 429)
         return new RateLimitError(message);
-    if (code === 'not_enough_space')
-        return new NotEnoughSpaceError(message);
-    if (code === 'file_not_found')
-        return new FileNotFoundError(message);
     return new ApiError(message, status, code);
 }
 function asRecord(value) {

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,11 +43,15 @@ 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 {
     requestTimeoutMs?: number;
+    signal?: AbortSignal;
     user?: string;
 }
 export interface FilesystemReadOpts extends FilesystemRequestOpts {
@@ -47,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. */
@@ -56,8 +69,6 @@ export declare class WatchHandle {
     constructor(socket: ProcessSocket, events: AsyncIterable<ProcessFrame>, onEvent: (event: FilesystemEvent) => void | Promise<void>, onExit?: (error?: Error) => void | Promise<void>);
     /** Stop watching the directory. */
     stop(): void;
-    /** Alias for `stop`. */
-    close(): void;
     /** Resolves when the watcher stream exits. */
     wait(): Promise<void>;
     private pump;
@@ -102,30 +113,19 @@ export declare class Filesystem {
     /** Write several files in one runtime API call. */
     writeFiles(files: WriteEntry[], opts?: FilesystemWriteOpts): Promise<WriteInfo[]>;
     /** List directory entries below `path`. */
-    list(path: string, opts?: {
-        requestTimeoutMs?: number;
+    list(path: string, opts?: FilesystemRequestOpts & {
         depth?: number;
     }): Promise<EntryInfo[]>;
     /** Return whether a file or directory exists at `path`. */
-    exists(path: string, opts?: {
-        requestTimeoutMs?: number;
-    }): Promise<boolean>;
+    exists(path: string, opts?: FilesystemRequestOpts): Promise<boolean>;
     /** Return stat metadata for `path`. */
-    getInfo(path: string, opts?: {
-        requestTimeoutMs?: number;
-    }): Promise<EntryInfo>;
+    getInfo(path: string, opts?: FilesystemRequestOpts): Promise<EntryInfo>;
     /** Remove a file at `path`. */
-    remove(path: string, opts?: {
-        requestTimeoutMs?: number;
-    }): Promise<void>;
+    remove(path: string, opts?: FilesystemRequestOpts): Promise<void>;
     /** Move or rename a file. */
-    rename(oldPath: string, newPath: string, opts?: {
-        requestTimeoutMs?: number;
-    }): Promise<EntryInfo>;
+    rename(oldPath: string, newPath: string, opts?: FilesystemRequestOpts): Promise<EntryInfo>;
     /** Create a directory. */
-    makeDir(path: string, opts?: {
-        requestTimeoutMs?: number;
-    }): Promise<boolean>;
+    makeDir(path: string, opts?: FilesystemRequestOpts): Promise<boolean>;
     /** Start watching a directory for filesystem events. */
     watchDir(path: string): FilesystemWatcher;
     watchDir(path: string, onEvent: (event: FilesystemEvent) => void | Promise<void>, opts?: WatchOpts): Promise<FilesystemWatcher>;

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;
@@ -22,10 +31,6 @@ export class WatchHandle {
     stop() {
         this.socket.close();
     }
-    /** Alias for `stop`. */
-    close() {
-        this.stop();
-    }
     /** Resolves when the watcher stream exits. */
     wait() {
         return this.done;
@@ -66,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).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);
@@ -113,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. */
@@ -126,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 } : {}),
                 }))),
             },
         });
@@ -198,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);
@@ -257,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

@@ -20,16 +20,15 @@ export interface GitAuthOpts {
     envs?: Record<string, string>;
     user?: string;
     cwd?: string;
-    timeout?: number;
     timeoutMs?: number;
     requestTimeoutMs?: number;
+    signal?: AbortSignal;
 }
 export interface GitCloneOpts extends GitAuthOpts {
     path?: string;
     branch?: string;
     depth?: number;
     recursive?: boolean;
-    submodules?: boolean;
     dangerouslyStoreCredentials?: boolean;
 }
 export interface GitRequestOpts extends GitAuthOpts {
@@ -51,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;
@@ -84,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/git.js

@@ -9,7 +9,7 @@ export class Git {
         return this.run('/runtime/v1/git/clone', {
             url,
             ...gitOpts(opts),
-            ...pick(opts, ['path', 'branch', 'depth', 'recursive', 'submodules', 'username', 'password']),
+            ...pick(opts, ['path', 'branch', 'depth', 'recursive', 'username', 'password']),
             dangerously_store_credentials: opts.dangerouslyStoreCredentials,
         }, opts);
     }
@@ -163,7 +163,11 @@ export class Git {
         return String(result.value ?? '');
     }
     async run(path, json, opts) {
-        const payload = await this.dataPlane.postJson(path, { json: compact(json), requestTimeoutMs: opts.requestTimeoutMs });
+        const payload = await this.dataPlane.postJson(path, {
+            json: compact(json),
+            requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.signal,
+        });
         return gitResult(payload.git ?? payload);
     }
 }
@@ -172,7 +176,7 @@ function gitOpts(opts) {
         env_vars: opts.envs,
         user: opts.user,
         cwd: opts.cwd,
-        timeout_seconds: opts.timeout ?? (opts.timeoutMs === undefined ? undefined : Math.ceil(opts.timeoutMs / 1000)),
+        timeout_seconds: opts.timeoutMs === undefined ? undefined : Math.ceil(opts.timeoutMs / 1000),
     };
 }
 function pick(source, keys) {

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, 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, 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.d.ts

@@ -41,7 +41,7 @@ export declare class Process {
     private waitPromise?;
     constructor(processID: string, handle: CommandHandle, output: ProcessOutput, onExit?: ((exitCode: number) => Promise<void> | void) | undefined);
     kill(): Promise<void>;
-    wait(timeout?: number): Promise<ProcessOutput>;
+    wait(timeoutMs?: number): Promise<ProcessOutput>;
     private waitOnce;
     sendStdin(data: string): Promise<void>;
 }

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);
     }
 }
@@ -67,10 +71,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 +130,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) {