@watasu/sdk 0.1.40 → 0.1.50

package/README.md

@@ -71,7 +71,7 @@ await volume.destroy()
 ## Code Interpreter
 
 ```ts
-import { Sandbox } from '@watasu/sdk/code-interpreter'
+import { Sandbox } from '@watasu/code-interpreter'
 
 const sbx = await Sandbox.create()
 const context = await sbx.createCodeContext()
@@ -85,7 +85,7 @@ await sbx.removeCodeContext(context)
 await sbx.kill()
 ```
 
-`@watasu/sdk/code-interpreter` starts the `code-interpreter` template by default.
+`@watasu/code-interpreter` starts the `code-interpreter` template by default.
 Code runs in persistent Python contexts and returns structured `results`, `logs`,
 and `error` fields for each execution.
 
@@ -182,15 +182,21 @@ await sbx.kill()
 ```ts
 const sbx = await Sandbox.create({
   network: {
-    allowOut: ['pypi.org:443'],
+    allowOut: ({ rules }) => [...rules.keys(), 'pypi.org:443'],
     denyOut: ['169.254.169.254'],
+    rules: {
+      'api.example.com': [
+        { transform: { headers: { authorization: 'Bearer token' } } },
+      ],
+    },
+    maskRequestHost: '${PORT}-sandbox.example.com',
   },
 })
 
 await sbx.updateNetwork({
   allowInternetAccess: false,
   allowPackageRegistryAccess: true,
-  allowOut: ['pypi.org:443', 'registry.npmjs.org:443'],
+  allowOut: ['registry.npmjs.org:443'],
 })
 ```
 

package/dist/codeInterpreter.d.ts

@@ -1,33 +1,35 @@
 import { Sandbox as BaseSandbox, SandboxConnectOpts, SandboxCreateOpts } from './sandbox.js';
