@myagentroam/node 0.1.0

package/dist/workspace.js

@@ -0,0 +1,732 @@
+import { createHash } from 'node:crypto';
+import { lstat, readdir, readFile, realpath, stat, unlink } from 'node:fs/promises';
+import { homedir, platform as hostPlatform } from 'node:os';
+import { dirname, isAbsolute, posix, relative, resolve, sep, win32 } from 'node:path';
+import { spawn } from 'node:child_process';
+const GIT_TIMEOUT_MS = 5_000;
+const GIT_OUTPUT_LIMIT = 512 * 1024;
+const FILE_READ_LIMIT = 512 * 1024;
+const DIRECTORY_PAGE_LIMIT = 200;
+const DIRECTORY_PICKER_LIMIT = 200;
+const SEARCH_RESULT_LIMIT = 200;
+const SEARCH_SCAN_LIMIT = 10_000;
+const FILE_SEARCH_TIMEOUT_MS = 2_000;
+const REF_PATTERN = /^(?!-)(?!.*\.\.)(?!.*@\{)[A-Za-z0-9][A-Za-z0-9._/-]{0,254}$/;
+/**
+ * Lists directory names only for the Workspace picker. Browsing begins at the
+ * first allowed root when configured, while the Node account home remains a
+ * browse boundary and terminal default.
+ */
+export async function listWorkspaceDirectories(requestedPath, allowedRoots, homePath = homedir()) {
+    const home = await realpath(homePath);
+    const roots = await Promise.all(allowedRoots.map((root) => realpath(root)));
+    const browseRoots = [...new Set([home, ...roots])];
+    const requested = requestedPath === undefined ? (roots[0] ?? home) : await realpath(requestedPath);
+    const directory = await stat(requested);
+    if (!directory.isDirectory() || !isWithinAllowedRoot(requested, browseRoots))
+        throw new Error('WORKSPACE_DIRECTORY_NOT_ALLOWED');
+    const children = await readdir(requested, { withFileTypes: true });
+    const entries = [];
+    for (const child of children.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (!child.isDirectory() && !child.isSymbolicLink())
+            continue;
+        const path = await realpath(resolve(requested, child.name)).catch(() => undefined);
+        if (path === undefined || !isWithinAllowedRoot(path, browseRoots))
+            continue;
+        const metadata = await stat(path).catch(() => undefined);
+        if (metadata === undefined || !metadata.isDirectory())
+            continue;
+        entries.push({ path, name: child.name, selectable: isWithinAllowedRoot(path, roots) });
+        if (entries.length > DIRECTORY_PICKER_LIMIT)
+            break;
+    }
+    const parent = dirname(requested);
+    return {
+        homePath: home,
+        currentPath: requested,
+        parentPath: parent === requested || !isWithinAllowedRoot(parent, browseRoots) ? null : parent,
+        browseRoots: roots,
+        selectable: isWithinAllowedRoot(requested, roots),
+        entries: entries.slice(0, DIRECTORY_PICKER_LIMIT),
+        truncated: entries.length > DIRECTORY_PICKER_LIMIT
+    };
+}
+export async function listWorkspaceFiles(workspaceRoot, requestedPath = '.', cursor, limit = DIRECTORY_PAGE_LIMIT, options = {}) {
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > DIRECTORY_PAGE_LIMIT)
+        throw new Error('DIRECTORY_CURSOR_INVALID');
+    const directory = await resolveWorkspaceEntry(workspaceRoot, requestedPath, true, options);
+    const entries = await readdir(directory, { withFileTypes: true });
+    const root = await realpath(workspaceRoot);
+    const cursorValue = decodeDirectoryCursor(cursor, requestedPath);
+    const names = entries
+        .filter((entry) => entry.name !== '.git' && !isWorkspaceUploadTemporaryName(entry.name))
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+    const start = cursorValue === undefined ? 0 : names.findIndex((name) => name > cursorValue);
+    if (cursorValue !== undefined && start === -1)
+        return { entries: [], nextCursor: null, truncated: false };
+    const pageNames = names.slice(start, start + limit);
+    const output = [];
+    for (const name of pageNames) {
+        const child = await resolveWorkspaceEntry(root, relative(root, resolve(directory, name)), false, options).catch(() => undefined);
+        if (child === undefined)
+            continue;
+        const metadata = await lstat(child).catch(() => undefined);
+        if (metadata === undefined || (!metadata.isFile() && !metadata.isDirectory()))
+            continue;
+        output.push({
+            path: relative(root, child).split(sep).join('/'),
+            name,
+            kind: metadata.isDirectory() ? 'DIRECTORY' : 'FILE',
+            size: metadata.isFile() ? metadata.size : null,
+            modifiedAt: metadata.mtimeMs
+        });
+    }
+    const nextName = names[start + pageNames.length];
+    return {
+        entries: output,
+        nextCursor: nextName === undefined || pageNames.length === 0
+            ? null
+            : encodeDirectoryCursor(requestedPath, pageNames[pageNames.length - 1]),
+        truncated: nextName !== undefined
+    };
+}
+/** Validates an upload destination without following an existing target symlink. */
+export async function preflightWorkspaceUpload(workspaceRoot, requestedDirectory, name, options = {}) {
+    if (name.length === 0 ||
+        name === '.' ||
+        name === '..' ||
+        name.includes('\0') ||
+        name.includes('/') ||
+        name.includes('\\') ||
+        isWorkspaceUploadTemporaryName(name)) {
+        return { path: '', absolutePath: '', status: 'INVALID_NAME' };
+    }
+    const root = await realpath(workspaceRoot);
+    const directory = await resolveWorkspaceEntry(root, requestedDirectory, true, options);
+    const absolutePath = resolve(directory, name);
+    if (dirname(absolutePath) !== directory)
+        throw new Error('FILE_PATH_ESCAPE');
+    assertNotPrivate(absolutePath, options.privateRoots);
+    const relativePath = relative(root, absolutePath).split(sep).join('/');
+    const metadata = await lstat(absolutePath).catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (metadata === undefined)
+        return { path: relativePath, absolutePath, status: 'READY' };
+    if (metadata.isSymbolicLink())
+        throw new Error('FILE_PATH_ESCAPE');
+    if (metadata.isFile())
+        return { path: relativePath, absolutePath, status: 'EXISTS_FILE' };
+    return { path: relativePath, absolutePath, status: 'EXISTS_DIRECTORY' };
+}
+export function workspaceUploadTemporaryName(uploadId) {
+    return `.mar-upload-${uploadId}.part`;
+}
+function isWorkspaceUploadTemporaryName(name) {
+    return /^\.mar-upload-[0-9a-f-]{36}\.part$/i.test(name);
+}
+export async function readWorkspaceTextFile(workspaceRoot, requestedPath, offset = 0, limit = FILE_READ_LIMIT, options = {}) {
+    if (!Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > FILE_READ_LIMIT)
+        throw new Error('FILE_RANGE_INVALID');
+    const root = await realpath(workspaceRoot);
+    const file = await resolveWorkspaceEntry(root, requestedPath, false, options);
+    const metadata = await lstat(file);
+    if (!metadata.isFile())
+        throw new Error('FILE_NOT_REGULAR');
+    if (metadata.size > FILE_READ_LIMIT * 16)
+        throw new Error('FILE_TOO_LARGE');
+    const source = await readFile(file);
+    const binary = source.includes(0) || !isValidUtf8(source);
+    if (binary) {
+        const end = Math.min(source.length, offset + limit);
+        const slice = source.subarray(offset, end);
+        return {
+            path: relative(root, file).split(sep).join('/'),
+            encoding: 'base64',
+            size: source.length,
+            content: slice.toString('base64'),
+            truncated: end < source.length,
+            nextOffset: end < source.length ? end : null
+        };
+    }
+    if (offset > 0 && offset < source.length && isUtf8ContinuationByte(source[offset]))
+        throw new Error('FILE_RANGE_INVALID');
+    let end = Math.min(source.length, offset + limit);
+    if (end < source.length && isUtf8ContinuationByte(source[end])) {
+        while (end > offset && isUtf8ContinuationByte(source[end]))
+            end -= 1;
+        if (end === offset) {
+            end += 1;
+            while (end < source.length && isUtf8ContinuationByte(source[end]))
+                end += 1;
+        }
+    }
+    const slice = source.subarray(offset, end);
+    const content = new TextDecoder('utf-8', { fatal: true }).decode(slice);
+    const nextOffset = end < source.length ? end : null;
+    return {
+        path: relative(root, file).split(sep).join('/'),
+        encoding: 'utf-8',
+        size: source.length,
+        content,
+        truncated: nextOffset !== null,
+        nextOffset
+    };
+}
+/** Reads one absolute file only when the resolved target remains within a Node allowed root. */
+export async function readAllowedTextFile(requestedPath, allowedRoots, offset = 0, limit = FILE_READ_LIMIT, options = {}) {
+    if (!isAbsolute(requestedPath))
+        throw new Error('FILE_PATH_ESCAPE');
+    const file = await realpath(requestedPath).catch((error) => {
+        if (error.code === 'ENOENT')
+            throw new Error('FILE_NOT_FOUND');
+        throw error;
+    });
+    const roots = await Promise.all(allowedRoots.map((root) => realpath(root)));
+    if (!isWithinAllowedRoot(file, roots))
+        throw new Error('FILE_PATH_ESCAPE');
+    assertNotPrivate(file, options.privateRoots);
+    const metadata = await lstat(file);
+    if (!metadata.isFile())
+        throw new Error('FILE_NOT_REGULAR');
+    if (metadata.size > FILE_READ_LIMIT * 16)
+        throw new Error('FILE_TOO_LARGE');
+    if (!Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > FILE_READ_LIMIT)
+        throw new Error('FILE_RANGE_INVALID');
+    const source = await readFile(file);
+    const binary = source.includes(0) || !isValidUtf8(source);
+    const end = Math.min(source.length, offset + limit);
+    if (binary) {
+        const slice = source.subarray(offset, end);
+        return {
+            path: file,
+            encoding: 'base64',
+            size: source.length,
+            content: slice.toString('base64'),
+            truncated: end < source.length,
+            nextOffset: end < source.length ? end : null
+        };
+    }
+    if (offset > 0 && offset < source.length && isUtf8ContinuationByte(source[offset]))
+        throw new Error('FILE_RANGE_INVALID');
+    let textEnd = end;
+    if (textEnd < source.length && isUtf8ContinuationByte(source[textEnd])) {
+        while (textEnd > offset && isUtf8ContinuationByte(source[textEnd]))
+            textEnd -= 1;
+        if (textEnd === offset) {
+            textEnd += 1;
+            while (textEnd < source.length && isUtf8ContinuationByte(source[textEnd]))
+                textEnd += 1;
+        }
+    }
+    const nextOffset = textEnd < source.length ? textEnd : null;
+    return {
+        path: file,
+        encoding: 'utf-8',
+        size: source.length,
+        content: new TextDecoder('utf-8', { fatal: true }).decode(source.subarray(offset, textEnd)),
+        truncated: nextOffset !== null,
+        nextOffset
+    };
+}
+function isValidUtf8(source) {
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(source);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isUtf8ContinuationByte(value) {
+    return (value & 0b1100_0000) === 0b1000_0000;
+}
+/** Searches file names only, so an exploratory request cannot exfiltrate file contents. */
+export async function searchWorkspaceFiles(workspaceRoot, query, cursor, limit = SEARCH_RESULT_LIMIT, options = {}) {
+    if (query.trim().length === 0 || query.length > 256)
+        throw new Error('FILE_SEARCH_LIMIT_EXCEEDED');
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > SEARCH_RESULT_LIMIT)
+        throw new Error('FILE_SEARCH_LIMIT_EXCEEDED');
+    const root = await realpath(workspaceRoot);
+    assertNotPrivate(root, options.privateRoots);
+    const after = decodeSearchCursor(cursor, query);
+    const deadline = Date.now() + FILE_SEARCH_TIMEOUT_MS;
+    const results = [];
+    let scanned = 0;
+    let exhausted = true;
+    const directories = ['.'];
+    const normalizedQuery = query.toLocaleLowerCase();
+    while (directories.length > 0) {
+        if (Date.now() > deadline || scanned >= SEARCH_SCAN_LIMIT) {
+            exhausted = false;
+            break;
+        }
+        const directoryPath = directories.shift();
+        const directory = await resolveWorkspaceEntry(root, directoryPath, true, options).catch((error) => {
+            if (error instanceof Error && error.message === 'FILE_NOT_FOUND')
+                return undefined;
+            throw error;
+        });
+        if (directory === undefined)
+            continue;
+        const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (entries === undefined)
+            continue;
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (entry.name === '.git')
+                continue;
+            scanned += 1;
+            if (scanned > SEARCH_SCAN_LIMIT || Date.now() > deadline) {
+                exhausted = false;
+                break;
+            }
+            const requestPath = relative(root, resolve(directory, entry.name)).split(sep).join('/');
+            const child = await resolveWorkspaceEntry(root, requestPath, false, options).catch(() => undefined);
+            if (child === undefined)
+                continue;
+            const metadata = await lstat(child).catch(() => undefined);
+            if (metadata === undefined || (!metadata.isFile() && !metadata.isDirectory()))
+                continue;
+            const safePath = relative(root, child).split(sep).join('/');
+            if (metadata.isDirectory())
+                directories.push(safePath);
+            if (safePath <= (after ?? '') || !safePath.toLocaleLowerCase().includes(normalizedQuery))
+                continue;
+            results.push({
+                path: safePath,
+                name: entry.name,
+                kind: metadata.isDirectory() ? 'DIRECTORY' : 'FILE',
+                size: metadata.isFile() ? metadata.size : null,
+                modifiedAt: metadata.mtimeMs
+            });
+            if (results.length > limit) {
+                exhausted = false;
+                break;
+            }
+        }
+        if (!exhausted || results.length > limit)
+            break;
+    }
+    results.sort((left, right) => left.path.localeCompare(right.path));
+    const page = results.slice(0, limit);
+    const nextCursor = !exhausted || results.length > limit
+        ? encodeSearchCursor(query, page[page.length - 1]?.path ?? after ?? '')
+        : null;
+    return { entries: page, nextCursor, truncated: nextCursor !== null };
+}
+async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory, options = {}) {
+    if (requestedPath.includes('\0') ||
+        requestedPath.length === 0 ||
+        requestedPath.startsWith('/') ||
+        requestedPath.startsWith('\\'))
+        throw new Error('FILE_PATH_ESCAPE');
+    const normalized = requestedPath.replaceAll('\\', '/');
+    if (normalized.split('/').some((segment) => segment === '..' || segment === '.git'))
+        throw new Error('FILE_PATH_ESCAPE');
+    const root = await realpath(workspaceRoot);
+    let candidate;
+    try {
+        candidate = await realpath(resolve(root, normalized));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new Error('FILE_NOT_FOUND');
+        throw error;
+    }
+    const pathToCandidate = relative(root, candidate);
+    if (pathToCandidate.startsWith('..') ||
+        pathToCandidate === '..' ||
+        pathToCandidate.startsWith(`..${sep}`))
+        throw new Error('FILE_PATH_ESCAPE');
+    assertNotPrivate(candidate, options.privateRoots);
+    const metadata = await lstat(candidate);
+    if (directory ? !metadata.isDirectory() : !metadata.isFile() && !metadata.isDirectory())
+        throw new Error(directory ? 'FILE_NOT_DIRECTORY' : 'FILE_NOT_REGULAR');
+    return candidate;
+}
+function assertNotPrivate(candidate, privateRoots) {
+    if (privateRoots?.some((privateRoot) => isSameOrDescendant(privateRoot, candidate)))
+        throw new Error('FILE_PATH_ESCAPE');
+}
+function isSameOrDescendant(root, candidate) {
+    const relativePath = relative(root, candidate);
+    return (relativePath === '' || (!relativePath.startsWith('..') && !relativePath.startsWith(`..${sep}`)));
+}
+function encodeDirectoryCursor(path, name) {
+    return Buffer.from(JSON.stringify({ path, name })).toString('base64url');
+}
+function decodeDirectoryCursor(cursor, expectedPath) {
+    if (cursor === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (typeof value !== 'object' ||
+            value === null ||
+            value.path !== expectedPath ||
+            typeof value.name !== 'string')
+            throw new Error();
+        return value.name;
+    }
+    catch {
+        throw new Error('DIRECTORY_CURSOR_INVALID');
+    }
+}
+function encodeSearchCursor(query, path) {
+    return Buffer.from(JSON.stringify({ query, path })).toString('base64url');
+}
+function decodeSearchCursor(cursor, expectedQuery) {
+    if (cursor === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (typeof value !== 'object' ||
+            value === null ||
+            value.query !== expectedQuery ||
+            typeof value.path !== 'string')
+            throw new Error();
+        return value.path;
+    }
+    catch {
+        throw new Error('DIRECTORY_CURSOR_INVALID');
+    }
+}
+export function normalizeWorkspacePath(input, platform = hostPlatform()) {
+    if (input.length === 0 || input.includes('\u0000')) {
+        throw new Error('WORKSPACE_PATH_INVALID');
+    }
+    if (platform === 'win32') {
+        // Device paths bypass normal Win32 resolution and must never be accepted.
+        if (/^\\\\[?.]/.test(input)) {
+            throw new Error('WORKSPACE_DEVICE_PATH_REJECTED');
+        }
+        const normalized = win32.normalize(input.replaceAll('/', '\\'));
+        if (!win32.isAbsolute(normalized)) {
+            throw new Error('WORKSPACE_PATH_NOT_ABSOLUTE');
+        }
+        return normalized.replace(/\\+$/, '').toLowerCase();
+    }
+    if (platform !== 'linux') {
+        throw new Error('WORKSPACE_PLATFORM_UNSUPPORTED');
+    }
+    const normalized = posix.normalize(input);
+    if (!posix.isAbsolute(normalized)) {
+        throw new Error('WORKSPACE_PATH_NOT_ABSOLUTE');
+    }
+    return normalized === '/' ? normalized : normalized.replace(/\/+$/, '');
+}
+export function isWithinAllowedRoot(target, roots, platform = hostPlatform()) {
+    const normalizedTarget = normalizeWorkspacePath(target, platform);
+    const pathApi = platform === 'win32' ? win32 : posix;
+    return roots.some((root) => {
+        const normalizedRoot = normalizeWorkspacePath(root, platform);
+        const relative = pathApi.relative(normalizedRoot, normalizedTarget);
+        return relative === '' || (!relative.startsWith('..') && !pathApi.isAbsolute(relative));
+    });
+}
+/** Resolving both candidate and roots rejects Linux symlinks which point outside a root. */
+export async function inspectWorkspace(requestedPath, allowedRoots) {
+    const resolvedPath = await realpath(requestedPath);
+    const resolvedRoots = await Promise.all(allowedRoots.map((root) => realpath(root)));
+    const directory = await stat(resolvedPath);
+    if (!directory.isDirectory() || !isWithinAllowedRoot(resolvedPath, resolvedRoots)) {
+        throw new Error('WORKSPACE_NOT_ALLOWED');
+    }
+    try {
+        const summary = await readGitSummary(resolvedPath);
+        return { path: resolvedPath, kind: 'GIT_WORKSPACE', gitSummary: summary };
+    }
+    catch (error) {
+        if ((error instanceof GitCommandError && error.code === 128) || isGitUnavailable(error)) {
+            return { path: resolvedPath, kind: 'DIRECTORY' };
+        }
+        throw error;
+    }
+}
+export async function readGitSummary(workspacePath) {
+    const commonDir = (await runGit(workspacePath, ['rev-parse', '--git-common-dir'])).text.trim();
+    const head = (await runGit(workspacePath, ['rev-parse', '--verify', 'HEAD'])).text.trim();
+    const branchResult = await runGitAllowFailure(workspacePath, [
+        'symbolic-ref',
+        '--quiet',
+        '--short',
+        'HEAD'
+    ]);
+    const dirty = (await runGit(workspacePath, ['status', '--porcelain=v1', '-z'])).output.length > 0;
+    const snapshotOutput = await runGit(workspacePath, ['status', '--porcelain=v1']).then((result) => result.text);
+    return {
+        commonDir,
+        head,
+        branch: branchResult.code === 0 ? branchResult.text.trim() : null,
+        dirty,
+        snapshot: summarizeText(snapshotOutput)
+    };
+}
+export function assertSafeGitRef(ref) {
+    if (!REF_PATTERN.test(ref)) {
+        throw new Error('GIT_REF_INVALID');
+    }
+}
+export async function readRestrictedDiff(workspacePath, fromRef, toRef) {
+    assertSafeGitRef(fromRef);
+    assertSafeGitRef(toRef);
+    const result = await runGit(workspacePath, [
+        'diff',
+        '--no-ext-diff',
+        '--no-textconv',
+        fromRef,
+        toRef
+    ]);
+    const binary = result.output.includes(0) || result.text.includes('Binary files ');
+    if (binary) {
+        return {
+            binary: true,
+            summary: `binary diff sha256=${createHash('sha256').update(result.output).digest('hex')} bytes=${result.output.length}`,
+            truncated: result.truncated
+        };
+    }
+    return { binary: false, text: result.text, truncated: result.truncated };
+}
+function currentBranchFromStatusHeader(header) {
+    const value = header.slice(3);
+    if (value.startsWith('HEAD '))
+        return null;
+    const unborn = /^(?:No commits yet on|Initial commit on) (.+)$/.exec(value);
+    if (unborn !== null)
+        return unborn[1] ?? null;
+    return value.split('...')[0]?.split(' ')[0] ?? null;
+}
+export async function readCurrentChangesSummary(workspacePath) {
+    const result = await runGit(workspacePath, [
+        'status',
+        '--porcelain=v1',
+        '-z',
+        '--branch',
+        '--untracked-files=all'
+    ]);
+    const records = result.text.split('\0');
+    const header = records.shift() ?? '';
+    const output = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        if (record.length < 4)
+            continue;
+        const indexState = record[0];
+        const worktreeState = record[1];
+        const path = record.slice(3);
+        if (indexState === '?' && worktreeState === '?') {
+            output.push({ path, state: 'UNTRACKED', change: 'ADDED' });
+            continue;
+        }
+        if (indexState !== ' ') {
+            output.push({ path, state: 'STAGED', change: gitChange(indexState) });
+        }
+        if (worktreeState !== ' ') {
+            output.push({ path, state: 'UNSTAGED', change: gitChange(worktreeState) });
+        }
+        // Porcelain v1 -z emits a second NUL-delimited source path for rename
+        // and copy records. It is metadata for the same entry, never another
+        // status record.
+        if (indexState === 'R' || indexState === 'C' || worktreeState === 'R' || worktreeState === 'C')
+            index += 1;
+    }
+    return {
+        branch: header.startsWith('## ') ? currentBranchFromStatusHeader(header) : null,
+        changes: output
+    };
+}
+export async function readCurrentChanges(workspacePath) {
+    return (await readCurrentChangesSummary(workspacePath)).changes;
+}
+export async function readCurrentChangeDiff(workspacePath, requestedPath) {
+    const path = safeGitWorkspacePath(requestedPath);
+    const result = await runGit(workspacePath, [
+        'diff',
+        '--no-ext-diff',
+        '--no-textconv',
+        'HEAD',
+        '--',
+        `:(literal)${path}`
+    ]);
+    const after = await readWorkingTreeText(workspacePath, path);
+    const binary = result.output.includes(0) || result.text.includes('Binary files ') || after?.binary === true;
+    if (binary) {
+        return {
+            binary: true,
+            summary: `binary diff sha256=${createHash('sha256').update(result.output).digest('hex')} bytes=${result.output.length}`,
+            truncated: result.truncated || after?.truncated === true
+        };
+    }
+    return {
+        binary: false,
+        text: result.text,
+        truncated: result.truncated || after?.truncated === true,
+        afterText: after?.text ?? '',
+        ...(after === undefined ? {} : { afterTruncated: after.truncated })
+    };
+}
+async function readWorkingTreeText(workspacePath, path) {
+    const root = await realpath(workspacePath);
+    let file;
+    try {
+        file = await resolveWorkspaceEntry(root, path, false);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'FILE_NOT_FOUND')
+            return undefined;
+        throw error;
+    }
+    const source = await readFile(file);
+    return diffTextFromBuffer(source, source.length > GIT_OUTPUT_LIMIT);
+}
+function diffTextFromBuffer(source, truncated) {
+    if (source.includes(0) || !isValidUtf8(source))
+        return { binary: true, truncated };
+    let end = Math.min(source.length, GIT_OUTPUT_LIMIT);
+    while (end > 0 && end < source.length && isUtf8ContinuationByte(source[end]))
+        end -= 1;
+    return { binary: false, text: source.subarray(0, end).toString('utf8'), truncated };
+}
+export async function restoreCurrentChange(workspacePath, requestedPath, state, options = {}) {
+    const path = safeGitWorkspacePath(requestedPath);
+    const pathspec = `:(literal)${path}`;
+    if (state === 'UNTRACKED') {
+        const status = await runGit(workspacePath, [
+            'status',
+            '--porcelain=v1',
+            '-z',
+            '--untracked-files=all',
+            '--',
+            pathspec
+        ]);
+        if (!status.text
+            .split('\0')
+            .some((record) => record.startsWith('?? ') && record.slice(3) === path))
+            throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
+        const root = await realpath(workspacePath);
+        const file = resolve(root, path);
+        assertNotPrivate(file, options.privateRoots);
+        const metadata = await lstat(file);
+        if (!metadata.isFile() || metadata.isSymbolicLink())
+            throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
+        await unlink(file);
+        return;
+    }
+    if (state === 'UNSTAGED') {
+        await runGit(workspacePath, ['restore', '--worktree', '--', pathspec]);
+        return;
+    }
+    await runGit(workspacePath, [
+        'restore',
+        '--source=HEAD',
+        '--staged',
+        '--worktree',
+        '--',
+        pathspec
+    ]);
+}
+function safeGitWorkspacePath(requestedPath) {
+    if (requestedPath.length === 0 ||
+        requestedPath.includes('\0') ||
+        requestedPath.startsWith('/') ||
+        requestedPath.startsWith('\\'))
+        throw new Error('FILE_PATH_ESCAPE');
+    const normalized = requestedPath.replaceAll('\\', '/');
+    if (normalized
+        .split('/')
+        .some((segment) => segment === '' || segment === '..' || segment === '.git'))
+        throw new Error('FILE_PATH_ESCAPE');
+    return normalized;
+}
+function gitChange(status) {
+    if (status === 'A')
+        return 'ADDED';
+    if (status === 'D')
+        return 'DELETED';
+    if (status === 'R')
+        return 'RENAMED';
+    if (status === 'C')
+        return 'COPIED';
+    if (status === 'T')
+        return 'TYPE_CHANGED';
+    return 'MODIFIED';
+}
+export class GitCommandError extends Error {
+    code;
+    stderr;
+    constructor(code, stderr) {
+        super('GIT_COMMAND_FAILED');
+        this.code = code;
+        this.stderr = stderr;
+    }
+}
+async function runGit(workspacePath, args) {
+    const result = await runGitAllowFailure(workspacePath, args);
+    if (result.code !== 0) {
+        throw new GitCommandError(result.code, result.stderr);
+    }
+    return result;
+}
+async function runGitAllowFailure(workspacePath, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', [...args], {
+            cwd: workspacePath,
+            shell: false,
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const chunks = [];
+        const errors = [];
+        let size = 0;
+        let truncated = false;
+        const timer = setTimeout(() => child.kill('SIGKILL'), GIT_TIMEOUT_MS);
+        child.stdout.on('data', (chunk) => {
+            if (size < GIT_OUTPUT_LIMIT) {
+                const retained = chunk.subarray(0, Math.max(0, GIT_OUTPUT_LIMIT - size));
+                chunks.push(retained);
+                size += retained.length;
+            }
+            truncated ||= size >= GIT_OUTPUT_LIMIT;
+        });
+        child.stderr.on('data', (chunk) => errors.push(chunk.subarray(0, 4096)));
+        child.once('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once('close', (code) => {
+            clearTimeout(timer);
+            const output = Buffer.concat(chunks);
+            resolve({
+                code: code ?? 1,
+                output,
+                text: output.toString('utf8'),
+                stderr: Buffer.concat(errors).toString('utf8'),
+                truncated
+            });
+        });
+    });
+}
+function isGitUnavailable(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}
+function summarizeText(value) {
+    return JSON.stringify({
+        sha256: createHash('sha256').update(value).digest('hex'),
+        bytes: Buffer.byteLength(value)
+    });
+}
+//# sourceMappingURL=workspace.js.map