@watasu/sdk 0.1.30 → 0.1.50

package/README.md

@@ -16,7 +16,7 @@ Set `WATASU_API_KEY` before using the SDK.
 import { Sandbox } from '@watasu/sdk'
 
 const sbx = await Sandbox.create()
-await sbx.filesystem.write('/home/user/a.js', 'console.log(2 + 2)')
+await sbx.files.write('/home/user/a.js', 'console.log(2 + 2)')
 const result = await sbx.process.startAndWait('node /home/user/a.js')
 console.log(result.stdout)
 console.log(await sbx.isRunning())
@@ -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.
 
@@ -152,12 +152,12 @@ const remoteUrl = await sbx.git.remoteGet('/workspace/project', 'origin')
 await sbx.git.restore('/workspace/project', { paths: ['README.md'] })
 await sbx.git.reset('/workspace/project', { mode: 'hard', target: 'HEAD' })
 
-await sbx.filesystem.writeFiles([
+await sbx.files.writeFiles([
   { path: '/workspace/project/a.txt', data: 'alpha' },
   { path: '/workspace/project/b.bin', data: new Uint8Array([0, 1, 2]) },
 ])
 
-const watcher = sbx.filesystem.watchDir('/workspace/project')
+const watcher = sbx.files.watchDir('/workspace/project')
 watcher.addEventListener((event) => {
   console.log(event.type, event.path)
 })
@@ -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,21 +1,136 @@
 import { Sandbox as BaseSandbox, SandboxConnectOpts, SandboxCreateOpts } from './sandbox.js';
-export type RunCodeLanguage = 'python' | 'python3' | string;
+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 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 { 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, 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, 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, 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, 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>;
-    timeout?: number;
+    timeoutMs?: number;
     requestTimeoutMs?: number;
+    signal?: AbortSignal;
 }
 export interface CreateCodeContextOpts {
     cwd?: string;
     language?: RunCodeLanguage;
     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;
@@ -35,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;
@@ -45,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>;
 }
@@ -70,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. */
@@ -82,19 +198,28 @@ 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;
+        signal?: AbortSignal;
     }): Promise<void>;
     /** List persistent code contexts. */
     listCodeContexts(opts?: {
         requestTimeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<Context[]>;
     /** Restart a persistent code context. */
     restartCodeContext(context: Context | string, opts?: {
         requestTimeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<void>;
 }
+export { Sandbox as default };

package/dist/codeInterpreter.js

@@ -1,5 +1,42 @@
 import { InvalidArgumentError } from './errors.js';
 import { Sandbox as BaseSandbox } from './sandbox.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 { 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, 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, VolumeConnectionConfig, VolumeFileType } from './volume.js';
+export { ProcessSocket, base64DecodeBytes, base64DecodeText, base64Encode } from './processSocket.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;
@@ -41,6 +78,7 @@ export class ExecutionError {
 }
 /** Rich result produced by the last expression of a code execution. */
 export class Result {
+    raw;
     text;
     html;
     markdown;
@@ -55,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);
@@ -66,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({
@@ -127,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;
@@ -149,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');
@@ -161,22 +201,24 @@ export class Sandbox extends BaseSandbox {
             language: opts.language,
             context_id: contextId(opts.context),
             env_vars: opts.envs,
-            timeout_seconds: opts.timeout,
+            timeout_ms: opts.timeoutMs,
         });
         const response = await this.runtimePostJson('/runtime/v1/code/run', payload, {
             requestTimeoutMs: opts.requestTimeoutMs,
+            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,
+            requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.signal,
         });
         return contextFromApi(response);
     }
@@ -184,12 +226,14 @@ export class Sandbox extends BaseSandbox {
     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,
+            signal: opts.signal,
         });
         const contexts = Array.isArray(response) ? response : arrayOfUnknown(response.contexts);
         return contexts.map((item) => contextFromApi(record(item)));
@@ -198,9 +242,11 @@ export class Sandbox extends BaseSandbox {
     async restartCodeContext(context, opts = {}) {
         await this.runtimePostJson(`/runtime/v1/code/contexts/${encodeURIComponent(requireContextId(context))}/restart`, {}, {
             requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.signal,
         });
     }
 }
+export { Sandbox as default };
 function executionFromApi(payload) {
     const execution = record(payload.execution ?? payload);
     const logs = record(execution.logs);
@@ -222,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)
@@ -243,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));
@@ -251,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