-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 { SandboxPaginator, SnapshotPaginator } from './sandbox.js';
-export type { CreateSnapshotOpts, FileUrlInfo, McpServer, McpServerName, RestoreSnapshotOpts, SandboxConnectOpts, SandboxCreateOpts, SandboxInfo, SandboxInfoLifecycle, SandboxLifecycle, SandboxListOpts, SandboxMetrics, SandboxMetricsOpts, SandboxNetworkSelector, SandboxNetworkUpdate, SandboxNetworkUpdateOpts, SandboxUrlOpts, SnapshotInfo, } from './sandbox.js';
+export type { ConnectionOpts, Username } from './connectionConfig.js';
+export { ControlClient as ApiClient } from './transport.js';
+export { ALL_TRAFFIC, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';
+export type { CreateSnapshotOpts, FileUrlInfo, McpServer, McpServerName, RestoreSnapshotOpts, SandboxApiOpts, SandboxConnectOpts, SandboxCreateOpts, SandboxInfo, SandboxInfoLifecycle, SandboxLifecycle, SandboxListOpts, SandboxMetrics, SandboxMetricsOpts, SandboxNetworkInfo, SandboxNetworkOpts, SandboxNetworkRule, SandboxNetworkRuleInfo, SandboxNetworkRules, SandboxNetworkSelector, SandboxNetworkSelectorContext, SandboxNetworkTransform, SandboxNetworkUpdate, SandboxNetworkUpdateOpts, SandboxOpts, SandboxState, SandboxUrlOpts, SignatureOpts, SnapshotInfo, SnapshotListOpts, } from './sandbox.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, GitCommitOpts, GitConfigOpts, GitConfigureUserOpts, GitCredentialOpts, GitFileStatus, GitInitOpts, GitPullOpts, GitPushOpts, GitRemoteAddOpts, GitResetMode, GitResetOpts, GitRestoreOpts, GitStatus, } from './git.js';
+export type { GitAddOpts, GitAuthOpts, GitBranches, GitBranchOpts, GitCloneOpts, GitCommandResult, GitCommitOpts, GitConfigScope, GitConfigOpts, GitConfigureUserOpts, GitCredentialOpts, GitDangerouslyAuthenticateOpts, GitDeleteBranchOpts, GitFileStatus, GitInitOpts, GitPullOpts, GitPushOpts, GitRemoteAddOpts, GitResetMode, GitResetOpts, GitRestoreOpts, GitStatus, } from './git.js';
 export { Pty } from './pty.js';
 export type { PtyConnectOpts, PtyCreateOpts, PtySize } from './pty.js';
 export { Terminal, TerminalManager, TerminalOutput } from './terminal.js';
 export type { TerminalOpts } from './terminal.js';
-export { Volume } from './volume.js';
-export type { VolumeApiParams, VolumeConnectionConfig, VolumeEntryStat, VolumeFileType, VolumeInfo, VolumeListFilesOpts, VolumeListOpts, VolumeMetadataOpts, VolumeReadFileOpts, VolumeReadFormat, VolumeWriteData, VolumeWriteFileOpts, } from './volume.js';
+export { Volume, VolumeConnectionConfig, VolumeFileType } from './volume.js';
+export type { VolumeAndToken, VolumeApiParams, VolumeApiOpts, VolumeEntryStat, VolumeInfo, VolumeListFilesOpts, VolumeListOpts, VolumeMetadataOpts, VolumeMetadataOptions, VolumeReadFileOpts, VolumeReadFormat, VolumeWriteData, VolumeWriteFileOpts, VolumeWriteOptions, } from './volume.js';
 export { ProcessSocket, base64DecodeBytes, base64DecodeText, base64Encode } from './processSocket.js';
-export { ReadyCmd, Template, TemplateBase, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
-export type { BuildInfo, BuildOptions, BuildStatusReason, CopyItem, GetBuildStatusOptions, LogEntry, ReadyCommand, TemplateBuilder, TemplateBuildStatus, TemplateBuildStatusResponse, TemplateClass, TemplateFactory, TemplateFinal, TemplateFromImage, TemplateOptions, TemplateTag, TemplateTagInfo, } from './template.js';
-export type RunCodeLanguage = 'python' | 'python3' | string;
+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, TemplateBuilder, TemplateBuildStatus, TemplateBuildStatusResponse, TemplateClass, TemplateFactory, TemplateFinal, TemplateFromImage, TemplateOptions, TemplateTag, TemplateTagInfo, } from './template.js';
+export type { components, paths } from './index.js';
+export type RunCodeLanguage = 'python' | 'javascript' | 'typescript' | 'r' | 'java' | 'bash' | (string & {});
+type OutputHandler<T> = (output: T) => Promise<unknown> | unknown;
 export interface RunCodeOpts {
-    language?: RunCodeLanguage;
-    context?: Context | string;
-    onStdout?: (message: OutputMessage) => void;
-    onStderr?: (message: OutputMessage) => void;
-    onResult?: (result: Result) => void;
-    onError?: (error: ExecutionError) => void;
+    onStdout?: OutputHandler<OutputMessage>;
+    onStderr?: OutputHandler<OutputMessage>;
+    onResult?: OutputHandler<Result>;
+    onError?: OutputHandler<ExecutionError>;
     envs?: Record<string, string>;
     timeoutMs?: number;
     requestTimeoutMs?: number;
@@ -39,6 +41,96 @@ export interface CreateCodeContextOpts {
     requestTimeoutMs?: number;
     signal?: AbortSignal;
 }
+/** Chart types returned by code execution results. */
+export declare enum ChartType {
+    LINE = "line",
+    SCATTER = "scatter",
+    BAR = "bar",
+    PIE = "pie",
+    BOX_AND_WHISKER = "box_and_whisker",
+    SUPERCHART = "superchart",
+    UNKNOWN = "unknown"
+}
+/** Axis scale types returned by chart results. */
+export declare enum ScaleType {
+    LINEAR = "linear",
+    DATETIME = "datetime",
+    CATEGORICAL = "categorical",
+    LOG = "log",
+    SYMLOG = "symlog",
+    LOGIT = "logit",
+    FUNCTION = "function",
+    FUNCTIONLOG = "functionlog",
+    ASINH = "asinh"
+}
+export type Chart = {
+    type: ChartType;
+    title: string;
+    elements: unknown[];
+};
+export type Chart2D = Chart & {
+    x_label?: string;
+    y_label?: string;
+    x_unit?: string;
+    y_unit?: string;
+};
+export type PointData = {
+    label: string;
+    points: [number | string, number | string][];
+};
+export type PointChart = Chart2D & {
+    x_ticks: (number | string)[];
+    x_scale: ScaleType;
+    x_tick_labels: string[];
+    y_ticks: (number | string)[];
+    y_scale: ScaleType;
+    y_tick_labels: string[];
+    elements: PointData[];
+};
+export type LineChart = PointChart & {
+    type: ChartType.LINE;
+};
+export type ScatterChart = PointChart & {
+    type: ChartType.SCATTER;
+};
+export type BarData = {
+    label: string;
+    value: string;
+    group: string;
+};
+export type BarChart = Chart2D & {
+    type: ChartType.BAR;
+    elements: BarData[];
+};
+export type PieData = {
+    label: string;
+    angle: number;
+    radius: number;
+};
+export type PieChart = Chart & {
+    type: ChartType.PIE;
+    elements: PieData[];
+};
+export type BoxAndWhiskerData = {
+    label: string;
+    min: number;
+    first_quartile: number;
+    median: number;
+    third_quartile: number;
+    max: number;
+    outliers: number[];
+};
+export type BoxAndWhiskerChart = Chart2D & {
+    type: ChartType.BOX_AND_WHISKER;
+    elements: BoxAndWhiskerData[];
+};
+export type SuperChart = Chart & {
+    type: ChartType.SUPERCHART;
+    elements: Chart[];
+};
+export type ChartTypes = LineChart | ScatterChart | BarChart | PieChart | BoxAndWhiskerChart | SuperChart;
+export type MIMEType = string;
+export type RawData = Record<string, unknown>;
 /** One stdout or stderr line emitted by code execution. */
 export declare class OutputMessage {
     readonly line: string;
@@ -58,6 +150,7 @@ export declare class ExecutionError {
 }
 /** Rich result produced by the last expression of a code execution. */
 export declare class Result {
+    readonly raw: RawData;
     readonly text?: string;
     readonly html?: string;
     readonly markdown?: string;
@@ -68,11 +161,11 @@ export declare class Result {
     readonly latex?: string;
     readonly json?: unknown;
     readonly javascript?: string;
-    readonly data?: unknown;
-    readonly chart?: unknown;
+    readonly data?: Record<string, unknown>;
+    readonly chart?: ChartTypes;
     readonly extra: Record<string, unknown>;
     readonly isMainResult: boolean;
-    constructor(payload?: Record<string, unknown>);
+    constructor(payload?: RawData, isMainResult?: boolean);
     formats(): string[];
     toJSON(): Record<string, unknown>;
 }
@@ -93,9 +186,9 @@ export declare class Execution {
 /** Code execution context metadata. */
 export declare class Context {
     readonly id: string;
-    readonly language?: string | undefined;
-    readonly cwd?: string | undefined;
-    constructor(id: string, language?: string | undefined, cwd?: string | undefined);
+    readonly language: string;
+    readonly cwd: string;
+    constructor(id: string, language?: string, cwd?: string);
     toJSON(): Record<string, unknown>;
 }
 /** Sandbox specialized for running Python code. */
@@ -105,9 +198,14 @@ export declare class Sandbox extends BaseSandbox {
     static create(template: string, opts?: SandboxCreateOpts): Promise<Sandbox>;
     static connect(sandboxId: string, opts?: SandboxConnectOpts): Promise<Sandbox>;
     /** Run Python code in the sandbox and return structured execution output. */
-    runCode(code: string, opts?: RunCodeOpts): Promise<Execution>;
+    runCode(code: string, opts?: RunCodeOpts & {
+        language?: RunCodeLanguage;
+    }): Promise<Execution>;
+    runCode(code: string, opts?: RunCodeOpts & {
+        context?: Context | string;
+    }): Promise<Execution>;
     /** Create a persistent code context. */
-    createCodeContext(_opts?: CreateCodeContextOpts): Promise<Context>;
+    createCodeContext(opts?: CreateCodeContextOpts): Promise<Context>;
     /** Remove a persistent code context. */
     removeCodeContext(context: Context | string, opts?: {
         requestTimeoutMs?: number;
@@ -124,3 +222,4 @@ export declare class Sandbox extends BaseSandbox {
         signal?: AbortSignal;
     }): Promise<void>;
 }
+export { Sandbox as default };

package/dist/codeInterpreter.js

@@ -1,17 +1,42 @@
 import { InvalidArgumentError } from './errors.js';
 import { Sandbox as BaseSandbox } from './sandbox.js';
-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 { SandboxPaginator, SnapshotPaginator } from './sandbox.js';
+export { ControlClient as ApiClient } from './transport.js';
+export { ALL_TRAFFIC, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';
 export { CommandExitError, CommandHandle, Commands } from './commands.js';
 export { Process, ProcessManager, ProcessMessage, ProcessOutput } from './process.js';
-export { FileType, Filesystem, FilesystemWatcher, WatchHandle } from './filesystem.js';
+export { FileType, Filesystem, FilesystemEventType, FilesystemWatcher, WatchHandle, } from './filesystem.js';
 export { Git } from './git.js';
 export { Pty } from './pty.js';
 export { Terminal, TerminalManager, TerminalOutput } from './terminal.js';
-export { Volume } from './volume.js';
+export { Volume, VolumeConnectionConfig, VolumeFileType } from './volume.js';
 export { ProcessSocket, base64DecodeBytes, base64DecodeText, base64Encode } from './processSocket.js';
-export { ReadyCmd, Template, TemplateBase, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
+export { ReadyCmd, Template, TemplateBase, LogEntry, LogEntryEnd, LogEntryStart, defaultBuildLogger, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL, } from './template.js';
+/** Chart types returned by code execution results. */
+export var ChartType;
+(function (ChartType) {
+    ChartType["LINE"] = "line";
+    ChartType["SCATTER"] = "scatter";
+    ChartType["BAR"] = "bar";
+    ChartType["PIE"] = "pie";
+    ChartType["BOX_AND_WHISKER"] = "box_and_whisker";
+    ChartType["SUPERCHART"] = "superchart";
+    ChartType["UNKNOWN"] = "unknown";
+})(ChartType || (ChartType = {}));
+/** Axis scale types returned by chart results. */
+export var ScaleType;
+(function (ScaleType) {
+    ScaleType["LINEAR"] = "linear";
+    ScaleType["DATETIME"] = "datetime";
+    ScaleType["CATEGORICAL"] = "categorical";
+    ScaleType["LOG"] = "log";
+    ScaleType["SYMLOG"] = "symlog";
+    ScaleType["LOGIT"] = "logit";
+    ScaleType["FUNCTION"] = "function";
+    ScaleType["FUNCTIONLOG"] = "functionlog";
+    ScaleType["ASINH"] = "asinh";
+})(ScaleType || (ScaleType = {}));
 /** One stdout or stderr line emitted by code execution. */
 export class OutputMessage {
     line;
@@ -53,6 +78,7 @@ export class ExecutionError {
 }
 /** Rich result produced by the last expression of a code execution. */
 export class Result {
+    raw;
     text;
     html;
     markdown;
@@ -67,7 +93,8 @@ export class Result {
     chart;
     extra;
     isMainResult;
-    constructor(payload = {}) {
+    constructor(payload = {}, isMainResult) {
+        this.raw = payload;
         this.text = stringValue(payload.text);
         this.html = stringValue(payload.html);
         this.markdown = stringValue(payload.markdown);
@@ -78,14 +105,16 @@ export class Result {
         this.latex = stringValue(payload.latex);
         this.json = payload.json;
         this.javascript = stringValue(payload.javascript);
-        this.data = payload.data;
-        this.chart = payload.chart;
+        this.data = recordOrUndefined(payload.data);
+        this.chart = chartFromApi(payload.chart);
         this.extra = record(payload.extra);
-        this.isMainResult = Boolean(payload.is_main_result ?? payload.isMainResult);
+        this.isMainResult = Boolean(isMainResult ?? payload.is_main_result ?? payload.isMainResult);
     }
     formats() {
         const names = ['text', 'html', 'markdown', 'svg', 'png', 'jpeg', 'pdf', 'latex', 'json', 'javascript', 'data', 'chart'];
-        return names.filter((name) => this[name] !== undefined);
+        const formats = names.filter((name) => this[name] !== undefined);
+        formats.push(...Object.keys(this.extra));
+        return formats;
     }
     toJSON() {
         return compactRecord({
@@ -139,7 +168,7 @@ export class Context {
     id;
     language;
     cwd;
-    constructor(id, language, cwd) {
+    constructor(id, language = '', cwd = '') {
         this.id = id;
         this.language = language;
         this.cwd = cwd;
@@ -161,7 +190,6 @@ export class Sandbox extends BaseSandbox {
     static async connect(sandboxId, opts = {}) {
         return await super.connect(sandboxId, opts);
     }
-    /** Run Python code in the sandbox and return structured execution output. */
     async runCode(code, opts = {}) {
         if (typeof code !== 'string')
             throw new InvalidArgumentError('code must be a string');
@@ -180,17 +208,17 @@ export class Sandbox extends BaseSandbox {
             signal: opts.signal,
         });
         const execution = executionFromApi(response);
-        emitCallbacks(execution, opts);
+        await emitCallbacks(execution, opts);
         return execution;
     }
     /** Create a persistent code context. */
-    async createCodeContext(_opts = {}) {
+    async createCodeContext(opts = {}) {
         const response = await this.runtimePostJson('/runtime/v1/code/contexts', compactRecord({
-            cwd: _opts.cwd,
-            language: _opts.language,
+            cwd: opts.cwd,
+            language: opts.language,
         }), {
-            requestTimeoutMs: _opts.requestTimeoutMs,
-            signal: _opts.signal,
+            requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.signal,
         });
         return contextFromApi(response);
     }
@@ -218,6 +246,7 @@ export class Sandbox extends BaseSandbox {
         });
     }
 }
+export { Sandbox as default };
 function executionFromApi(payload) {
     const execution = record(payload.execution ?? payload);
     const logs = record(execution.logs);
@@ -239,15 +268,15 @@ function executionErrorFromApi(value) {
     const item = value;
     return new ExecutionError(String(item.name ?? ''), String(item.value ?? ''), String(item.traceback ?? ''));
 }
-function emitCallbacks(execution, opts) {
+async function emitCallbacks(execution, opts) {
     for (const message of execution.logs.stdout)
-        opts.onStdout?.(message);
+        await opts.onStdout?.(message);
     for (const message of execution.logs.stderr)
-        opts.onStderr?.(message);
+        await opts.onStderr?.(message);
     for (const result of execution.results)
-        opts.onResult?.(result);
+        await opts.onResult?.(result);
     if (execution.error !== undefined)
-        opts.onError?.(execution.error);
+        await opts.onError?.(execution.error);
 }
 function contextId(context) {
     if (context === undefined)
@@ -260,7 +289,7 @@ function requireContextId(context) {
     return context.id;
 }
 function contextFromApi(payload) {
-    return new Context(String(payload.id ?? ''), stringValue(payload.language), stringValue(payload.cwd));
+    return new Context(String(payload.id ?? ''), stringValue(payload.language) ?? '', stringValue(payload.cwd) ?? '');
 }
 function compactRecord(payload) {
     return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));
@@ -268,6 +297,15 @@ function compactRecord(payload) {
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
+function recordOrUndefined(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function chartFromApi(value) {
+    const item = recordOrUndefined(value);
+    if (item === undefined)
+        return undefined;
+    return item;
+}
 function arrayOfRecords(value) {
     return Array.isArray(value) ? value.map((item) => record(item)) : [];
 }

package/dist/commands.d.ts

@@ -46,6 +46,15 @@ export interface CommandStartOpts {
     requestTimeoutMs?: number;
     signal?: AbortSignal;
 }
+export type CommandRequestOpts = Pick<CommandStartOpts, 'requestTimeoutMs' | 'signal'>;
+export interface CommandConnectOpts extends CommandRequestOpts {
+    timeoutMs?: number;
+    onStdout?: (data: string) => void | Promise<void>;
+    onStderr?: (data: string) => void | Promise<void>;
+}
+export type Stdout = string;
+export type Stderr = string;
+export type PtyOutput = Uint8Array;
 /** Live handle for one sandbox process stream. */
 export declare class CommandHandle implements Partial<CommandResult> {
     readonly pid: number | string;
@@ -70,9 +79,9 @@ export declare class CommandHandle implements Partial<CommandResult> {
     /** Kill the process. */
     kill(): Promise<boolean>;
     /** Send stdin bytes or text to the process. */
-    sendStdin(data: string | Uint8Array): Promise<void>;
+    sendStdin(data: string | Uint8Array, opts?: CommandRequestOpts): Promise<void>;
     /** Close the stdin stream and signal EOF to the process. */
-    closeStdin(): Promise<void>;
+    closeStdin(opts?: CommandRequestOpts): Promise<void>;
     /** Resize the attached PTY stream when this handle was created as a PTY. */
     resize(size: {
         cols: number;

package/dist/commands.js

@@ -56,16 +56,16 @@ export class CommandHandle {
         return this.handleKill();
     }
     /** Send stdin bytes or text to the process. */
-    async sendStdin(data) {
-        this.socket.sendStdin(data);
+    async sendStdin(data, opts = {}) {
+        await this.socket.sendStdin(data, opts);
     }
     /** Close the stdin stream and signal EOF to the process. */
-    async closeStdin() {
-        this.socket.closeStdin();
+    async closeStdin(opts = {}) {
+        await this.socket.closeStdin(opts);
     }
     /** Resize the attached PTY stream when this handle was created as a PTY. */
     async resize(size) {
-        this.socket.sendJson({ type: 'resize', cols: size.cols, rows: size.rows });
+        await this.socket.sendJson({ type: 'resize', cols: size.cols, rows: size.rows });
     }
     /** Detach the local stream without killing the process. */
     async disconnect() {
@@ -146,7 +146,7 @@ export class Commands {
     async sendStdin(pid, data, opts = {}) {
         const handle = await this.connect(pid, opts);
         try {
-            await handle.sendStdin(data);
+            await handle.sendStdin(data, opts);
         }
         finally {
             await handle.disconnect();
@@ -156,7 +156,7 @@ export class Commands {
     async closeStdin(pid, opts = {}) {
         const handle = await this.connect(pid, opts);
         try {
-            await handle.closeStdin();
+            await handle.closeStdin(opts);
         }
         finally {
             await handle.disconnect();
@@ -181,7 +181,7 @@ export class Commands {
         const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, '/runtime/v1/process', opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
         const environment = { ...this.sandboxEnvs, ...(opts.envs ?? {}) };
         const processConfig = processStartConfig(cmd, opts);
-        socket.sendJson({
+        await socket.sendJson({
             type: 'start',
             id: opts.processID,
             cmd: processConfig.cmd,
@@ -233,10 +233,11 @@ function framePid(frame) {
 function processInfo(value) {
     const item = value && typeof value === 'object' ? value : {};
     const process = item.process && typeof item.process === 'object' ? item.process : item;
+    const stablePid = typeof process.id === 'number' || typeof process.id === 'string' ? process.id : framePid(process);
     return {
-        pid: framePid(process) ?? '',
+        pid: stablePid ?? '',
         tag: typeof process.tag === 'string' ? process.tag : undefined,
-        cmd: typeof process.cmd === 'string' ? process.cmd : undefined,
+        cmd: typeof process.cmd === 'string' ? process.cmd : typeof process.command === 'string' ? process.command : undefined,
         args: Array.isArray(process.args) ? process.args.map(String) : [],
         envs: recordOfStrings(process.envs ?? process.environment),
         cwd: typeof process.cwd === 'string' ? process.cwd : undefined,

package/dist/connectionConfig.d.ts

@@ -1,5 +1,6 @@
 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;

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) {