@watasu/sdk 0.1.6 → 0.1.25

package/dist/commands.js

@@ -1,5 +1,5 @@
 import { ProcessSocket, base64DecodeBytes, base64DecodeText } from './processSocket.js';
-import { SandboxError } from './errors.js';
+import { SandboxError, TimeoutError } from './errors.js';
 /** Error thrown by `CommandHandle.wait()` when a process exits non-zero. */
 export class CommandExitError extends SandboxError {
     result;
@@ -22,11 +22,12 @@ export class CommandHandle {
     onStdout;
     onStderr;
     onPty;
+    onExit;
     _stdout = '';
     _stderr = '';
     result;
     pending;
-    constructor(pid, socket, handleKill, events, onStdout, onStderr, onPty) {
+    constructor(pid, socket, handleKill, events, onStdout, onStderr, onPty, onExit) {
         this.pid = pid;
         this.socket = socket;
         this.handleKill = handleKill;
@@ -34,6 +35,7 @@ export class CommandHandle {
         this.onStdout = onStdout;
         this.onStderr = onStderr;
         this.onPty = onPty;
+        this.onExit = onExit;
         this.pending = this.handleEvents();
     }
     get stdout() { return this._stdout; }
@@ -41,8 +43,8 @@ export class CommandHandle {
     get exitCode() { return this.result?.exitCode; }
     get error() { return this.result?.error; }
     /** Wait until the process exits and return captured output. */
-    async wait() {
-        await this.pending;
+    async wait(timeoutMs) {
+        await waitFor(this.pending, timeoutMs);
         if (!this.result)
             throw new SandboxError('Command ended without an exit event');
         if (this.result.exitCode !== 0)
@@ -57,12 +59,16 @@ export class CommandHandle {
     async sendStdin(data) {
         this.socket.sendStdin(data);
     }
+    /** Close the stdin stream and signal EOF to the process. */
+    async closeStdin() {
+        this.socket.closeStdin();
+    }
     /** 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 });
     }
     /** Detach the local stream without killing the process. */
-    disconnect() {
+    async disconnect() {
         this.socket.close();
     }
     async handleEvents() {
@@ -88,12 +94,14 @@ export class CommandHandle {
                     await this.onPty?.(bytes);
                 }
                 else if (type === 'exit') {
+                    const exitCode = Number(frame.exit_code ?? frame.exitCode ?? 0);
                     this.result = {
-                        exitCode: Number(frame.exit_code ?? frame.exitCode ?? 0),
+                        exitCode,
                         error: typeof frame.error === 'string' ? frame.error : undefined,
                         stdout: this._stdout,
                         stderr: this._stderr,
                     };
+                    await this.onExit?.(exitCode);
                     return;
                 }
                 else if (type === 'error') {
@@ -116,6 +124,10 @@ export class Commands {
         this.config = config;
         this.sandboxEnvs = sandboxEnvs;
     }
+    /** Whether this runtime supports stdin EOF frames. */
+    get supportsStdinClose() {
+        return true;
+    }
     /** List processes currently known by the sandbox runtime. */
     async list(opts = {}) {
         const payload = await this.dataPlane.getJson('/runtime/v1/process', opts);
@@ -137,7 +149,17 @@ export class Commands {
             await handle.sendStdin(data);
         }
         finally {
-            handle.disconnect();
+            await handle.disconnect();
+        }
+    }
+    /** Attach to a process and close stdin, signalling EOF. */
+    async closeStdin(pid, opts = {}) {
+        const handle = await this.connect(pid, opts);
+        try {
+            await handle.closeStdin();
+        }
+        finally {
+            await handle.disconnect();
         }
     }
     /** Run a shell command over the WebSocket process runtime. */
@@ -145,7 +167,7 @@ export class Commands {
         const handle = await this.start(cmd, opts);
         if (opts.background)
             return handle;
-        return handle.wait();
+        return handle.wait(opts.timeoutMs ?? opts.timeout);
     }
     /** Reconnect to a live process stream by pid. */
     async connect(pid, opts = {}) {
@@ -154,27 +176,44 @@ export class Commands {
         const actualPid = framePid(first) ?? pid;
         return new CommandHandle(actualPid, socket, () => this.kill(actualPid), socket, opts.onStdout, opts.onStderr, opts.onPty);
     }
-    async start(cmd, opts) {
+    /** 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.envs ?? {}) };
+        const environment = { ...this.sandboxEnvs, ...(opts.envVars ?? opts.envs ?? {}) };
+        const processConfig = processStartConfig(cmd, opts);
         socket.sendJson({
             type: 'start',
-            cmd: '/bin/bash',
-            args: ['-l', '-c', cmd],
-            cwd: opts.cwd,
+            id: opts.processID,
+            cmd: processConfig.cmd,
+            args: processConfig.args,
+            cwd: opts.cwd ?? opts.rootDir,
             user: opts.user,
             environment,
             envs: environment,
             stdin: opts.stdin ?? false,
-            timeout_ms: opts.timeoutMs ?? 60_000,
+            timeout_ms: opts.timeoutMs ?? opts.timeout ?? 60_000,
         });
         const first = await nextStarted(socket);
         const pid = framePid(first);
         if (pid === undefined)
             throw new SandboxError('process started frame did not include pid');
-        return new CommandHandle(pid, socket, () => this.kill(pid), withFirst(first, socket), opts.onStdout, opts.onStderr, opts.onPty);
+        return new CommandHandle(pid, socket, () => this.kill(pid), withFirst(first, socket), opts.onStdout, opts.onStderr, opts.onPty, opts.onExit);
     }
 }
+function processStartConfig(cmd, opts) {
+    if (opts.args !== undefined || opts.cmd !== undefined) {
+        return { cmd: opts.cmd ?? cmd, args: opts.args ?? [] };
+    }
+    return { cmd: '/bin/bash', args: ['-l', '-c', cmd] };
+}
+function waitFor(promise, timeoutMs) {
+    if (timeoutMs === undefined || timeoutMs <= 0)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new TimeoutError()), timeoutMs);
+        promise.then(resolve, reject).finally(() => clearTimeout(timer));
+    });
+}
 async function nextStarted(events) {
     for await (const frame of events) {
         if (frame.type === 'started')

package/dist/errors.d.ts

@@ -7,6 +7,9 @@ export declare class AuthenticationError extends SandboxError {
 export declare class NotFoundError extends SandboxError {
     constructor(message?: string);
 }
+export declare class ConflictError extends SandboxError {
+    constructor(message?: string);
+}
 export declare class TimeoutError extends SandboxError {
     constructor(message?: string);
 }

package/dist/errors.js

@@ -16,6 +16,12 @@ export class NotFoundError extends SandboxError {
         this.name = 'NotFoundError';
     }
 }
+export class ConflictError extends SandboxError {
+    constructor(message = 'Conflict') {
+        super(message);
+        this.name = 'ConflictError';
+    }
+}
 export class TimeoutError extends SandboxError {
     constructor(message = 'Request timed out') {
         super(message);
@@ -76,6 +82,8 @@ export function errorFromResponse(status, payload) {
         return new AuthenticationError(message);
     if (status === 404)
         return new NotFoundError(message);
+    if (status === 409)
+        return new ConflictError(message);
     if (status === 408 || status === 504)
         return new TimeoutError(message);
     if (status === 422 || status === 400)

package/dist/filesystem.d.ts

@@ -21,6 +21,11 @@ export interface EntryInfo {
     metadata?: Record<string, string>;
 }
 export type WriteInfo = EntryInfo;
+export type WriteData = string | Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array>;
+export interface WriteEntry {
+    path: string;
+    data: WriteData;
+}
 export interface FilesystemEvent {
     type: 'create' | 'write' | 'modify' | 'remove' | 'delete' | 'rename' | string;
     path: string;
@@ -33,6 +38,17 @@ export interface WatchOpts {
     requestTimeoutMs?: number;
     onExit?: (error?: Error) => void | Promise<void>;
 }
+export interface FilesystemRequestOpts {
+    requestTimeoutMs?: number;
+    user?: string;
+}
+export interface FilesystemReadOpts extends FilesystemRequestOpts {
+    gzip?: boolean;
+}
+export interface FilesystemWriteOpts extends FilesystemRequestOpts {
+    gzip?: boolean;
+    metadata?: Record<string, string>;
+}
 /** Live filesystem watcher. Call `stop()` to close the local watch stream. */
 export declare class WatchHandle {
     private readonly socket;
@@ -46,22 +62,45 @@ export declare class WatchHandle {
     wait(): Promise<void>;
     private pump;
 }
+/** Lazy filesystem watcher. Add listeners, then call `start()`. */
+export declare class FilesystemWatcher {
+    private readonly dataPlane;
+    private readonly path;
+    private readonly opts;
+    private handle?;
+    private listeners;
+    constructor(dataPlane: DataPlaneClient, path: string, opts?: WatchOpts);
+    start(opts?: WatchOpts): Promise<void>;
+    stop(): Promise<void>;
+    addEventListener(listener: (event: FilesystemEvent) => void | Promise<void>): () => boolean;
+    wait(): Promise<void>;
+}
 /** Filesystem helper for a sandbox data-plane session. */
 export declare class Filesystem {
     private readonly dataPlane;
     constructor(dataPlane: DataPlaneClient);
-    /** Read a file as UTF-8 text, bytes, or a one-chunk async byte stream. */
-    read(path: string, opts?: {
-        format?: 'text' | 'bytes' | 'stream';
-        requestTimeoutMs?: number;
-        gzip?: boolean;
-    }): Promise<string | Uint8Array | AsyncIterable<Uint8Array>>;
-    /** Write UTF-8 text or bytes to a file. */
-    write(path: string, data: string | Uint8Array, opts?: {
-        requestTimeoutMs?: number;
-        gzip?: boolean;
-        metadata?: Record<string, string>;
-    }): Promise<WriteInfo>;
+    /** Read file content as text, bytes, a `Blob`, or a `ReadableStream`. */
+    read(path: string, opts?: FilesystemReadOpts & {
+        format?: 'text';
+    }): Promise<string>;
+    read(path: string, opts: FilesystemReadOpts & {
+        format: 'bytes';
+    }): Promise<Uint8Array>;
+    read(path: string, opts: FilesystemReadOpts & {
+        format: 'blob';
+    }): Promise<Blob>;
+    read(path: string, opts: FilesystemReadOpts & {
+        format: 'stream';
+    }): Promise<ReadableStream<Uint8Array>>;
+    /** Read a file as raw bytes. */
+    readBytes(path: string, opts?: FilesystemReadOpts): Promise<Uint8Array>;
+    /** Write UTF-8 text, bytes, browser data objects, or a batch of file entries. */
+    write(path: string, data: WriteData, opts?: FilesystemWriteOpts): Promise<WriteInfo>;
+    write(files: WriteEntry[], opts?: FilesystemWriteOpts): Promise<WriteInfo[]>;
+    /** Write raw bytes to a file. */
+    writeBytes(path: string, data: Uint8Array | ArrayBuffer, opts?: FilesystemWriteOpts): Promise<WriteInfo>;
+    /** 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;
@@ -88,5 +127,6 @@ export declare class Filesystem {
         requestTimeoutMs?: number;
     }): Promise<boolean>;
     /** Start watching a directory for filesystem events. */
-    watchDir(path: string, onEvent: (event: FilesystemEvent) => void | Promise<void>, opts?: WatchOpts): Promise<WatchHandle>;
+    watchDir(path: string): FilesystemWatcher;
+    watchDir(path: string, onEvent: (event: FilesystemEvent) => void | Promise<void>, opts?: WatchOpts): Promise<FilesystemWatcher>;
 }

package/dist/filesystem.js

@@ -1,6 +1,6 @@
 import { withQuery } from './transport.js';
-import { FileNotFoundError } from './errors.js';
-import { ProcessSocket } from './processSocket.js';
+import { FileNotFoundError, InvalidArgumentError } from './errors.js';
+import { ProcessSocket, base64Encode } from './processSocket.js';
 export var FileType;
 (function (FileType) {
     /** Regular file. */
@@ -50,27 +50,93 @@ export class WatchHandle {
         }
     }
 }
+/** Lazy filesystem watcher. Add listeners, then call `start()`. */
+export class FilesystemWatcher {
+    dataPlane;
+    path;
+    opts;
+    handle;
+    listeners = [];
+    constructor(dataPlane, path, opts = {}) {
+        this.dataPlane = dataPlane;
+        this.path = path;
+        this.opts = opts;
+    }
+    async start(opts = {}) {
+        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();
+        this.handle = new WatchHandle(socket, socket, async (event) => {
+            for (const listener of this.listeners)
+                await listener(event);
+        }, nextOpts.onExit);
+    }
+    async stop() {
+        this.handle?.stop();
+    }
+    addEventListener(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index === -1)
+                return false;
+            this.listeners.splice(index, 1);
+            return true;
+        };
+    }
+    wait() {
+        return this.handle?.wait() ?? Promise.resolve();
+    }
+}
 /** Filesystem helper for a sandbox data-plane session. */
 export class Filesystem {
     dataPlane;
     constructor(dataPlane) {
         this.dataPlane = dataPlane;
     }
-    /** Read a file as UTF-8 text, bytes, or a one-chunk async byte stream. */
     async read(path, opts = {}) {
         const bytes = await this.dataPlane.getBytes(withQuery('/runtime/v1/files', { path, gzip: opts.gzip }), opts);
         if (opts.format === 'bytes')
             return bytes;
+        if (opts.format === 'blob')
+            return new Blob([toArrayBuffer(bytes)]);
         if (opts.format === 'stream')
-            return (async function* () { yield bytes; })();
+            return new ReadableStream({ start(controller) { controller.enqueue(bytes); controller.close(); } });
         return new TextDecoder().decode(bytes);
     }
-    /** Write UTF-8 text or bytes to a file. */
-    async write(path, data, opts = {}) {
-        const body = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-        const payload = await this.dataPlane.putJson(withQuery('/runtime/v1/files', { path, gzip: opts.gzip }), body, opts);
+    /** Read a file as raw bytes. */
+    async readBytes(path, opts = {}) {
+        return this.read(path, { ...opts, format: 'bytes' });
+    }
+    async write(pathOrFiles, dataOrOpts, opts = {}) {
+        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);
         return entryInfo(payload.file ?? payload);
     }
+    /** Write raw bytes to a file. */
+    async writeBytes(path, data, opts = {}) {
+        return this.write(path, data, opts);
+    }
+    /** Write several files in one runtime API call. */
+    async writeFiles(files, opts = {}) {
+        if (files.length === 0)
+            return [];
+        const payload = await this.dataPlane.postJson('/runtime/v1/files/write_files', {
+            ...opts,
+            json: {
+                files: await Promise.all(files.map(async (file) => ({
+                    path: file.path,
+                    data_base64: base64Encode(await writeDataToBytes(file.data)),
+                }))),
+            },
+        });
+        const written = Array.isArray(payload.files) ? payload.files : [];
+        return written.map(entryInfo);
+    }
     /** List directory entries below `path`. */
     async list(path, opts = {}) {
         const payload = await this.dataPlane.getJson(withQuery('/runtime/v1/directories', { path, depth: opts.depth }), opts);
@@ -111,11 +177,61 @@ export class Filesystem {
         await this.dataPlane.postJson(withQuery('/runtime/v1/directories', { path }), opts);
         return true;
     }
-    /** Start watching a directory for filesystem events. */
-    async watchDir(path, onEvent, opts = {}) {
-        const socket = await new ProcessSocket(this.dataPlane.baseUrl, this.dataPlane.token, withQuery('/runtime/v1/files/watch', { path, recursive: opts.recursive ?? false, include_entry: opts.includeEntry }), opts.requestTimeoutMs).connect();
-        return new WatchHandle(socket, socket, onEvent, opts.onExit);
+    watchDir(path, onEvent, opts = {}) {
+        const watcher = new FilesystemWatcher(this.dataPlane, path, opts);
+        if (!onEvent)
+            return watcher;
+        watcher.addEventListener(onEvent);
+        return watcher.start().then(() => watcher);
+    }
+}
+async function writeDataToBytes(data) {
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    if (data instanceof Uint8Array)
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (typeof Blob !== 'undefined' && data instanceof Blob)
+        return new Uint8Array(await data.arrayBuffer());
+    if (isReadableStream(data))
+        return readStreamToBytes(data);
+    throw new InvalidArgumentError(`Unsupported file data type: ${Object.prototype.toString.call(data)}`);
+}
+function toArrayBuffer(bytes) {
+    const buffer = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(buffer).set(bytes);
+    return buffer;
+}
+function isReadableStream(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.getReader === 'function');
+}
+async function readStreamToBytes(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!(value instanceof Uint8Array)) {
+                throw new InvalidArgumentError('ReadableStream file data must yield Uint8Array chunks');
+            }
+            chunks.push(value);
+            total += value.byteLength;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
     }
+    return bytes;
 }
 function entryInfo(value) {
     const item = value && typeof value === 'object' ? value : {};

package/dist/git.d.ts

@@ -18,6 +18,8 @@ export interface GitAuthOpts {
     username?: string;
     password?: string;
     envs?: Record<string, string>;
+    user?: string;
+    cwd?: string;
     timeout?: number;
     timeoutMs?: number;
     requestTimeoutMs?: number;
@@ -32,6 +34,10 @@ export interface GitCloneOpts extends GitAuthOpts {
 }
 export interface GitRequestOpts extends GitAuthOpts {
 }
+export interface GitInitOpts extends GitRequestOpts {
+    bare?: boolean;
+    initialBranch?: string;
+}
 export interface GitPullOpts extends GitAuthOpts {
     branch?: string;
     remote?: string;
@@ -54,12 +60,25 @@ export interface GitBranchOpts extends GitRequestOpts {
 }
 export interface GitAddOpts extends GitRequestOpts {
     files?: string[];
+    all?: boolean;
 }
 export interface GitCommitOpts extends GitRequestOpts {
     authorName?: string;
     authorEmail?: string;
     allowEmpty?: boolean;
 }
+export type GitResetMode = 'soft' | 'mixed' | 'hard' | 'merge' | 'keep';
+export interface GitResetOpts extends GitRequestOpts {
+    mode?: GitResetMode;
+    target?: string;
+    paths?: string[];
+}
+export interface GitRestoreOpts extends GitRequestOpts {
+    paths: string[];
+    staged?: boolean;
+    worktree?: boolean;
+    source?: string;
+}
 export interface GitRemoteAddOpts extends GitRequestOpts {
     fetch?: boolean;
     overwrite?: boolean;
@@ -114,6 +133,8 @@ export declare class Git {
     }): Promise<GitCommandResult>;
     /** Configure Git author identity globally or for one repository. */
     configureUser(name: string, email: string, opts?: GitConfigureUserOpts): Promise<GitCommandResult>;
+    /** Initialize a Git repository. */
+    init(path: string, opts?: GitInitOpts): Promise<GitCommandResult>;
     /** Return parsed repository status for `path`. */
     status(path: string, opts?: GitRequestOpts): Promise<GitStatus>;
     /** Return branches and the current branch for `path`. */
@@ -126,6 +147,10 @@ export declare class Git {
     add(path: string, opts?: GitAddOpts): Promise<GitCommandResult>;
     /** Commit staged files. */
     commit(path: string, message: string, opts?: GitCommitOpts): Promise<GitCommandResult>;
+    /** Reset the current HEAD to a specified state. */
+    reset(path: string, opts?: GitResetOpts): Promise<GitCommandResult>;
+    /** Restore working tree files or unstage changes. */
+    restore(path: string, opts: GitRestoreOpts): Promise<GitCommandResult>;
     /** Pull the current branch with a fast-forward-only merge. */
     pull(path: string, opts?: GitPullOpts): Promise<GitCommandResult>;
     /** Push the current branch or a selected branch. */
@@ -136,6 +161,8 @@ export declare class Git {
     checkoutBranch(path: string, branch: string, opts?: GitRequestOpts): Promise<GitCommandResult>;
     /** Add a remote. */
     remoteAdd(path: string, name: string, url: string, opts?: GitRemoteAddOpts): Promise<GitCommandResult>;
+    /** Return a remote URL, or undefined when the remote does not exist. */
+    remoteGet(path: string, name: string, opts?: GitRequestOpts): Promise<string | undefined>;
     /** Set a Git config value. */
     setConfig(key: string, value: string, opts?: GitConfigOpts): Promise<GitCommandResult>;
     /** Read a Git config value. */

package/dist/git.js

@@ -33,6 +33,15 @@ export class Git {
             path: opts.path,
         }, opts);
     }
+    /** Initialize a Git repository. */
+    async init(path, opts = {}) {
+        return this.run('/runtime/v1/git/init', {
+            path,
+            bare: opts.bare,
+            initial_branch: opts.initialBranch,
+            ...gitOpts(opts),
+        }, opts);
+    }
     /** Return parsed repository status for `path`. */
     async status(path, opts = {}) {
         const result = await this.run('/runtime/v1/git/status', { path, ...gitOpts(opts) }, opts);
@@ -58,7 +67,7 @@ export class Git {
     }
     /** Stage files. Defaults to all files. */
     async add(path, opts = {}) {
-        return this.run('/runtime/v1/git/add', { path, files: opts.files, ...gitOpts(opts) }, opts);
+        return this.run('/runtime/v1/git/add', { path, files: opts.files, all: opts.all, ...gitOpts(opts) }, opts);
     }
     /** Commit staged files. */
     async commit(path, message, opts = {}) {
@@ -71,6 +80,27 @@ export class Git {
             ...gitOpts(opts),
         }, opts);
     }
+    /** Reset the current HEAD to a specified state. */
+    async reset(path, opts = {}) {
+        return this.run('/runtime/v1/git/reset', {
+            path,
+            mode: opts.mode,
+            target: opts.target,
+            paths: opts.paths,
+            ...gitOpts(opts),
+        }, opts);
+    }
+    /** Restore working tree files or unstage changes. */
+    async restore(path, opts) {
+        return this.run('/runtime/v1/git/restore', {
+            path,
+            paths: opts.paths,
+            staged: opts.staged,
+            worktree: opts.worktree,
+            source: opts.source,
+            ...gitOpts(opts),
+        }, opts);
+    }
     /** Pull the current branch with a fast-forward-only merge. */
     async pull(path, opts = {}) {
         return this.run('/runtime/v1/git/pull', { path, ...gitOpts(opts), ...pick(opts, ['remote', 'branch', 'username', 'password']) }, opts);
@@ -81,7 +111,7 @@ export class Git {
             path,
             ...gitOpts(opts),
             ...pick(opts, ['remote', 'branch', 'username', 'password']),
-            set_upstream: opts.setUpstream,
+            set_upstream: opts.setUpstream ?? true,
         }, opts);
     }
     /** Check out an arbitrary ref in a repository. */
@@ -103,6 +133,15 @@ export class Git {
             ...gitOpts(opts),
         }, opts);
     }
+    /** Return a remote URL, or undefined when the remote does not exist. */
+    async remoteGet(path, name, opts = {}) {
+        const result = await this.run('/runtime/v1/git/remote_get', {
+            path,
+            name,
+            ...gitOpts(opts),
+        }, opts);
+        return result.value ?? result.url;
+    }
     /** Set a Git config value. */
     async setConfig(key, value, opts = {}) {
         return this.run('/runtime/v1/git/set_config', {
@@ -131,6 +170,8 @@ export class Git {
 function gitOpts(opts) {
     return {
         env_vars: opts.envs,
+        user: opts.user,
+        cwd: opts.cwd,
         timeout_seconds: opts.timeout ?? (opts.timeoutMs === undefined ? undefined : Math.ceil(opts.timeoutMs / 1000)),
     };
 }

package/dist/index.d.ts

@@ -1,13 +1,22 @@
-export { ApiError, AuthenticationError, FileNotFoundError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, TimeoutError, } from './errors.js';
+export { ApiError, AuthenticationError, ConflictError, FileNotFoundError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, TimeoutError, } from './errors.js';
 export { ConnectionConfig, KEEPALIVE_PING_INTERVAL_SEC } from './connectionConfig.js';
-export { Sandbox, SnapshotPaginator } from './sandbox.js';
-export type { CreateSnapshotOpts, RestoreSnapshotOpts, SandboxCreateOpts, SandboxConnectOpts, SandboxInfo, SandboxMetrics, SandboxUrlOpts, SnapshotInfo, FileUrlInfo, } from './sandbox.js';
+export { Sandbox, SandboxPaginator, SnapshotPaginator } from './sandbox.js';
+export { Sandbox as CodeInterpreterSandbox } from './codeInterpreter.js';
+export type { CreateSnapshotOpts, RestoreSnapshotOpts, SandboxCreateOpts, SandboxConnectOpts, SandboxInfo, SandboxListOpts, SandboxMetrics, McpServer, McpServerName, SandboxNetworkSelector, SandboxNetworkUpdate, SandboxNetworkUpdateOpts, SandboxUrlOpts, SnapshotInfo, 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 { FileType, Filesystem, WatchHandle } from './filesystem.js';
-export type { EntryInfo, FilesystemEvent, WatchOpts, WriteInfo } from './filesystem.js';
+export { Process, ProcessManager, ProcessMessage, ProcessOutput } from './process.js';
+export type { ProcessOpts } from './process.js';
+export { FileType, Filesystem, 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, GitPullOpts, GitPushOpts, GitRemoteAddOpts, GitRequestOpts, GitStatus, } 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 { 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 { 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';