@@ -34,23 +34,27 @@ export interface CommandStartOpts {
     /** Arguments for `cmd` when starting a direct executable. */
     args?: string[];
     cwd?: string;
-    /** Deprecated alias for `cwd`. */
-    rootDir?: string;
     user?: string;
     envs?: Record<string, string>;
-    /** Alias for `envs`. */
-    envVars?: Record<string, string>;
     onStdout?: (data: string) => void | Promise<void>;
     onStderr?: (data: string) => void | Promise<void>;
     onPty?: (data: Uint8Array) => void | Promise<void>;
     onExit?: (exitCode: number) => void | Promise<void>;
     stdin?: boolean;
     timeoutMs?: number;
-    /** Alias for `timeoutMs`. */
-    timeout?: number;
     processID?: string;
     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;
@@ -75,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;
@@ -98,18 +102,22 @@ export declare class Commands {
     /** List processes currently known by the sandbox runtime. */
     list(opts?: {
         requestTimeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<ProcessInfo[]>;
     /** Send SIGKILL to a process by pid. */
     kill(pid: number | string, opts?: {
         requestTimeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<boolean>;
     /** Attach to a process and send stdin bytes or text. */
     sendStdin(pid: number | string, data: string | Uint8Array, opts?: {
         requestTimeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<void>;
     /** Attach to a process and close stdin, signalling EOF. */
     closeStdin(pid: number | string, opts?: {
         requestTimeoutMs?: number;
+        signal?: AbortSignal;
     }): Promise<void>;
     run(cmd: string, opts: CommandStartOpts & {
         background: true;

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();
@@ -167,31 +167,31 @@ export class Commands {
         const handle = await this.start(cmd, opts);
         if (opts.background)
             return handle;
-        return handle.wait(opts.timeoutMs ?? opts.timeout);
+        return handle.wait(opts.timeoutMs);
     }
     /** Reconnect to a live process stream by pid. */
     async connect(pid, opts = {}) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, `/runtime/v1/process/${pid}/connect?since=0`, opts.requestTimeoutMs ?? this.config.requestTimeoutMs).connect();
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, `/runtime/v1/process/${pid}/connect?since=0`, opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
         const first = await nextStarted(socket);
         const actualPid = framePid(first) ?? pid;
         return new CommandHandle(actualPid, socket, () => this.kill(actualPid), socket, opts.onStdout, opts.onStderr, opts.onPty);
     }
     /** Start a command and return a live handle immediately. */
     async start(cmd, opts = {}) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, '/runtime/v1/process', opts.requestTimeoutMs ?? this.config.requestTimeoutMs).connect();
-        const environment = { ...this.sandboxEnvs, ...(opts.envVars ?? opts.envs ?? {}) };
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, '/runtime/v1/process', opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
+        const environment = { ...this.sandboxEnvs, ...(opts.envs ?? {}) };
         const processConfig = processStartConfig(cmd, opts);
-        socket.sendJson({
+        await socket.sendJson({
             type: 'start',
             id: opts.processID,
             cmd: processConfig.cmd,
             args: processConfig.args,
-            cwd: opts.cwd ?? opts.rootDir,
+            cwd: opts.cwd,
             user: opts.user,
             environment,
             envs: environment,
             stdin: opts.stdin ?? false,
-            timeout_ms: opts.timeoutMs ?? opts.timeout ?? 60_000,
+            timeout_ms: opts.timeoutMs ?? 60_000,
         });
         const first = await nextStarted(socket);
         const pid = framePid(first);
@@ -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,