@watasu/sdk 0.1.66 → 0.1.67

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/index.d.ts

@@ -8,7 +8,7 @@ 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';

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.66",
+  "version": "0.1.67",
   "type": "module",
   "license": "MIT OR Apache-2.0",
   "description": "TypeScript SDK for Watasu",