@watasu/sdk 0.1.53 → 0.1.67

package/README.md

@@ -156,6 +156,15 @@ await sbx.files.writeFiles([
   { path: '/workspace/project/a.txt', data: 'alpha' },
   { path: '/workspace/project/b.bin', data: new Uint8Array([0, 1, 2]) },
 ])
+const patch = await sbx.files.applyDiff(
+  `*** Begin Patch
+*** Update File: /workspace/project/a.txt
+@@
+-alpha
++beta
+*** End Patch`
+)
+console.log(patch.status)
 
 const watcher = sbx.files.watchDir('/workspace/project')
 watcher.addEventListener((event) => {

package/dist/codeInterpreter.d.ts

@@ -6,7 +6,7 @@ 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 type { CommandConnectOpts, CommandRequestOpts, CommandResult, CommandStartOpts, ProcessInfo, ProcessOutputEvent, ProcessOutputSnapshot, ProcessStatus, PtyOutput, ReadProcessOutputOptions, Stderr, StopProcessOptions, 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';

package/dist/commands.d.ts

@@ -26,6 +26,45 @@ export interface ProcessInfo {
     envs: Record<string, string>;
     cwd?: string;
 }
+export interface ProcessStatus {
+    pid: number | string;
+    id?: number | string;
+    osPid?: number;
+    command?: string;
+    args: string[];
+    cwd?: string;
+    user?: string;
+    pty?: boolean;
+    status: string;
+    startedAt?: string;
+    finishedAt?: string;
+    exitCode?: number;
+}
+export interface ProcessOutputEvent {
+    cursor: number;
+    type: 'stdout' | 'stderr' | 'pty' | string;
+    data: Uint8Array;
+}
+export interface ProcessOutputSnapshot {
+    pid: number | string;
+    status: string;
+    exitCode?: number;
+    finishedAt?: string;
+    nextCursor: number;
+    truncatedBeforeCursor: boolean;
+    events: ProcessOutputEvent[];
+}
+export interface ReadProcessOutputOptions extends CommandRequestOpts {
+    since?: number;
+    limitBytes?: number;
+}
+export interface StopProcessOptions {
+    signal?: string;
+    killGroup?: boolean;
+    graceMs?: number;
+    requestTimeoutMs?: number;
+    abortSignal?: AbortSignal;
+}
 export interface CommandStartOpts {
     /** Return a `CommandHandle` immediately instead of waiting for exit. */
     background?: boolean;
@@ -125,6 +164,14 @@ export declare class Commands {
     run(cmd: string, opts?: CommandStartOpts): Promise<CommandResult>;
     /** Reconnect to a live process stream by pid. */
     connect(pid: number | string, opts?: CommandStartOpts): Promise<CommandHandle>;
+    /** Reconnect to a live process stream by pid starting at a cursor. */
+    connectSince(pid: number | string, cursor?: number, opts?: CommandStartOpts): Promise<CommandHandle>;
+    /** Look up process status without attaching a WebSocket. */
+    process(pid: number | string, opts?: CommandRequestOpts): Promise<ProcessStatus>;
+    /** Read available process output since a cursor without blocking. */
+    readProcessOutput(pid: number | string, opts?: ReadProcessOutputOptions): Promise<ProcessOutputSnapshot>;
+    /** Stop a process, optionally signalling the full process group. */
+    stopProcess(pid: number | string, opts?: StopProcessOptions): Promise<ProcessStatus>;
     /** Start a command and return a live handle immediately. */
     start(cmd: string, opts?: CommandStartOpts): Promise<CommandHandle>;
 }

package/dist/commands.js

@@ -1,3 +1,4 @@
+import { withQuery } from './transport.js';
 import { ProcessSocket, base64DecodeBytes, base64DecodeText } from './processSocket.js';
 import { SandboxError, TimeoutError } from './errors.js';
 /** Error thrown by `CommandHandle.wait()` when a process exits non-zero. */
@@ -136,9 +137,10 @@ export class Commands {
     }
     /** Send SIGKILL to a process by pid. */
     async kill(pid, opts = {}) {
-        await this.dataPlane.postJson(`/runtime/v1/process/${pid}/signal`, {
-            ...opts,
-            json: { signal: 'SIGKILL' },
+        await this.stopProcess(pid, {
+            signal: 'SIGKILL',
+            requestTimeoutMs: opts.requestTimeoutMs,
+            abortSignal: opts.signal,
         });
         return true;
     }
@@ -171,11 +173,41 @@ export class Commands {
     }
     /** 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, this.config.headers).connect();
+        return this.connectSince(pid, 0, opts);
+    }
+    /** Reconnect to a live process stream by pid starting at a cursor. */
+    async connectSince(pid, cursor = 0, opts = {}) {
+        const encodedPid = encodeURIComponent(String(pid));
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery(`/runtime/v1/process/${encodedPid}/connect`, { since: cursor }), 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);
     }
+    /** Look up process status without attaching a WebSocket. */
+    async process(pid, opts = {}) {
+        const payload = await this.dataPlane.getJson(`/runtime/v1/process/${encodeURIComponent(String(pid))}`, opts);
+        return processStatus(payload);
+    }
+    /** Read available process output since a cursor without blocking. */
+    async readProcessOutput(pid, opts = {}) {
+        const payload = await this.dataPlane.getJson(withQuery(`/runtime/v1/process/${encodeURIComponent(String(pid))}/output`, {
+            since: opts.since,
+            limit_bytes: opts.limitBytes,
+        }), opts);
+        return processOutputSnapshot(payload);
+    }
+    /** Stop a process, optionally signalling the full process group. */
+    async stopProcess(pid, opts = {}) {
+        const payload = await this.dataPlane.deleteJson(withQuery(`/runtime/v1/process/${encodeURIComponent(String(pid))}`, {
+            signal: opts.signal,
+            kill_group: opts.killGroup ?? true,
+            grace_ms: opts.graceMs,
+        }), {
+            requestTimeoutMs: opts.requestTimeoutMs,
+            signal: opts.abortSignal,
+        });
+        return processStatus(payload);
+    }
     /** 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, this.config.headers).connect();
@@ -243,8 +275,61 @@ function processInfo(value) {
         cwd: typeof process.cwd === 'string' ? process.cwd : undefined,
     };
 }
+function processStatus(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    const process = item.process && typeof item.process === 'object' ? item.process : item;
+    const pid = scalar(process.pid ?? process.id) ?? '';
+    return {
+        pid,
+        id: scalar(process.id),
+        osPid: numberValue(process.os_pid ?? process.osPid),
+        command: stringValue(process.command ?? process.cmd),
+        args: arrayOfStrings(process.args ?? process.arguments),
+        cwd: stringValue(process.cwd ?? process.working_directory),
+        user: stringValue(process.user),
+        pty: typeof process.pty === 'boolean' ? process.pty : undefined,
+        status: stringValue(process.status) ?? '',
+        startedAt: stringValue(process.started_at ?? process.startedAt),
+        finishedAt: stringValue(process.finished_at ?? process.finishedAt),
+        exitCode: numberValue(process.exit_code ?? process.exitCode),
+    };
+}
+function processOutputSnapshot(value) {
+    const payload = value && typeof value === 'object' ? value : {};
+    return {
+        pid: scalar(payload.pid ?? payload.id) ?? '',
+        status: stringValue(payload.status) ?? '',
+        exitCode: numberValue(payload.exit_code ?? payload.exitCode),
+        finishedAt: stringValue(payload.finished_at ?? payload.finishedAt),
+        nextCursor: numberValue(payload.next_cursor ?? payload.nextCursor) ?? 0,
+        truncatedBeforeCursor: payload.truncated_before_cursor === true || payload.truncatedBeforeCursor === true,
+        events: Array.isArray(payload.events) ? payload.events.map(processOutputEvent) : [],
+    };
+}
+function processOutputEvent(value) {
+    const event = value && typeof value === 'object' ? value : {};
+    return {
+        cursor: numberValue(event.cursor) ?? 0,
+        type: stringValue(event.type) ?? '',
+        data: base64DecodeBytes(stringValue(event.data) ?? ''),
+    };
+}
 function recordOfStrings(value) {
     if (!value || typeof value !== 'object')
         return {};
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, String(item)]));
 }
+function scalar(value) {
+    return typeof value === 'number' || typeof value === 'string' ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function numberValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    return undefined;
+}
+function arrayOfStrings(value) {
+    return Array.isArray(value) ? value.map(String) : [];
+}

package/dist/filesystem.d.ts

@@ -68,6 +68,41 @@ export interface FilesystemWriteOpts extends FilesystemRequestOpts {
     useOctetStream?: boolean;
     metadata?: Record<string, string>;
 }
+export interface ApplyDiffOpts extends FilesystemRequestOpts {
+    cwd?: string;
+}
+export interface ApplyDiffFailedHunk {
+    index: number;
+    oldStart: number;
+}
+export interface ApplyDiffFailure {
+    path: string;
+    error: string;
+    failedHunk?: ApplyDiffFailedHunk;
+}
+export interface ApplyDiffFileSummary {
+    path: string;
+    sourcePath?: string;
+    kind: string;
+    added: number;
+    removed: number;
+}
+export interface ApplyDiffSummary {
+    requested: number;
+    applied: number;
+    failed: number;
+}
+export interface ApplyDiffReport {
+    status: 'applied' | 'partial' | 'failed' | string;
+    parsedDiffBlocks: number;
+    patches: number;
+    files: ApplyDiffFileSummary[];
+    summary: ApplyDiffSummary;
+    applied: string[];
+    failed: ApplyDiffFailure[];
+    touched: string[];
+    raw: Record<string, unknown>;
+}
 /** Live filesystem watcher. Call `stop()` to close the local watch stream. */
 export declare class WatchHandle {
     private readonly socket;
@@ -130,6 +165,8 @@ export declare class Filesystem {
     remove(path: string, opts?: FilesystemRequestOpts): Promise<void>;
     /** Move or rename a file. */
     rename(oldPath: string, newPath: string, opts?: FilesystemRequestOpts): Promise<EntryInfo>;
+    /** Apply a git-style unified diff or Codex apply_patch payload inside the sandbox. */
+    applyDiff(diff: string, opts?: ApplyDiffOpts): Promise<ApplyDiffReport>;
     /** Create a directory. */
     makeDir(path: string, opts?: FilesystemRequestOpts): Promise<boolean>;
     /** Start watching a directory for filesystem events. */

package/dist/filesystem.js

@@ -183,6 +183,17 @@ export class Filesystem {
         });
         return entryInfo(payload.file ?? payload);
     }
+    /** Apply a git-style unified diff or Codex apply_patch payload inside the sandbox. */
+    async applyDiff(diff, opts = {}) {
+        const payload = await this.dataPlane.postJson('/runtime/v1/files/apply_diff', {
+            ...requestOpts(opts),
+            json: {
+                diff,
+                ...(opts.cwd ? { cwd: opts.cwd } : {}),
+            },
+        });
+        return applyDiffReport(payload);
+    }
     /** Create a directory. */
     async makeDir(path, opts = {}) {
         await this.dataPlane.postJson(withQuery('/runtime/v1/directories', { path }), opts);
@@ -312,6 +323,60 @@ function filesystemEvent(value) {
         raw: item,
     };
 }
+function applyDiffReport(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    return {
+        status: String(item.status ?? ''),
+        parsedDiffBlocks: requiredNumber(item.parsed_diff_blocks),
+        patches: requiredNumber(item.patches),
+        files: Array.isArray(item.files) ? item.files.map(applyDiffFileSummary) : [],
+        summary: applyDiffSummary(item.summary),
+        applied: stringArray(item.applied),
+        failed: Array.isArray(item.failed) ? item.failed.map(applyDiffFailure) : [],
+        touched: stringArray(item.touched),
+        raw: item,
+    };
+}
+function applyDiffSummary(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    return {
+        requested: requiredNumber(item.requested),
+        applied: requiredNumber(item.applied),
+        failed: requiredNumber(item.failed),
+    };
+}
+function applyDiffFileSummary(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    return {
+        path: String(item.path ?? ''),
+        sourcePath: typeof item.source_path === 'string' ? item.source_path : undefined,
+        kind: String(item.kind ?? ''),
+        added: requiredNumber(item.added),
+        removed: requiredNumber(item.removed),
+    };
+}
+function applyDiffFailure(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    const failedHunk = item.failed_hunk && typeof item.failed_hunk === 'object'
+        ? item.failed_hunk
+        : undefined;
+    return {
+        path: String(item.path ?? ''),
+        error: String(item.error ?? ''),
+        failedHunk: failedHunk
+            ? {
+                index: requiredNumber(failedHunk.index),
+                oldStart: requiredNumber(failedHunk.old_start),
+            }
+            : undefined,
+    };
+}
+function requiredNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
 function normalizeEventType(value) {
     if (value === 'delete')
         return FilesystemEventType.REMOVE;

package/dist/index.d.ts

@@ -8,11 +8,11 @@ export type { CreateSnapshotOpts, RestoreSnapshotOpts, SandboxApiOpts, SandboxCr
 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 { CommandConnectOpts, CommandRequestOpts, CommandResult, CommandStartOpts, ProcessInfo, PtyOutput, Stderr, Stdout, } from './commands.js';
+export type { CommandConnectOpts, CommandRequestOpts, CommandResult, CommandStartOpts, ProcessInfo, ProcessOutputEvent, ProcessOutputSnapshot, ProcessStatus, PtyOutput, ReadProcessOutputOptions, Stderr, StopProcessOptions, 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 type { ApplyDiffFailure, ApplyDiffFailedHunk, ApplyDiffFileSummary, ApplyDiffOpts, ApplyDiffReport, ApplyDiffSummary, 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, 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';

package/dist/pty.js

@@ -1,5 +1,6 @@
 import { CommandHandle } from './commands.js';
 import { ProcessSocket } from './processSocket.js';
+import { withQuery } from './transport.js';
 import { SandboxError } from './errors.js';
 /** PTY helper backed by the sandbox process WebSocket runtime. */
 export class Pty {
@@ -35,7 +36,7 @@ export class Pty {
     }
     /** Connect to a running PTY by pid. */
     async connect(pid, opts = {}) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, `/runtime/v1/process/${pid}/connect?since=0`, opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
+        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery(`/runtime/v1/process/${encodeURIComponent(String(pid))}/connect`, { since: 0 }), opts.requestTimeoutMs ?? this.config.requestTimeoutMs, this.config.headers).connect();
         const first = await nextStarted(socket);
         const actualPid = framePid(first) ?? pid;
         return new CommandHandle(actualPid, socket, () => this.kill(actualPid), withFirst(first, socket), undefined, undefined, opts.onData);
@@ -66,8 +67,10 @@ export class Pty {
     }
     /** Kill a running PTY. */
     async kill(pid, opts = {}) {
-        await this.dataPlane.postJson(`/runtime/v1/process/${pid}/signal`, {
-            json: { signal: 'SIGKILL' },
+        await this.dataPlane.deleteJson(withQuery(`/runtime/v1/process/${encodeURIComponent(String(pid))}`, {
+            signal: 'SIGKILL',
+            kill_group: true,
+        }), {
             requestTimeoutMs: opts.requestTimeoutMs,
             signal: opts.signal,
         });

package/package.json

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