@watasu/sdk 0.1.50 → 0.1.53

package/dist/codeInterpreter.d.ts

@@ -1,5 +1,5 @@
-import { Sandbox as BaseSandbox, SandboxConnectOpts, SandboxCreateOpts } 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';
+import { Sandbox as BaseSandbox } from './sandbox.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, 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';
@@ -138,7 +138,6 @@ export declare class OutputMessage {
     readonly error: boolean;
     constructor(line: string, timestamp?: number, error?: boolean);
     toString(): string;
-    toJSON(): Record<string, unknown>;
 }
 /** Structured exception raised by user code inside the sandbox. */
 export declare class ExecutionError {
@@ -146,7 +145,6 @@ export declare class ExecutionError {
     readonly value: string;
     readonly traceback: string;
     constructor(name: string, value: string, traceback: string);
-    toJSON(): Record<string, unknown>;
 }
 /** Rich result produced by the last expression of a code execution. */
 export declare class Result {
@@ -170,8 +168,8 @@ export declare class Result {
     toJSON(): Record<string, unknown>;
 }
 export interface Logs {
-    stdout: OutputMessage[];
-    stderr: OutputMessage[];
+    stdout: string[];
+    stderr: string[];
 }
 /** Complete result of a sandbox code execution. */
 export declare class Execution {
@@ -189,37 +187,33 @@ export declare class Context {
     readonly language: string;
     readonly cwd: string;
     constructor(id: string, language?: string, cwd?: string);
-    toJSON(): Record<string, unknown>;
 }
 /** Sandbox specialized for running Python code. */
 export declare class Sandbox extends BaseSandbox {
-    static readonly defaultTemplate = "code-interpreter";
-    static create(opts?: SandboxCreateOpts): Promise<Sandbox>;
-    static create(template: string, opts?: SandboxCreateOpts): Promise<Sandbox>;
-    static connect(sandboxId: string, opts?: SandboxConnectOpts): Promise<Sandbox>;
+    protected static readonly defaultTemplate: string;
+    protected get jupyterUrl(): string;
     /** Run Python code in the sandbox and return structured execution output. */
     runCode(code: string, opts?: RunCodeOpts & {
+        /**
+         * Language to use for code execution.
+         *
+         * If not defined, the default Python context is used.
+         */
         language?: RunCodeLanguage;
     }): Promise<Execution>;
     runCode(code: string, opts?: RunCodeOpts & {
-        context?: Context | string;
+        /**
+         * Context to run the code in.
+         */
+        context?: Context;
     }): Promise<Execution>;
     /** Create a persistent code context. */
     createCodeContext(opts?: CreateCodeContextOpts): Promise<Context>;
     /** Remove a persistent code context. */
-    removeCodeContext(context: Context | string, opts?: {
-        requestTimeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
+    removeCodeContext(context: Context | string): Promise<void>;
     /** List persistent code contexts. */
-    listCodeContexts(opts?: {
-        requestTimeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<Context[]>;
+    listCodeContexts(): Promise<Context[]>;
     /** Restart a persistent code context. */
-    restartCodeContext(context: Context | string, opts?: {
-        requestTimeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
+    restartCodeContext(context: Context | string): Promise<void>;
 }
 export { Sandbox as default };

package/dist/codeInterpreter.js

@@ -1,6 +1,6 @@
 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 { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, 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';
@@ -50,13 +50,6 @@ export class OutputMessage {
     toString() {
         return this.line;
     }
-    toJSON() {
-        return {
-            line: this.line,
-            timestamp: this.timestamp,
-            error: this.error,
-        };
-    }
 }
 /** Structured exception raised by user code inside the sandbox. */
 export class ExecutionError {
@@ -68,13 +61,6 @@ export class ExecutionError {
         this.value = value;
         this.traceback = traceback;
     }
-    toJSON() {
-        return {
-            name: this.name,
-            value: this.value,
-            traceback: this.traceback,
-        };
-    }
 }
 /** Rich result produced by the last expression of a code execution. */
 export class Result {
@@ -107,7 +93,7 @@ export class Result {
         this.javascript = stringValue(payload.javascript);
         this.data = recordOrUndefined(payload.data);
         this.chart = chartFromApi(payload.chart);
-        this.extra = record(payload.extra);
+        this.extra = resultExtra(payload);
         this.isMainResult = Boolean(isMainResult ?? payload.is_main_result ?? payload.isMainResult);
     }
     formats() {
@@ -128,10 +114,7 @@ export class Result {
             latex: this.latex,
             json: this.json,
             javascript: this.javascript,
-            data: this.data,
-            chart: this.chart,
             extra: Object.keys(this.extra).length === 0 ? undefined : this.extra,
-            is_main_result: this.isMainResult,
         });
     }
 }
@@ -153,13 +136,9 @@ export class Execution {
     }
     toJSON() {
         return {
-            results: this.results.map((result) => result.toJSON()),
-            logs: {
-                stdout: this.logs.stdout.map((message) => message.toJSON()),
-                stderr: this.logs.stderr.map((message) => message.toJSON()),
-            },
-            error: this.error?.toJSON() ?? null,
-            execution_count: this.executionCount,
+            results: this.results,
+            logs: this.logs,
+            error: this.error,
         };
     }
 }
@@ -173,22 +152,12 @@ export class Context {
         this.language = language;
         this.cwd = cwd;
     }
-    toJSON() {
-        return compactRecord({
-            id: this.id,
-            language: this.language,
-            cwd: this.cwd,
-        });
-    }
 }
 /** Sandbox specialized for running Python code. */
 export class Sandbox extends BaseSandbox {
     static defaultTemplate = 'code-interpreter';
-    static async create(templateOrOpts, opts = {}) {
-        return await super.create(templateOrOpts, opts);
-    }
-    static async connect(sandboxId, opts = {}) {
-        return await super.connect(sandboxId, opts);
+    get jupyterUrl() {
+        return this.runtimeBaseUrl;
     }
     async runCode(code, opts = {}) {
         if (typeof code !== 'string')
@@ -200,7 +169,7 @@ export class Sandbox extends BaseSandbox {
             code,
             language: opts.language,
             context_id: contextId(opts.context),
-            env_vars: opts.envs,
+            envs: opts.envs,
             timeout_ms: opts.timeoutMs,
         });
         const response = await this.runtimePostJson('/runtime/v1/code/run', payload, {
@@ -222,14 +191,12 @@ export class Sandbox extends BaseSandbox {
         });
         return contextFromApi(response);
     }
-    /** Remove a persistent code context. */
     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,
@@ -238,7 +205,6 @@ export class Sandbox extends BaseSandbox {
         const contexts = Array.isArray(response) ? response : arrayOfUnknown(response.contexts);
         return contexts.map((item) => contextFromApi(record(item)));
     }
-    /** Restart a persistent code context. */
     async restartCodeContext(context, opts = {}) {
         await this.runtimePostJson(`/runtime/v1/code/contexts/${encodeURIComponent(requireContextId(context))}/restart`, {}, {
             requestTimeoutMs: opts.requestTimeoutMs,
@@ -251,16 +217,16 @@ function executionFromApi(payload) {
     const execution = record(payload.execution ?? payload);
     const logs = record(execution.logs);
     return new Execution(arrayOfRecords(execution.results).map((item) => new Result(item)), {
-        stdout: arrayOfUnknown(logs.stdout).map((item) => outputMessageFromApi(item, false)),
-        stderr: arrayOfUnknown(logs.stderr).map((item) => outputMessageFromApi(item, true)),
+        stdout: arrayOfUnknown(logs.stdout).map(outputLineFromApi),
+        stderr: arrayOfUnknown(logs.stderr).map(outputLineFromApi),
     }, executionErrorFromApi(execution.error), numberValue(execution.execution_count ?? execution.executionCount));
 }
-function outputMessageFromApi(value, error) {
+function outputLineFromApi(value) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
         const item = value;
-        return new OutputMessage(String(item.line ?? ''), numberValue(item.timestamp) ?? Date.now() / 1000, Boolean(item.error ?? error));
+        return String(item.line ?? item.text ?? '');
     }
-    return new OutputMessage(String(value), Date.now() / 1000, error);
+    return String(value);
 }
 function executionErrorFromApi(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -270,9 +236,9 @@ function executionErrorFromApi(value) {
 }
 async function emitCallbacks(execution, opts) {
     for (const message of execution.logs.stdout)
-        await opts.onStdout?.(message);
+        await opts.onStdout?.(new OutputMessage(message, Date.now() / 1000, false));
     for (const message of execution.logs.stderr)
-        await opts.onStderr?.(message);
+        await opts.onStderr?.(new OutputMessage(message, Date.now() / 1000, true));
     for (const result of execution.results)
         await opts.onResult?.(result);
     if (execution.error !== undefined)
@@ -297,6 +263,33 @@ function compactRecord(payload) {
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
+function resultExtra(payload) {
+    const extra = record(payload.extra);
+    for (const [key, value] of Object.entries(payload)) {
+        if (!knownResultKeys.has(key))
+            extra[key] = value;
+    }
+    return extra;
+}
+const knownResultKeys = new Set([
+    'plain',
+    'text',
+    'html',
+    'markdown',
+    'svg',
+    'png',
+    'jpeg',
+    'pdf',
+    'latex',
+    'json',
+    'javascript',
+    'data',
+    'chart',
+    'extra',
+    'type',
+    'is_main_result',
+    'isMainResult',
+]);
 function recordOrUndefined(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
 }

package/dist/connectionConfig.d.ts

@@ -1,6 +1,12 @@
 export declare const KEEPALIVE_PING_INTERVAL_SEC = 50;
 export declare const SESSION_OPERATION_REQUEST_TIMEOUT_MS = 150000;
 export type Username = string;
+export interface Logger {
+    debug?: (...args: unknown[]) => void;
+    info?: (...args: unknown[]) => void;
+    warn?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+}
 /** Connection options accepted by Watasu SDK entrypoints. */
 export interface ConnectionOpts {
     apiKey?: string;
@@ -14,12 +20,21 @@ export interface ConnectionOpts {
     headers?: Record<string, string>;
     apiHeaders?: Record<string, string>;
     debug?: boolean;
+    logger?: Logger;
     signal?: AbortSignal;
-    proxy?: unknown;
+    proxy?: string;
 }
 /** Resolved connection settings used by control-plane and data-plane clients. */
 export declare class ConnectionConfig {
+    static envdPort: number;
+    static get domain(): string;
+    static get apiUrl(): string;
+    static get sandboxUrl(): string | undefined;
+    static get debug(): boolean;
+    static get apiKey(): string | undefined;
+    static get accessToken(): string | undefined;
     readonly apiKey?: string;
+    readonly accessToken?: string;
     readonly domain: string;
     readonly apiUrl: string;
     /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
@@ -29,8 +44,9 @@ export declare class ConnectionConfig {
     readonly headers: Record<string, string>;
     readonly apiHeaders: Record<string, string>;
     readonly debug: boolean;
+    readonly logger?: Logger;
     readonly signal?: AbortSignal;
-    readonly proxy?: unknown;
+    readonly proxy?: string;
     constructor(opts?: ConnectionOpts);
     /** HTTP headers including the configured bearer token. */
     get authHeaders(): Record<string, string>;
@@ -38,14 +54,14 @@ export declare class ConnectionConfig {
     getSignal(requestTimeoutMs?: number, signal?: AbortSignal | undefined): AbortSignal | undefined;
     /** Return the sandbox data-plane API URL for a Watasu route token. */
     getSandboxUrl(sandboxId: string, opts: {
-        sandboxDomain?: string;
+        sandboxDomain: string;
         envdPort: number;
     }): string;
     /** Return the direct sandbox data-plane API URL for a Watasu route token. */
     getSandboxDirectUrl(sandboxId: string, opts: {
-        sandboxDomain?: string;
+        sandboxDomain: string;
         envdPort: number;
     }): string;
     /** Return the public hostname for a Watasu sandbox route token and port. */
-    getHost(sandboxId: string, port: number, sandboxDomain?: string): string;
+    getHost(sandboxId: string, port: number, sandboxDomain: string): string;
 }

package/dist/connectionConfig.js

@@ -2,7 +2,34 @@ export const KEEPALIVE_PING_INTERVAL_SEC = 50;
 export const SESSION_OPERATION_REQUEST_TIMEOUT_MS = 150_000;
 /** Resolved connection settings used by control-plane and data-plane clients. */
 export class ConnectionConfig {
+    static envdPort = 49983;
+    static get domain() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_DOMAIN ?? 'watasu.io';
+    }
+    static get apiUrl() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;
+    }
+    static get sandboxUrl() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_SANDBOX_URL;
+    }
+    static get debug() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        const value = (env.WATASU_DEBUG ?? 'false').toLowerCase();
+        return value === 'true' || value === '1';
+    }
+    static get apiKey() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_API_KEY ?? env.WATASU_ACCESS_TOKEN;
+    }
+    static get accessToken() {
+        const env = typeof process !== 'undefined' ? process.env : {};
+        return env.WATASU_ACCESS_TOKEN ?? this.apiKey;
+    }
     apiKey;
+    accessToken;
     domain;
     apiUrl;
     /** Absolute sandbox data-plane URL override, primarily for local runtimes. */
@@ -12,20 +39,20 @@ export class ConnectionConfig {
     headers;
     apiHeaders;
     debug;
+    logger;
     signal;
     proxy;
     constructor(opts = {}) {
         const env = typeof process !== 'undefined' ? process.env : {};
-        this.apiKey =
-            opts.apiKey ??
-                opts.accessToken ??
-                env.WATASU_API_KEY;
-        this.domain = opts.domain ?? env.WATASU_DOMAIN ?? 'watasu.io';
-        this.apiUrl =
-            opts.apiUrl ?? env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;
-        this.sandboxUrl =
-            opts.sandboxUrl ??
-                env.WATASU_SANDBOX_URL;
+        const token = opts.apiKey ??
+            opts.accessToken ??
+            ConnectionConfig.apiKey ??
+            ConnectionConfig.accessToken;
+        this.apiKey = token;
+        this.accessToken = opts.accessToken ?? token;
+        this.domain = opts.domain ?? ConnectionConfig.domain;
+        this.apiUrl = opts.apiUrl ?? env.WATASU_API_URL ?? `https://api.${this.domain}/v1`;
+        this.sandboxUrl = opts.sandboxUrl ?? ConnectionConfig.sandboxUrl;
         this.dataPlaneDomain =
             opts.dataPlaneDomain ??
                 env.WATASU_DATA_PLANE_DOMAIN ??
@@ -33,14 +60,16 @@ export class ConnectionConfig {
         this.requestTimeoutMs = opts.requestTimeoutMs ?? 60_000;
         this.headers = opts.headers ?? {};
         this.apiHeaders = opts.apiHeaders ?? {};
-        this.debug = opts.debug ?? false;
+        this.debug = opts.debug ?? ConnectionConfig.debug;
+        this.logger = opts.logger;
         this.signal = opts.signal;
         this.proxy = opts.proxy;
     }
     /** HTTP headers including the configured bearer token. */
     get authHeaders() {
-        return this.apiKey
-            ? { ...this.headers, ...this.apiHeaders, Authorization: `Bearer ${this.apiKey}` }
+        const token = this.accessToken ?? this.apiKey;
+        return token
+            ? { ...this.headers, ...this.apiHeaders, Authorization: `Bearer ${token}` }
             : { ...this.headers, ...this.apiHeaders };
     }
     /** Return an abort signal that follows the caller signal and optional timeout. */
@@ -61,7 +90,6 @@ export class ConnectionConfig {
         }
         return controller.signal;
     }
-    /** Return the sandbox data-plane API URL for a Watasu route token. */
     getSandboxUrl(sandboxId, opts) {
         if (this.sandboxUrl)
             return this.sandboxUrl;
@@ -69,11 +97,12 @@ export class ConnectionConfig {
             return `http://localhost:${opts.envdPort}`;
         return `https://${sandboxId}.sandbox.${opts.sandboxDomain ?? this.dataPlaneDomain}`;
     }
-    /** Return the direct sandbox data-plane API URL for a Watasu route token. */
     getSandboxDirectUrl(sandboxId, opts) {
-        return this.getSandboxUrl(sandboxId, opts);
+        return this.getSandboxUrl(sandboxId, {
+            sandboxDomain: opts.sandboxDomain ?? this.dataPlaneDomain,
+            envdPort: opts.envdPort,
+        });
     }
-    /** Return the public hostname for a Watasu sandbox route token and port. */
     getHost(sandboxId, port, sandboxDomain = this.dataPlaneDomain) {
         if (this.debug)
             return `localhost:${port}`;

package/dist/errors.d.ts

@@ -46,10 +46,6 @@ export declare class FileUploadError extends BuildError {
 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);
-}
 export declare class ApiError extends SandboxError {
     readonly status: number;
     readonly code?: string | undefined;

package/dist/errors.js

@@ -94,15 +94,6 @@ export class VolumeError extends Error {
         this.name = 'VolumeError';
     }
 }
-export function unsupported(feature) {
-    throw new NotImplementedError(`${feature} is not supported by Watasu yet`);
-}
-export class NotImplementedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NotImplementedError';
-    }
-}
 export class ApiError extends SandboxError {
     status;
     code;

package/dist/filesystem.d.ts

@@ -22,6 +22,11 @@ export interface EntryInfo {
     path: string;
     size?: number;
     mode?: number;
+    permissions?: string;
+    owner?: string;
+    group?: string;
+    modifiedTime?: Date;
+    symlinkTarget?: string;
     uid?: number;
     gid?: number;
     mtime?: number;
@@ -44,6 +49,7 @@ export interface WatchOpts {
     recursive?: boolean;
     includeEntry?: boolean;
     allowNetworkMounts?: boolean;
+    timeoutMs?: number;
     requestTimeoutMs?: number;
     signal?: AbortSignal;
     user?: string;

package/dist/filesystem.js

@@ -76,7 +76,7 @@ export class FilesystemWatcher {
             recursive: nextOpts.recursive ?? false,
             include_entry: nextOpts.includeEntry,
             allow_network_mounts: nextOpts.allowNetworkMounts,
-        }), nextOpts.requestTimeoutMs, this.dataPlane.headers).connect();
+        }), nextOpts.requestTimeoutMs ?? nextOpts.timeoutMs, this.dataPlane.headers).connect();
         this.handle = new WatchHandle(socket, socket, async (event) => {
             for (const listener of this.listeners)
                 await listener(event);
@@ -265,6 +265,11 @@ function entryInfo(value) {
         path: String(item.path ?? ''),
         size: numberValue(item.bytes ?? item.size),
         mode: numberValue(item.mode),
+        permissions: stringValue(item.permissions),
+        owner: stringValue(item.owner),
+        group: stringValue(item.group),
+        modifiedTime: dateValue(item.modified_time ?? item.modifiedTime ?? item.mtime ?? item.updated_at ?? item.updatedAt),
+        symlinkTarget: stringValue(item.symlink_target ?? item.symlinkTarget),
         uid: numberValue(item.uid),
         gid: numberValue(item.gid),
         mtime: numberValue(item.mtime),
@@ -274,6 +279,23 @@ function entryInfo(value) {
 function numberValue(value) {
     return typeof value === 'number' ? value : undefined;
 }
+function stringValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+function dateValue(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        if (!Number.isNaN(date.getTime()))
+            return date;
+    }
+    return undefined;
+}
 function recordOfStrings(value) {
     if (!value || typeof value !== 'object')
         return undefined;

package/dist/git.d.ts

@@ -169,5 +169,8 @@ export declare class Git {
     setConfig(key: string, value: string, opts?: GitConfigOpts): Promise<GitCommandResult>;
     /** Read a Git config value. */
     getConfig(key: string, opts?: GitConfigOpts): Promise<string>;
+    private getRemoteUrl;
+    private resolveRemoteName;
+    private hasUpstream;
     private run;
 }

package/dist/git.js

@@ -1,3 +1,4 @@
+import { InvalidArgumentError } from './errors.js';
 /** Git helper backed by sandbox data-plane routes. */
 export class Git {
     dataPlane;
@@ -162,6 +163,31 @@ export class Git {
         }, opts);
         return String(result.value ?? '');
     }
+    async getRemoteUrl(path, remote, opts = {}) {
+        const url = await this.remoteGet(path, remote, opts);
+        if (!url) {
+            throw new InvalidArgumentError(`Remote "${remote}" URL not found in repository.`);
+        }
+        return url;
+    }
+    async resolveRemoteName(path, remote, opts = {}) {
+        if (remote)
+            return remote;
+        const status = await this.status(path, opts);
+        const upstreamRemote = status.upstream?.split('/')[0];
+        if (upstreamRemote)
+            return upstreamRemote;
+        throw new InvalidArgumentError('Remote is required when the repository has no upstream remote.');
+    }
+    async hasUpstream(path, opts = {}) {
+        try {
+            const status = await this.status(path, opts);
+            return Boolean(status.upstream);
+        }
+        catch {
+            return false;
+        }
+    }
     async run(path, json, opts) {
         const payload = await this.dataPlane.postJson(path, {
             json: compact(json),
@@ -173,7 +199,7 @@ export class Git {
 }
 function gitOpts(opts) {
     return {
-        env_vars: opts.envs,
+        envs: opts.envs,
         user: opts.user,
         cwd: opts.cwd,
         timeout_seconds: opts.timeoutMs === undefined ? undefined : Math.ceil(opts.timeoutMs / 1000),

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, 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';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, NotImplementedError, RateLimitError, SandboxError, SandboxNotFoundError, TemplateError, TimeoutError, VolumeError, } from './errors.js';
+export { ApiError, AuthenticationError, BuildError, ConflictError, FileNotFoundError, FileUploadError, GitAuthError, GitUpstreamError, InvalidArgumentError, NotEnoughSpaceError, NotFoundError, 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, Sandbox, SandboxPaginator, SnapshotPaginator, getSignature, } from './sandbox.js';

package/dist/pty.d.ts

@@ -1,16 +1,21 @@
-import { CommandHandle, CommandStartOpts } from './commands.js';
-import { ConnectionConfig, type ConnectionOpts } from './connectionConfig.js';
+import { CommandHandle } from './commands.js';
+import { ConnectionConfig, type ConnectionOpts, type Username } from './connectionConfig.js';
 import { DataPlaneClient } from './transport.js';
 export interface PtySize {
     cols: number;
     rows: number;
 }
-export interface PtyCreateOpts extends Omit<CommandStartOpts, 'background' | 'onStdout' | 'onStderr'> {
+export interface PtyCreateOpts extends Pick<ConnectionOpts, 'requestTimeoutMs' | 'signal'> {
     cols?: number;
     rows?: number;
     size?: PtySize;
     cmd?: string;
+    cwd?: string;
+    user?: Username;
+    envs?: Record<string, string>;
+    timeoutMs?: number;
     onData?: (data: Uint8Array) => void | Promise<void>;
+    onPty?: (data: Uint8Array) => void | Promise<void>;
 }
 export interface PtyConnectOpts {
     onData?: (data: Uint8Array) => void | Promise<void>;