@watasu/sdk 0.1.5 → 0.1.24

package/dist/filesystem.js

@@ -1,5 +1,6 @@
 import { withQuery } from './transport.js';
-import { FileNotFoundError, unsupported } from './errors.js';
+import { FileNotFoundError, InvalidArgumentError } from './errors.js';
+import { ProcessSocket, base64Encode } from './processSocket.js';
 export var FileType;
 (function (FileType) {
     /** Regular file. */
@@ -9,27 +10,133 @@ export var FileType;
     /** Symbolic link. */
     FileType["SYMLINK"] = "symlink";
 })(FileType || (FileType = {}));
+/** Live filesystem watcher. Call `stop()` to close the local watch stream. */
+export class WatchHandle {
+    socket;
+    done;
+    constructor(socket, events, onEvent, onExit) {
+        this.socket = socket;
+        this.done = this.pump(events, onEvent, onExit);
+    }
+    /** Stop watching the directory. */
+    stop() {
+        this.socket.close();
+    }
+    /** Alias for `stop`. */
+    close() {
+        this.stop();
+    }
+    /** Resolves when the watcher stream exits. */
+    wait() {
+        return this.done;
+    }
+    async pump(events, onEvent, onExit) {
+        let error;
+        try {
+            for await (const frame of events) {
+                if (frame.type !== 'events' || !Array.isArray(frame.events))
+                    continue;
+                for (const item of frame.events) {
+                    await onEvent(filesystemEvent(item));
+                }
+            }
+        }
+        catch (caught) {
+            error = caught instanceof Error ? caught : new Error(String(caught));
+            throw error;
+        }
+        finally {
+            await onExit?.(error);
+        }
+    }
+}
+/** 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);
@@ -70,9 +177,61 @@ export class Filesystem {
         await this.dataPlane.postJson(withQuery('/runtime/v1/directories', { path }), opts);
         return true;
     }
-    watchDir() {
-        unsupported('sandbox.files.watchDir');
+    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 : {};
@@ -96,3 +255,19 @@ function recordOfStrings(value) {
         return undefined;
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, String(item)]));
 }
+function filesystemEvent(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    return {
+        type: normalizeEventType(String(item.type ?? 'modify')),
+        path: String(item.path ?? ''),
+        entry: item.file && typeof item.file === 'object' ? entryInfo(item.file) : undefined,
+        raw: item,
+    };
+}
+function normalizeEventType(value) {
+    if (value === 'delete')
+        return 'remove';
+    if (value === 'modify')
+        return 'write';
+    return value;
+}

package/dist/git.d.ts

@@ -0,0 +1,171 @@
+import { DataPlaneClient } from './transport.js';
+export interface GitCommandResult {
+    path?: string;
+    url?: string;
+    ref?: string;
+    branch?: string;
+    remote?: string;
+    name?: string;
+    value?: string;
+    branches?: string[];
+    currentBranch?: string;
+    stdout: string;
+    stderr: string;
+    command?: Record<string, unknown>;
+    raw: Record<string, unknown>;
+}
+export interface GitAuthOpts {
+    username?: string;
+    password?: string;
+    envs?: Record<string, string>;
+    user?: string;
+    cwd?: string;
+    timeout?: number;
+    timeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+export interface GitCloneOpts extends GitAuthOpts {
+    path?: string;
+    branch?: string;
+    depth?: number;
+    recursive?: boolean;
+    submodules?: boolean;
+    dangerouslyStoreCredentials?: boolean;
+}
+export interface GitRequestOpts extends GitAuthOpts {
+}
+export interface GitInitOpts extends GitRequestOpts {
+    bare?: boolean;
+    initialBranch?: string;
+}
+export interface GitPullOpts extends GitAuthOpts {
+    branch?: string;
+    remote?: string;
+}
+export interface GitPushOpts extends GitAuthOpts {
+    branch?: string;
+    remote?: string;
+    setUpstream?: boolean;
+}
+export interface GitCredentialOpts extends GitRequestOpts {
+    host?: string;
+    protocol?: string;
+}
+export interface GitConfigureUserOpts extends GitRequestOpts {
+    scope?: 'global' | 'local';
+    path?: string;
+}
+export interface GitBranchOpts extends GitRequestOpts {
+    force?: boolean;
+}
+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;
+}
+export interface GitConfigOpts extends GitRequestOpts {
+    scope?: 'global' | 'local';
+    path?: string;
+}
+export interface GitBranches {
+    path?: string;
+    branches: string[];
+    currentBranch?: string;
+    result: GitCommandResult;
+}
+export interface GitFileStatus {
+    name: string;
+    status: string;
+    indexStatus: string;
+    workingTreeStatus: string;
+    staged: boolean;
+    renamedFrom?: string;
+}
+export interface GitStatus {
+    currentBranch?: string;
+    upstream?: string;
+    ahead: number;
+    behind: number;
+    detached: boolean;
+    fileStatus: GitFileStatus[];
+    isClean: boolean;
+    hasChanges: boolean;
+    hasStaged: boolean;
+    hasUntracked: boolean;
+    hasConflicts: boolean;
+    totalCount: number;
+    stagedCount: number;
+    unstagedCount: number;
+    untrackedCount: number;
+    conflictCount: number;
+    result: GitCommandResult;
+}
+/** Git helper backed by sandbox data-plane routes. */
+export declare class Git {
+    private readonly dataPlane;
+    constructor(dataPlane: DataPlaneClient);
+    /** Clone a repository into the sandbox. */
+    clone(url: string, opts?: GitCloneOpts): Promise<GitCommandResult>;
+    /** Store Git credentials in the sandbox credential helper. */
+    dangerouslyAuthenticate(opts: GitCredentialOpts & {
+        username: string;
+        password: string;
+    }): 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`. */
+    branches(path: string, opts?: GitRequestOpts): Promise<GitBranches>;
+    /** Create and check out a new branch. */
+    createBranch(path: string, branch: string, opts?: GitRequestOpts): Promise<GitCommandResult>;
+    /** Delete a branch. */
+    deleteBranch(path: string, branch: string, opts?: GitBranchOpts): Promise<GitCommandResult>;
+    /** Stage files. Defaults to all files. */
+    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. */
+    push(path: string, opts?: GitPushOpts): Promise<GitCommandResult>;
+    /** Check out an arbitrary ref in a repository. */
+    checkout(path: string, ref: string, opts?: GitRequestOpts): Promise<GitCommandResult>;
+    /** Check out an existing branch in a repository. */
+    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. */
+    getConfig(key: string, opts?: GitConfigOpts): Promise<string>;
+    private run;
+}

package/dist/git.js

@@ -0,0 +1,277 @@
+/** Git helper backed by sandbox data-plane routes. */
+export class Git {
+    dataPlane;
+    constructor(dataPlane) {
+        this.dataPlane = dataPlane;
+    }
+    /** Clone a repository into the sandbox. */
+    async clone(url, opts = {}) {
+        return this.run('/runtime/v1/git/clone', {
+            url,
+            ...gitOpts(opts),
+            ...pick(opts, ['path', 'branch', 'depth', 'recursive', 'submodules', 'username', 'password']),
+            dangerously_store_credentials: opts.dangerouslyStoreCredentials,
+        }, opts);
+    }
+    /** Store Git credentials in the sandbox credential helper. */
+    async dangerouslyAuthenticate(opts) {
+        return this.run('/runtime/v1/git/dangerously_authenticate', {
+            ...gitOpts(opts),
+            username: opts.username,
+            password: opts.password,
+            host: opts.host,
+            protocol: opts.protocol,
+        }, opts);
+    }
+    /** Configure Git author identity globally or for one repository. */
+    async configureUser(name, email, opts = {}) {
+        return this.run('/runtime/v1/git/configure_user', {
+            ...gitOpts(opts),
+            name,
+            email,
+            scope: opts.scope,
+            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);
+        return parseGitStatus(result);
+    }
+    /** Return branches and the current branch for `path`. */
+    async branches(path, opts = {}) {
+        const result = await this.run('/runtime/v1/git/branches', { path, ...gitOpts(opts) }, opts);
+        return {
+            path: result.path,
+            branches: Array.isArray(result.raw.branches) ? result.raw.branches.map(String) : result.branches ?? [],
+            currentBranch: stringValue(result.raw.current_branch) ?? result.currentBranch,
+            result,
+        };
+    }
+    /** Create and check out a new branch. */
+    async createBranch(path, branch, opts = {}) {
+        return this.run('/runtime/v1/git/create_branch', { path, branch, ...gitOpts(opts) }, opts);
+    }
+    /** Delete a branch. */
+    async deleteBranch(path, branch, opts = {}) {
+        return this.run('/runtime/v1/git/delete_branch', { path, branch, force: opts.force, ...gitOpts(opts) }, opts);
+    }
+    /** Stage files. Defaults to all files. */
+    async add(path, 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 = {}) {
+        return this.run('/runtime/v1/git/commit', {
+            path,
+            message,
+            author_name: opts.authorName,
+            author_email: opts.authorEmail,
+            allow_empty: opts.allowEmpty,
+            ...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);
+    }
+    /** Push the current branch or a selected branch. */
+    async push(path, opts = {}) {
+        return this.run('/runtime/v1/git/push', {
+            path,
+            ...gitOpts(opts),
+            ...pick(opts, ['remote', 'branch', 'username', 'password']),
+            set_upstream: opts.setUpstream ?? true,
+        }, opts);
+    }
+    /** Check out an arbitrary ref in a repository. */
+    async checkout(path, ref, opts = {}) {
+        return this.run('/runtime/v1/git/checkout', { path, ref, ...gitOpts(opts) }, opts);
+    }
+    /** Check out an existing branch in a repository. */
+    async checkoutBranch(path, branch, opts = {}) {
+        return this.checkout(path, branch, opts);
+    }
+    /** Add a remote. */
+    async remoteAdd(path, name, url, opts = {}) {
+        return this.run('/runtime/v1/git/remote_add', {
+            path,
+            name,
+            url,
+            fetch: opts.fetch,
+            overwrite: opts.overwrite,
+            ...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', {
+            key,
+            value,
+            scope: opts.scope,
+            path: opts.path,
+            ...gitOpts(opts),
+        }, opts);
+    }
+    /** Read a Git config value. */
+    async getConfig(key, opts = {}) {
+        const result = await this.run('/runtime/v1/git/get_config', {
+            key,
+            scope: opts.scope,
+            path: opts.path,
+            ...gitOpts(opts),
+        }, opts);
+        return String(result.value ?? '');
+    }
+    async run(path, json, opts) {
+        const payload = await this.dataPlane.postJson(path, { json: compact(json), requestTimeoutMs: opts.requestTimeoutMs });
+        return gitResult(payload.git ?? payload);
+    }
+}
+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)),
+    };
+}
+function pick(source, keys) {
+    const record = source;
+    return Object.fromEntries(keys.map((key) => [key, record[key]]));
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function gitResult(value) {
+    const item = value && typeof value === 'object' ? value : {};
+    return {
+        path: stringValue(item.path),
+        url: stringValue(item.url),
+        ref: stringValue(item.ref),
+        branch: stringValue(item.branch),
+        remote: stringValue(item.remote),
+        name: stringValue(item.name),
+        value: stringValue(item.value),
+        branches: Array.isArray(item.branches) ? item.branches.map(String) : undefined,
+        currentBranch: stringValue(item.current_branch),
+        stdout: String(item.stdout ?? ''),
+        stderr: String(item.stderr ?? ''),
+        command: item.command && typeof item.command === 'object' ? item.command : undefined,
+        raw: item,
+    };
+}
+function parseGitStatus(result) {
+    const fileStatus = [];
+    let currentBranch;
+    let upstream;
+    let ahead = 0;
+    let behind = 0;
+    let detached = false;
+    for (const line of result.stdout.split(/\r?\n/).filter(Boolean)) {
+        if (line.startsWith('## ')) {
+            const branchLine = line.slice(3);
+            detached = branchLine.includes('HEAD') && branchLine.includes('no branch');
+            const [branchPart, trackingPart] = branchLine.split('...');
+            currentBranch = branchPart?.replace(/\s+\[.*\]$/, '') || undefined;
+            if (trackingPart) {
+                const match = trackingPart.match(/^([^\s[]+)(?:\s+\[(.*)\])?/);
+                upstream = match?.[1];
+                const details = match?.[2] ?? '';
+                ahead = numberFrom(details, /ahead\s+(\d+)/);
+                behind = numberFrom(details, /behind\s+(\d+)/);
+            }
+            continue;
+        }
+        const indexStatus = line[0] ?? ' ';
+        const workingTreeStatus = line[1] ?? ' ';
+        const path = line.slice(3);
+        const [name, renamedFrom] = path.includes(' -> ') ? path.split(' -> ').reverse() : [path, undefined];
+        const status = statusName(indexStatus, workingTreeStatus);
+        fileStatus.push({ name, status, indexStatus, workingTreeStatus, staged: indexStatus !== ' ' && indexStatus !== '?', renamedFrom });
+    }
+    const stagedCount = fileStatus.filter((item) => item.staged).length;
+    const untrackedCount = fileStatus.filter((item) => item.status === 'untracked').length;
+    const conflictCount = fileStatus.filter((item) => item.status === 'conflict').length;
+    const totalCount = fileStatus.length;
+    return {
+        currentBranch,
+        upstream,
+        ahead,
+        behind,
+        detached,
+        fileStatus,
+        isClean: totalCount === 0,
+        hasChanges: totalCount > 0,
+        hasStaged: stagedCount > 0,
+        hasUntracked: untrackedCount > 0,
+        hasConflicts: conflictCount > 0,
+        totalCount,
+        stagedCount,
+        unstagedCount: totalCount - stagedCount,
+        untrackedCount,
+        conflictCount,
+        result,
+    };
+}
+function numberFrom(value, pattern) {
+    const match = value.match(pattern);
+    return match ? Number(match[1]) : 0;
+}
+function statusName(indexStatus, workingTreeStatus) {
+    if (indexStatus === '?' && workingTreeStatus === '?')
+        return 'untracked';
+    if (indexStatus === 'U' || workingTreeStatus === 'U' || indexStatus === 'A' && workingTreeStatus === 'A')
+        return 'conflict';
+    if (indexStatus === 'D' || workingTreeStatus === 'D')
+        return 'deleted';
+    if (indexStatus === 'R')
+        return 'renamed';
+    if (indexStatus === 'A')
+        return 'added';
+    if (indexStatus === 'M' || workingTreeStatus === 'M')
+        return 'modified';
+    return 'changed';
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}