@watasu/sdk 0.1.51 → 0.1.66

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

@@ -1,4 +1,4 @@
-import { Sandbox as BaseSandbox, SandboxConnectOpts, SandboxCreateOpts } from './sandbox.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';
@@ -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

@@ -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/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;
@@ -62,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;
@@ -124,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

@@ -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);
@@ -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);
@@ -265,6 +276,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 +290,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;
@@ -290,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/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;
 }