@danneillouven/remote-workspace 0.0.0-stage → 0.1.0

package/runtime/server/src/modules/filesystem/workspace-file-service.js

@@ -0,0 +1,328 @@
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { mapWithConcurrency } from "../../lib/concurrency.js";
+import { AppError } from "../../lib/errors.js";
+import { parseByteRange } from "../../lib/http-range.js";
+import { isWithinRoot, joinWorkspacePath, normalizeWorkspacePath } from "./workspace-path.js";
+// Media the viewer can show, by extension. Nothing else is ever served for preview,
+// so a file's bytes can never be interpreted by the browser as HTML or script.
+const IMAGE_TYPES = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    bmp: 'image/bmp',
+    ico: 'image/x-icon',
+    svg: 'image/svg+xml',
+    // Safari decodes these; other browsers show the viewer's "cannot be displayed" notice.
+    heic: 'image/heic',
+    heif: 'image/heif',
+    tif: 'image/tiff',
+    tiff: 'image/tiff',
+    jxl: 'image/jxl',
+};
+const MEDIA_TYPES = {
+    ...IMAGE_TYPES,
+    mp4: 'video/mp4',
+    m4v: 'video/mp4',
+    mov: 'video/quicktime',
+    webm: 'video/webm',
+    ogv: 'video/ogg',
+    mp3: 'audio/mpeg',
+    m4a: 'audio/mp4',
+    aac: 'audio/aac',
+    wav: 'audio/wav',
+    flac: 'audio/flac',
+    oga: 'audio/ogg',
+    ogg: 'audio/ogg',
+    opus: 'audio/ogg',
+};
+const extensionOf = (filePath) => path.posix.extname(filePath).slice(1).toLowerCase();
+export function previewContentType(filePath) {
+    return MEDIA_TYPES[extensionOf(filePath)] ?? null;
+}
+// Same heuristic as Git: a NUL byte in the first 8000 bytes means binary.
+const BINARY_SNIFF_BYTES = 8000;
+const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+/**
+ * Workspace-scoped file access. Every request path is normalized, resolved to
+ * its canonical form (following symlinks), and checked against the canonical
+ * workspace root, so symlinks cannot be used to escape the workspace.
+ */
+export class WorkspaceFileService {
+    #driver;
+    #options;
+    #canonicalRoot = null;
+    constructor(driver, options) {
+        this.#driver = driver;
+        this.#options = options;
+    }
+    async #getCanonicalRoot() {
+        await this.#options.validateRoot?.();
+        if (this.#options.validateRoot)
+            this.#canonicalRoot = null;
+        if (!this.#canonicalRoot) {
+            const pending = this.#driver.realpath(this.#options.root).catch((error) => {
+                this.#canonicalRoot = null;
+                if (error instanceof AppError && error.code === 'NOT_FOUND') {
+                    throw new AppError('NOT_FOUND', `Workspace root ${this.#options.root} does not exist.`, { cause: error });
+                }
+                throw error;
+            });
+            this.#canonicalRoot = pending;
+        }
+        return this.#canonicalRoot;
+    }
+    /** Resolve a client path to a canonical absolute path inside the workspace. */
+    async resolve(requestPath) {
+        const relativePath = normalizeWorkspacePath(requestPath);
+        const root = await this.#getCanonicalRoot();
+        const absolutePath = await this.#driver.realpath(path.posix.join(root, relativePath));
+        if (!isWithinRoot(root, absolutePath)) {
+            throw new AppError('PATH_OUTSIDE_WORKSPACE', 'Path resolves outside the workspace.');
+        }
+        return { relativePath, absolutePath };
+    }
+    async listDirectory(requestPath) {
+        const { relativePath, absolutePath } = await this.resolve(requestPath);
+        const stat = await this.#driver.stat(absolutePath);
+        if (stat.type !== 'directory')
+            throw new AppError('NOT_A_DIRECTORY', 'Not a directory.');
+        const raw = await this.#driver.readdir(absolutePath);
+        const entries = await mapWithConcurrency(raw, 16, async ({ name, stat: entryStat }) => {
+            let target = entryStat;
+            if (entryStat.type === 'symlink') {
+                // Report the link target's type. Whether the target is inside the
+                // workspace is enforced when the entry is actually opened.
+                target = await this.#driver.stat(path.posix.join(absolutePath, name)).catch(() => null);
+            }
+            return {
+                name,
+                path: joinWorkspacePath(relativePath, name),
+                type: target?.type === 'file' || target?.type === 'directory' ? target.type : 'other',
+                isSymlink: entryStat.type === 'symlink',
+                size: target?.type === 'file' ? target.size : null,
+                mtimeMs: target?.mtimeMs ?? null,
+            };
+        });
+        entries.sort((a, b) => {
+            const aDir = a.type === 'directory' ? 0 : 1;
+            const bDir = b.type === 'directory' ? 0 : 1;
+            return aDir - bDir || collator.compare(a.name, b.name);
+        });
+        const truncated = entries.length > this.#options.maxDirEntries;
+        return { path: relativePath, entries: truncated ? entries.slice(0, this.#options.maxDirEntries) : entries, truncated };
+    }
+    async readFile(requestPath) {
+        const { relativePath, absolutePath } = await this.resolve(requestPath);
+        const stat = await this.#driver.stat(absolutePath);
+        // Refuse directories and special files (FIFOs, devices) — reading a FIFO would block.
+        if (stat.type !== 'file')
+            throw new AppError('NOT_A_FILE', 'Not a regular file.');
+        const base = { path: relativePath, size: stat.size, mtimeMs: stat.mtimeMs };
+        if (stat.size > this.#options.maxFileBytes) {
+            return { kind: 'too-large', ...base, limit: this.#options.maxFileBytes };
+        }
+        const data = stat.size === 0 ? Buffer.alloc(0) : await this.#driver.readFile(absolutePath, this.#options.maxFileBytes);
+        if (data.subarray(0, BINARY_SNIFF_BYTES).includes(0)) {
+            return { kind: 'binary', ...base };
+        }
+        let content;
+        let hasDecodingErrors = false;
+        try {
+            content = new TextDecoder('utf-8', { fatal: true }).decode(data);
+        }
+        catch {
+            content = new TextDecoder('utf-8').decode(data);
+            hasDecodingErrors = true;
+        }
+        return { kind: 'text', ...base, size: data.length, content, hasDecodingErrors };
+    }
+    /**
+     * Overwrite an existing text file. `expectedMtimeMs` guards against clobbering a
+     * change made on the host since the editor loaded the file (null forces the write).
+     */
+    async writeFile(requestPath, content, expectedMtimeMs) {
+        const { relativePath, absolutePath } = await this.resolve(requestPath);
+        const stat = await this.#driver.stat(absolutePath);
+        if (stat.type !== 'file')
+            throw new AppError('NOT_A_FILE', 'Not a regular file.');
+        if (expectedMtimeMs !== null && stat.mtimeMs !== null && stat.mtimeMs !== expectedMtimeMs) {
+            throw new AppError('CONFLICT', 'The file changed on disk since it was opened.');
+        }
+        const data = Buffer.from(content, 'utf8');
+        if (data.length > this.#options.maxFileBytes) {
+            throw new AppError('BAD_REQUEST', `File exceeds the ${this.#options.maxFileBytes}-byte limit (MAX_FILE_BYTES).`);
+        }
+        await this.#driver.writeFile(absolutePath, data);
+        const written = await this.#driver.stat(absolutePath);
+        return { kind: 'text', path: relativePath, content, size: data.length, mtimeMs: written.mtimeMs, hasDecodingErrors: false };
+    }
+    /**
+     * Bytes of a file for the media viewer (images, video, audio) or, with `download`,
+     * any regular file as an attachment. Supports a single byte range, which iOS needs
+     * to play video.
+     */
+    async openRaw(requestPath, options) {
+        const previewType = previewContentType(requestPath);
+        if (!options.download && !previewType)
+            throw new AppError('BAD_REQUEST', 'Only images, video, and audio can be previewed.');
+        const { relativePath, absolutePath } = await this.resolve(requestPath);
+        const stat = await this.#driver.stat(absolutePath);
+        if (stat.type !== 'file')
+            throw new AppError('NOT_A_FILE', 'Not a regular file.');
+        // Decoding a huge image can take down a phone's browser tab.
+        if (!options.download && IMAGE_TYPES[extensionOf(relativePath)] && stat.size > this.#options.maxImageBytes) {
+            throw new AppError('BAD_REQUEST', `Image exceeds the ${this.#options.maxImageBytes}-byte limit (MAX_IMAGE_BYTES).`, { statusCode: 413 });
+        }
+        const range = parseByteRange(options.range, stat.size);
+        if (range === 'unsatisfiable')
+            throw new AppError('BAD_REQUEST', 'Requested range not satisfiable.', { statusCode: 416 });
+        const { start, end } = range ?? { start: 0, end: stat.size - 1 };
+        const stream = stat.size === 0 ? Readable.from([]) : await this.#driver.createReadStream(absolutePath, { start, end });
+        return {
+            stream,
+            contentType: options.download || !previewType ? 'application/octet-stream' : previewType,
+            name: path.posix.basename(relativePath),
+            size: stat.size,
+            range,
+        };
+    }
+    /**
+     * Resolve an entry to act on itself (rename, move, delete) rather than through it:
+     * the parent is canonicalized and contained, but a symlink at the final component
+     * stays a symlink, so deleting a link never touches its target.
+     */
+    async #resolveEntry(requestPath) {
+        const relativePath = normalizeWorkspacePath(requestPath);
+        if (relativePath === '')
+            throw new AppError('BAD_REQUEST', 'The project folder itself cannot be changed.');
+        const parent = await this.resolve(path.posix.dirname(relativePath).replace(/^\.$/, ''));
+        if ((await this.#driver.stat(parent.absolutePath)).type !== 'directory')
+            throw new AppError('NOT_A_DIRECTORY', 'Not a directory.');
+        const name = path.posix.basename(relativePath);
+        return { relativePath, absolutePath: path.posix.join(parent.absolutePath, name) };
+    }
+    async #exists(absolutePath) {
+        try {
+            await this.#driver.lstat(absolutePath);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === 'NOT_FOUND')
+                return false;
+            throw error;
+        }
+    }
+    async #resolveDirectory(requestPath) {
+        const directory = await this.resolve(requestPath);
+        if ((await this.#driver.stat(directory.absolutePath)).type !== 'directory')
+            throw new AppError('NOT_A_DIRECTORY', 'Not a directory.');
+        return directory;
+    }
+    /** Create an empty file or a folder, along with any missing parent folders. */
+    async createEntry(requestPath, type) {
+        const relativePath = normalizeWorkspacePath(requestPath);
+        const segments = relativePath.split('/');
+        for (let depth = 1; depth < segments.length; depth++) {
+            const parent = await this.#resolveEntry(segments.slice(0, depth).join('/'));
+            if (!(await this.#exists(parent.absolutePath)))
+                await this.#driver.mkdir(parent.absolutePath);
+        }
+        const { absolutePath } = await this.#resolveEntry(relativePath);
+        if (await this.#exists(absolutePath))
+            throw new AppError('CONFLICT', `${segments.at(-1)} already exists.`);
+        if (type === 'directory')
+            await this.#driver.mkdir(absolutePath);
+        else
+            await this.#driver.createFile(absolutePath);
+        return { path: relativePath };
+    }
+    /** Copy a file or folder into `destination`, picking a free name ("name copy.ext") on a clash. */
+    async copyEntry(requestPath, destination) {
+        const source = await this.resolve(requestPath);
+        if (source.relativePath === '')
+            throw new AppError('BAD_REQUEST', 'The project folder itself cannot be copied.');
+        const target = await this.#resolveDirectory(destination);
+        const sourceStat = await this.#driver.stat(source.absolutePath);
+        if (sourceStat.type === 'directory' && isWithinRoot(source.absolutePath, target.absolutePath)) {
+            throw new AppError('BAD_REQUEST', 'A folder cannot be copied into itself.');
+        }
+        const name = await this.#freeName(target.absolutePath, path.posix.basename(source.relativePath));
+        await this.#copyTree(source.absolutePath, path.posix.join(target.absolutePath, name), sourceStat);
+        return { path: joinWorkspacePath(target.relativePath, name) };
+    }
+    async #freeName(directory, name) {
+        if (!(await this.#exists(path.posix.join(directory, name))))
+            return name;
+        // ".env" has no extension; "archive.tar.gz" becomes "archive.tar copy.gz", as in VS Code.
+        const extension = path.posix.extname(name);
+        const stem = name.slice(0, name.length - extension.length);
+        for (let attempt = 1; attempt < 1000; attempt++) {
+            const candidate = `${stem} copy${attempt === 1 ? '' : ` ${attempt}`}${extension}`;
+            if (!(await this.#exists(path.posix.join(directory, candidate))))
+                return candidate;
+        }
+        throw new AppError('CONFLICT', 'Could not find a free name for the copy.');
+    }
+    // Symlinks and special files inside a copied folder are skipped: following a link
+    // could copy data from outside the workspace into it.
+    async #copyTree(source, destination, stat) {
+        if (stat.type === 'file')
+            return this.#driver.copyFile(source, destination);
+        if (stat.type !== 'directory')
+            return;
+        await this.#driver.mkdir(destination);
+        for (const entry of await this.#driver.readdir(source)) {
+            await this.#copyTree(path.posix.join(source, entry.name), path.posix.join(destination, entry.name), entry.stat);
+        }
+    }
+    /** Move a file or folder into `destination`; refuses to replace an existing entry. */
+    async moveEntry(requestPath, destination) {
+        const source = await this.#resolveEntry(requestPath);
+        const target = await this.#resolveDirectory(destination);
+        const sourceStat = await this.#driver.lstat(source.absolutePath);
+        const name = path.posix.basename(source.relativePath);
+        const destinationPath = path.posix.join(target.absolutePath, name);
+        if (destinationPath === source.absolutePath)
+            return { path: source.relativePath };
+        if (sourceStat.type === 'directory' && isWithinRoot(source.absolutePath, target.absolutePath)) {
+            throw new AppError('BAD_REQUEST', 'A folder cannot be moved into itself.');
+        }
+        if (await this.#exists(destinationPath))
+            throw new AppError('CONFLICT', `${name} already exists in the destination folder.`);
+        await this.#driver.rename(source.absolutePath, destinationPath);
+        return { path: joinWorkspacePath(target.relativePath, name) };
+    }
+    async renameEntry(requestPath, newName) {
+        const source = await this.#resolveEntry(requestPath);
+        await this.#driver.lstat(source.absolutePath);
+        const parent = path.posix.dirname(source.relativePath).replace(/^\.$/, '');
+        const relativePath = joinWorkspacePath(parent, newName);
+        const oldName = path.posix.basename(source.relativePath);
+        if (newName === oldName)
+            return { path: source.relativePath };
+        const destinationPath = path.posix.join(path.posix.dirname(source.absolutePath), newName);
+        // A case-only rename finds the file itself on case-insensitive filesystems.
+        if (newName.toLowerCase() !== oldName.toLowerCase() && (await this.#exists(destinationPath))) {
+            throw new AppError('CONFLICT', `${newName} already exists.`);
+        }
+        await this.#driver.rename(source.absolutePath, destinationPath);
+        return { path: relativePath };
+    }
+    /** Delete a file, symlink, or folder with everything in it. */
+    async deleteEntry(requestPath) {
+        const { absolutePath } = await this.#resolveEntry(requestPath);
+        await this.#removeTree(absolutePath, await this.#driver.lstat(absolutePath));
+    }
+    async #removeTree(absolutePath, stat) {
+        if (stat.type !== 'directory')
+            return this.#driver.unlink(absolutePath);
+        for (const entry of await this.#driver.readdir(absolutePath)) {
+            await this.#removeTree(path.posix.join(absolutePath, entry.name), entry.stat);
+        }
+        await this.#driver.rmdir(absolutePath);
+    }
+}

package/runtime/server/src/modules/filesystem/workspace-path.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { AppError } from "../../lib/errors.js";
+/**
+ * Normalize a client-supplied workspace-relative path. Returns '' for the
+ * root, otherwise a clean relative POSIX path with no '.', '..', or empty
+ * segments. Absolute paths and anything escaping the root are rejected.
+ */
+export function normalizeWorkspacePath(input) {
+    if (input.includes('\0'))
+        throw new AppError('BAD_REQUEST', 'Path must not contain NUL bytes.');
+    if (input.startsWith('/'))
+        throw new AppError('BAD_REQUEST', 'Path must be relative to the workspace root.');
+    const normalized = path.posix.normalize(input === '' ? '.' : input).replace(/\/+$/, '');
+    if (normalized === '.' || normalized === '')
+        return '';
+    if (normalized === '..' || normalized.startsWith('../')) {
+        throw new AppError('PATH_OUTSIDE_WORKSPACE', 'Path is outside the workspace.');
+    }
+    return normalized;
+}
+/**
+ * Containment check on canonical absolute paths. Uses path.relative rather
+ * than a string prefix so '/srv/app-old' is not considered inside '/srv/app'.
+ */
+export function isWithinRoot(root, candidate) {
+    const relative = path.posix.relative(root, candidate);
+    return relative === '' || (relative !== '..' && !relative.startsWith('../') && !path.posix.isAbsolute(relative));
+}
+export function joinWorkspacePath(parent, name) {
+    return parent === '' ? name : `${parent}/${name}`;
+}

package/runtime/server/src/modules/git/git-parsers.js

@@ -0,0 +1,229 @@
+const kindByCode = {
+    M: 'modified',
+    A: 'added',
+    D: 'deleted',
+    R: 'renamed',
+    C: 'copied',
+    T: 'type-changed',
+};
+/** Split `count` space-separated fields off the front; the remainder (which may contain spaces) is returned last. */
+function splitFields(record, count) {
+    const fields = [];
+    let offset = 0;
+    for (let index = 0; index < count; index += 1) {
+        const next = record.indexOf(' ', offset);
+        if (next === -1)
+            return null;
+        fields.push(record.slice(offset, next));
+        offset = next + 1;
+    }
+    return { fields, rest: record.slice(offset) };
+}
+function pushChanges(changes, xy, path, origPath) {
+    const [index, worktree] = xy;
+    if (index && index !== '.') {
+        changes.push({ path, origPath: index === 'R' || index === 'C' ? origPath : null, area: 'staged', kind: kindByCode[index] ?? 'modified' });
+    }
+    if (worktree && worktree !== '.') {
+        changes.push({ path, origPath: null, area: 'unstaged', kind: kindByCode[worktree] ?? 'modified' });
+    }
+}
+/**
+ * Parse `git status --porcelain=v2 --branch -z`. With -z, records are
+ * NUL-terminated and paths are emitted verbatim (no quoting), so names
+ * containing spaces, quotes, or newlines are preserved exactly.
+ */
+export function parsePorcelainV2(output) {
+    const status = {
+        commit: null,
+        branch: null,
+        detached: false,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        changes: [],
+    };
+    const records = output.split('\0');
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        if (!record)
+            continue;
+        switch (record[0]) {
+            case '#': {
+                const [, key, ...values] = record.split(' ');
+                const value = values.join(' ');
+                if (key === 'branch.oid')
+                    status.commit = value === '(initial)' ? null : value;
+                else if (key === 'branch.head') {
+                    status.detached = value === '(detached)';
+                    status.branch = status.detached ? null : value;
+                }
+                else if (key === 'branch.upstream')
+                    status.upstream = value;
+                else if (key === 'branch.ab') {
+                    const match = /^\+(\d+) -(\d+)$/.exec(value);
+                    if (match) {
+                        status.ahead = Number(match[1]);
+                        status.behind = Number(match[2]);
+                    }
+                }
+                break;
+            }
+            case '1': {
+                // 1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
+                const parsed = splitFields(record, 8);
+                if (parsed)
+                    pushChanges(status.changes, parsed.fields[1] ?? '', parsed.rest, null);
+                break;
+            }
+            case '2': {
+                // 2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path>\0<origPath>
+                const parsed = splitFields(record, 9);
+                const origPath = records[index + 1] ?? null;
+                index += 1;
+                if (parsed)
+                    pushChanges(status.changes, parsed.fields[1] ?? '', parsed.rest, origPath);
+                break;
+            }
+            case 'u': {
+                // u <XY> <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path>
+                const parsed = splitFields(record, 10);
+                if (parsed)
+                    status.changes.push({ path: parsed.rest, origPath: null, area: 'conflicted', kind: 'conflicted' });
+                break;
+            }
+            case '?':
+                status.changes.push({ path: record.slice(2), origPath: null, area: 'untracked', kind: 'untracked' });
+                break;
+            default:
+                // '!' (ignored) and unknown future record types are skipped.
+                break;
+        }
+    }
+    return status;
+}
+/**
+ * Parse `git diff --numstat -z`. Binary files report '-' counts (→ null).
+ * Renames are emitted as `<add>\t<del>\t\0<orig>\0<path>\0`.
+ */
+export function parseNumstat(output) {
+    const counts = new Map();
+    const records = output.split('\0');
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        if (!record)
+            continue;
+        const match = /^(-|\d+)\t(-|\d+)\t(.*)$/s.exec(record);
+        if (!match)
+            continue;
+        let filePath = match[3] ?? '';
+        if (filePath === '') {
+            // Rename/copy: the next two records are the original and new paths.
+            filePath = records[index + 2] ?? '';
+            index += 2;
+        }
+        counts.set(filePath, {
+            additions: match[1] === '-' ? null : Number(match[1]),
+            deletions: match[2] === '-' ? null : Number(match[2]),
+        });
+    }
+    return counts;
+}
+export function isBinaryDiff(diff) {
+    return /^Binary files .* differ$/m.test(diff) || diff.includes('\nGIT binary patch\n');
+}
+/** Split a one-file `git diff` into its file header and hunks ("@@ ..." through the hunk's last line, no trailing newline). */
+export function splitDiffHunks(diff) {
+    const lines = diff.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    const first = lines.findIndex((line) => line.startsWith('@@ '));
+    if (first === -1)
+        return { header: diff, hunks: [] };
+    const hunks = [];
+    for (const line of lines.slice(first)) {
+        if (line.startsWith('@@ '))
+            hunks.push([line]);
+        else
+            hunks.at(-1)?.push(line);
+    }
+    return { header: lines.slice(0, first).map((line) => `${line}\n`).join(''), hunks: hunks.map((hunk) => hunk.join('\n')) };
+}
+/** Fields of the `git log` format below, separated by U+001F; commits are NUL-separated (-z). */
+export const LOG_FORMAT = '%H%x1f%P%x1f%aN%x1f%aE%x1f%at%x1f%D%x1f%B';
+/**
+ * Parse `--decorate=full` ref names (%D), the way VS Code's Git extension does:
+ * the checked-out branch, other branches, remote branches (except origin/HEAD-style aliases), and tags.
+ */
+export function parseRefNames(decoration) {
+    const refs = [];
+    for (const raw of decoration.split(', ')) {
+        const name = raw.trim();
+        if (!name)
+            continue;
+        if (name === 'HEAD')
+            refs.push({ id: 'HEAD', name: 'HEAD', kind: 'head' });
+        else if (name.startsWith('HEAD -> refs/heads/')) {
+            const id = name.slice('HEAD -> '.length);
+            refs.push({ id, name: id.slice('refs/heads/'.length), kind: 'head' });
+        }
+        else if (name.startsWith('refs/heads/'))
+            refs.push({ id: name, name: name.slice('refs/heads/'.length), kind: 'branch' });
+        else if (name.startsWith('refs/remotes/') && !name.endsWith('/HEAD'))
+            refs.push({ id: name, name: name.slice('refs/remotes/'.length), kind: 'remote' });
+        else if (name.startsWith('tag: refs/tags/')) {
+            const id = name.slice('tag: '.length);
+            refs.push({ id, name: id.slice('refs/tags/'.length), kind: 'tag' });
+        }
+    }
+    return refs;
+}
+/** Parse `git log -z --format=LOG_FORMAT`. */
+export function parseLog(output) {
+    const items = [];
+    for (const record of output.split('\0')) {
+        if (!record.trim())
+            continue;
+        const fields = record.split('\x1f');
+        if (fields.length < 7)
+            continue;
+        const [id = '', parents = '', author = '', email = '', timestamp = '0', decoration = ''] = fields;
+        // The message is last and may itself contain the separator.
+        const message = fields.slice(6).join('\x1f').replace(/\s+$/, '');
+        items.push({
+            id: id.trim(),
+            parentIds: parents.split(' ').filter(Boolean),
+            subject: message.split('\n')[0] ?? '',
+            message,
+            author,
+            email,
+            timestamp: Number(timestamp) || 0,
+            refs: parseRefNames(decoration),
+        });
+    }
+    return items;
+}
+const kindByStatusLetter = { ...kindByCode, U: 'conflicted' };
+/** Parse `git diff --name-status -z` (renames/copies: `R<score>\0<orig>\0<path>`). */
+export function parseNameStatus(output) {
+    const entries = [];
+    const records = output.split('\0');
+    for (let index = 0; index < records.length; index += 1) {
+        const status = records[index];
+        if (!status)
+            continue;
+        const letter = status[0] ?? '';
+        if (letter === 'R' || letter === 'C') {
+            const origPath = records[index + 1] ?? '';
+            const filePath = records[index + 2] ?? '';
+            index += 2;
+            entries.push({ path: filePath, origPath, kind: kindByStatusLetter[letter] ?? 'modified' });
+        }
+        else {
+            const filePath = records[index + 1] ?? '';
+            index += 1;
+            entries.push({ path: filePath, origPath: null, kind: kindByStatusLetter[letter] ?? 'modified' });
+        }
+    }
+    return entries;
+}