@playcraft/cli 0.0.57 → 0.0.59

package/dist/workspace-runtime/server/lock.js

@@ -0,0 +1,53 @@
+import { closeSync, constants, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export class RuntimeProcessLock {
+    filePath;
+    fd = null;
+    constructor(stateDir) {
+        this.filePath = join(stateDir, 'workspace-runtime.lock');
+    }
+    acquire() {
+        mkdirSync(dirname(this.filePath), { recursive: true, mode: 0o700 });
+        try {
+            this.fd = openSync(this.filePath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+            writeFileSync(this.fd, String(process.pid));
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        const existing = Number.parseInt(readFileSync(this.filePath, 'utf8'), 10);
+        if (Number.isInteger(existing) && processAlive(existing)) {
+            throw Object.assign(new Error(`workspace-runtime already running as pid ${existing}`), {
+                code: 'duplicate_instance',
+            });
+        }
+        unlinkSync(this.filePath);
+        this.acquire();
+    }
+    release() {
+        if (this.fd !== null) {
+            closeSync(this.fd);
+            this.fd = null;
+        }
+        try {
+            if (readFileSync(this.filePath, 'utf8').trim() === String(process.pid)) {
+                unlinkSync(this.filePath);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/workspace-runtime/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workspace-runtime/workspaces/context-error.js

@@ -0,0 +1,2 @@
+export class WorkspaceContextError extends Error {
+}

package/dist/workspace-runtime/workspaces/file-snapshot.js

@@ -0,0 +1,213 @@
+import { chmod, lstat, mkdir, readdir, readFile, readlink, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { fileSnapshotDigest, fileSnapshotManifestKey, fileSnapshotManifestSchema, fileSnapshotObjectKey, hashSnapshotBytes, isDisposableBackupPath, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
+const READ_ATTEMPTS = 3;
+const realIo = {
+    async readdir(path) {
+        return readdir(path, { withFileTypes: true });
+    },
+    async lstat(path) {
+        return lstat(path);
+    },
+    readFile,
+    readlink,
+};
+export async function captureWorkspaceTree(root, previousPaths, revisions, io = realIo) {
+    const entries = [];
+    const files = [];
+    const bodies = new Map();
+    const seen = new Set();
+    let status = 'complete';
+    await walk(root, root, io, revisions, entries, files, bodies, seen, () => {
+        status = 'incomplete';
+    });
+    for (const path of [...previousPaths].sort((left, right) => left.localeCompare(right))) {
+        if (seen.has(path) || !workspaceRelativePathSchema.safeParse(path).success)
+            continue;
+        entries.push({ path, kind: 'deleted' });
+    }
+    entries.sort((left, right) => left.path.localeCompare(right.path) || left.kind.localeCompare(right.kind));
+    return { status, entries, files, bodies };
+}
+export async function materializeSnapshot(snapshotDir, tree) {
+    await rm(snapshotDir, { recursive: true, force: true });
+    for (const file of tree.files) {
+        const body = tree.bodies.get(file.path);
+        if (!body || hashSnapshotBytes(body) !== file.contentHash)
+            throw new Error('snapshot_body_missing');
+        const target = join(snapshotDir, ...file.path.split('/'));
+        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+        await writeFile(target, body, { mode: 0o600 });
+    }
+}
+export async function materializeRemoteSnapshot(root, entries) {
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const rootReal = await realpath(root);
+    const skipped = [];
+    const applicable = [];
+    for (const entry of entries) {
+        if (isDisposableBackupPath(entry.path)) {
+            skipped.push(entry.path);
+            continue;
+        }
+        applicable.push(entry);
+    }
+    for (const entry of applicable) {
+        if (entry.kind !== 'file')
+            continue;
+        if (!entry.contentBase64 || !entry.contentHash)
+            throw new Error('snapshot_mismatch');
+        const body = Buffer.from(entry.contentBase64, 'base64');
+        if (hashSnapshotBytes(body) !== entry.contentHash)
+            throw new Error('snapshot_mismatch');
+    }
+    for (const entry of applicable) {
+        const target = resolve(rootReal, ...entry.path.split('/'));
+        const rel = relative(rootReal, target);
+        if (rel === '' || rel.startsWith(`..${sep}`) || rel === '..' || rel.startsWith('..')) {
+            throw new Error('snapshot_mismatch');
+        }
+        if (entry.kind === 'deleted') {
+            await rm(target, { force: true });
+            continue;
+        }
+        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+        if (entry.kind === 'symlink') {
+            if (!entry.target)
+                throw new Error('snapshot_mismatch');
+            await rm(target, { force: true });
+            await symlink(entry.target, target);
+            continue;
+        }
+        const body = Buffer.from(entry.contentBase64 ?? '', 'base64');
+        await writeFile(target, body, { mode: entry.mode ?? 0o600 });
+        if (entry.mode !== undefined)
+            await chmod(target, entry.mode);
+    }
+    let repositoryReady = false;
+    try {
+        const git = await lstat(join(rootReal, '.git'));
+        repositoryReady = git.isDirectory() && !git.isSymbolicLink();
+    }
+    catch {
+        repositoryReady = false;
+    }
+    return {
+        skipped,
+        directoryReady: true,
+        repositoryReady,
+        environmentReady: false,
+    };
+}
+export async function publishFileSnapshot(input) {
+    for (const entry of input.tree.entries) {
+        if (entry.kind !== 'file' || !entry.contentHash)
+            continue;
+        const body = input.tree.bodies.get(entry.path);
+        if (!body || hashSnapshotBytes(body) !== entry.contentHash)
+            throw new Error('snapshot_body_missing');
+        await putObjectBytes(input.baseUrl, fileSnapshotObjectKey(input.workspaceId, input.generation, input.snapshotId, entry.contentHash), body, 'cli');
+    }
+    const digest = fileSnapshotDigest(input.tree.entries);
+    const manifest = fileSnapshotManifestSchema.parse({
+        snapshotId: input.snapshotId,
+        workspaceId: input.workspaceId,
+        generation: input.generation,
+        status: input.tree.status,
+        entries: input.tree.entries,
+        digest,
+    });
+    const manifestKey = fileSnapshotManifestKey(input.workspaceId, input.generation, input.snapshotId);
+    await putObjectBytes(input.baseUrl, manifestKey, Buffer.from(JSON.stringify(manifest)), 'cli');
+    return { manifestKey, checksum: digest, status: input.tree.status };
+}
+async function walk(rootReal, current, io, revisions, entries, files, bodies, seen, markIncomplete) {
+    const listed = await io.readdir(current);
+    for (const entry of listed) {
+        if (entry.name === '.' || entry.name === '..' || SKIP_DIRECTORY_NAMES.has(entry.name))
+            continue;
+        const child = join(current, entry.name);
+        const relativePath = toPosixRelative(rootReal, child);
+        if (!workspaceRelativePathSchema.safeParse(relativePath).success) {
+            markIncomplete();
+            continue;
+        }
+        if (entry.isSymbolicLink()) {
+            const sampled = await sampleLink(child, io);
+            seen.add(relativePath);
+            if (!sampled) {
+                markIncomplete();
+                entries.push({ path: relativePath, kind: 'symlink' });
+                continue;
+            }
+            entries.push({ path: relativePath, kind: 'symlink', mode: sampled.mode, target: sampled.target });
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await walk(rootReal, child, io, revisions, entries, files, bodies, seen, markIncomplete);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const sampled = await sampleFile(child, io);
+        seen.add(relativePath);
+        if (!sampled) {
+            markIncomplete();
+            entries.push({ path: relativePath, kind: 'file' });
+            continue;
+        }
+        const record = {
+            path: relativePath,
+            contentHash: sampled.hash,
+            revision: revisions[relativePath]?.revision ?? 0,
+        };
+        entries.push({
+            path: relativePath,
+            kind: 'file',
+            mode: sampled.mode,
+            contentHash: sampled.hash,
+            size: sampled.body.byteLength,
+        });
+        files.push(record);
+        bodies.set(relativePath, sampled.body);
+    }
+}
+async function sampleFile(path, io) {
+    let previous;
+    for (let attempt = 0; attempt < READ_ATTEMPTS; attempt += 1) {
+        try {
+            const body = await io.readFile(path);
+            const mode = (await io.lstat(path)).mode & 0o777;
+            const hash = hashSnapshotBytes(body);
+            if (previous && previous.hash === hash && previous.mode === mode)
+                return { body, mode, hash };
+            previous = { hash, mode, body };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+async function sampleLink(path, io) {
+    let previous;
+    for (let attempt = 0; attempt < READ_ATTEMPTS; attempt += 1) {
+        try {
+            const target = await io.readlink(path);
+            const mode = (await io.lstat(path)).mode & 0o777;
+            if (target.includes('\0') || target.length === 0 || target.length > 512)
+                return undefined;
+            if (previous && previous.target === target && previous.mode === mode)
+                return { mode, target };
+            previous = { mode, target };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function toPosixRelative(rootReal, target) {
+    return relative(rootReal, target).split(sep).join('/');
+}

package/dist/workspace-runtime/workspaces/files.js

@@ -0,0 +1,143 @@
+import { mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { hashWorkspaceFileContent, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
+export class InvalidWorkspacePathError extends Error {
+    code = 'invalid_workspace_path';
+    constructor(path) {
+        super(path);
+        this.name = 'InvalidWorkspacePathError';
+    }
+}
+export async function ensureWorkspaceRoot(root) {
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    return realpath(root);
+}
+export async function resolveWorkspaceFile(root, relativePath) {
+    const parsed = workspaceRelativePathSchema.safeParse(relativePath);
+    if (!parsed.success)
+        throw new InvalidWorkspacePathError(relativePath);
+    const rootReal = await ensureWorkspaceRoot(root);
+    const target = resolve(rootReal, ...parsed.data.split('/'));
+    assertInsideRoot(rootReal, target);
+    try {
+        const existing = await realpath(target);
+        assertInsideRoot(rootReal, existing);
+        return existing;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        await assertParentInsideRoot(rootReal, dirname(target));
+        return target;
+    }
+}
+export async function writeWorkspaceFile(root, relativePath, content) {
+    const target = await resolveWorkspaceFile(root, relativePath);
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    const bytes = Buffer.from(content, 'utf8');
+    await writeFile(target, bytes, { mode: 0o600 });
+    return { path: relativePath, contentHash: hashWorkspaceFileContent(content), size: bytes.byteLength };
+}
+export async function readWorkspaceFile(root, relativePath, revisions) {
+    const target = await resolveWorkspaceFile(root, relativePath);
+    const content = await readFile(target, 'utf8');
+    const contentHash = hashWorkspaceFileContent(content);
+    return workspaceFileContentSchema.parse({
+        path: relativePath,
+        revision: revisions[relativePath]?.revision ?? 0,
+        contentHash,
+        content,
+    });
+}
+export async function listWorkspaceFiles(root, revisions) {
+    const rootReal = await ensureWorkspaceRoot(root);
+    const files = [];
+    for (const relativePath of await walkWorkspaceFiles(rootReal, rootReal)) {
+        const target = join(rootReal, ...relativePath.split('/'));
+        const content = await readFile(target, 'utf8');
+        files.push({
+            path: relativePath,
+            revision: revisions[relativePath]?.revision ?? 0,
+            contentHash: hashWorkspaceFileContent(content),
+            size: Buffer.byteLength(content, 'utf8'),
+        });
+    }
+    files.sort((left, right) => left.path.localeCompare(right.path));
+    return workspaceFileListSchema.parse({ files });
+}
+export async function snapshotWorkspaceFiles(root, snapshotDir, revisions) {
+    const listed = await listWorkspaceFiles(root, revisions);
+    await rm(snapshotDir, { recursive: true, force: true });
+    const records = [];
+    for (const file of listed.files) {
+        const content = await readWorkspaceFile(root, file.path, revisions);
+        const target = join(snapshotDir, ...file.path.split('/'));
+        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+        await writeFile(target, content.content, { mode: 0o600 });
+        records.push({ path: file.path, contentHash: file.contentHash, revision: file.revision });
+    }
+    return records;
+}
+export async function restoreWorkspaceFiles(root, snapshotDir, files) {
+    const rootReal = await ensureWorkspaceRoot(root);
+    const keep = new Set(files.map((item) => item.path));
+    for (const relativePath of await walkWorkspaceFiles(rootReal, rootReal)) {
+        if (!keep.has(relativePath)) {
+            await rm(join(rootReal, ...relativePath.split('/')), { force: true });
+        }
+    }
+    const next = {};
+    for (const file of files) {
+        const source = join(snapshotDir, ...file.path.split('/'));
+        const content = await readFile(source, 'utf8');
+        await writeWorkspaceFile(root, file.path, content);
+        next[file.path] = { revision: file.revision, contentHash: hashWorkspaceFileContent(content) };
+    }
+    return next;
+}
+async function walkWorkspaceFiles(rootReal, current) {
+    const entries = await readdir(current, { withFileTypes: true });
+    const paths = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (SKIP_DIRECTORY_NAMES.has(entry.name) || entry.name === '.' || entry.name === '..')
+                continue;
+            const child = join(current, entry.name);
+            const childReal = await realpath(child);
+            assertInsideRoot(rootReal, childReal);
+            paths.push(...(await walkWorkspaceFiles(rootReal, childReal)));
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const childReal = await realpath(join(current, entry.name));
+        assertInsideRoot(rootReal, childReal);
+        paths.push(toPosixRelative(rootReal, childReal));
+    }
+    return paths;
+}
+async function assertParentInsideRoot(rootReal, parent) {
+    if (parent === rootReal)
+        return;
+    try {
+        const parentReal = await realpath(parent);
+        assertInsideRoot(rootReal, parentReal);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        await mkdir(parent, { recursive: true, mode: 0o700 });
+        const parentReal = await realpath(parent);
+        assertInsideRoot(rootReal, parentReal);
+    }
+}
+function assertInsideRoot(rootReal, target) {
+    const rel = relative(rootReal, target);
+    if (rel === '' || rel.startsWith(`..${sep}`) || rel === '..' || rel.startsWith('..')) {
+        throw new InvalidWorkspacePathError(target);
+    }
+}
+function toPosixRelative(rootReal, target) {
+    return relative(rootReal, target).split(sep).join('/');
+}

package/dist/workspace-runtime/workspaces/git.js

@@ -0,0 +1,242 @@
+import { spawn } from 'node:child_process';
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, relative, resolve, sep } from 'node:path';
+import { gitDiffSchema, gitGraphSchema, gitStatusSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+const GIT_DIFF_MAX_BYTES = 1024 * 1024;
+const GIT_PREFIX = [
+    '-c',
+    'core.hooksPath=/dev/null',
+    '-c',
+    'commit.gpgsign=false',
+    '-c',
+    'safe.directory=*',
+];
+export class GitWorkspaceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'GitWorkspaceError';
+    }
+}
+export async function probeGitBinary() {
+    try {
+        const result = await runGitProcess(tmpdir(), ['--version'], 4000);
+        return result.code === 0;
+    }
+    catch (error) {
+        return error instanceof GitWorkspaceError && error.code === 'git_binary_missing' ? false : false;
+    }
+}
+export async function readWorkspaceGitStatus(root) {
+    const rootReal = await ensureWorkspaceGit(root);
+    const branchResult = await gitAllowFail(rootReal, ['symbolic-ref', '--short', 'HEAD']);
+    const branch = branchResult.code === 0 ? branchResult.stdout.trim() || 'HEAD' : 'HEAD';
+    const upstream = await gitAllowFail(rootReal, ['rev-list', '--left-right', '--count', '@{upstream}...HEAD']);
+    let ahead = 0;
+    let behind = 0;
+    if (upstream.code === 0) {
+        const [left, right] = upstream.stdout.trim().split(/\s+/);
+        behind = Number.parseInt(left ?? '0', 10) || 0;
+        ahead = Number.parseInt(right ?? '0', 10) || 0;
+    }
+    const porcelain = await git(rootReal, ['status', '--porcelain=v1', '--untracked-files=all', '-z']);
+    return gitStatusSchema.parse({
+        initialized: true,
+        branch,
+        ahead,
+        behind,
+        hasUpstream: upstream.code === 0,
+        files: parsePorcelain(porcelain),
+    });
+}
+export async function readWorkspaceGitDiff(root) {
+    const rootReal = await ensureWorkspaceGit(root);
+    const vsHead = await gitAllowFail(rootReal, ['diff', '--no-color', 'HEAD']);
+    const patch = vsHead.code === 0
+        ? vsHead.stdout
+        : `${(await gitAllowFail(rootReal, ['diff', '--no-color'])).stdout}${(await gitAllowFail(rootReal, ['diff', '--no-color', '--cached'])).stdout}`;
+    if (Buffer.byteLength(patch, 'utf8') > GIT_DIFF_MAX_BYTES) {
+        throw new GitWorkspaceError('git_diff_too_large', '1MiB');
+    }
+    return gitDiffSchema.parse({ patch });
+}
+export async function readWorkspaceGitGraph(root) {
+    const rootReal = await ensureWorkspaceGit(root);
+    const log = await gitAllowFail(rootReal, ['log', '-n', '20', '--format=%H%x09%s%x09%cI']);
+    if (log.code !== 0)
+        return gitGraphSchema.parse({ commits: [] });
+    const commits = log.stdout
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0)
+        .map((line) => {
+        const [sha, subject, committedAt] = splitLogLine(line);
+        return {
+            sha,
+            subject: subject.length > 0 ? subject : '(empty)',
+            committedAt: committedAt.length > 0 ? committedAt : new Date(0).toISOString(),
+        };
+    });
+    return gitGraphSchema.parse({ commits });
+}
+function splitLogLine(line) {
+    const first = line.indexOf('\t');
+    if (first < 0)
+        return [line, '', ''];
+    const second = line.indexOf('\t', first + 1);
+    if (second < 0)
+        return [line.slice(0, first), line.slice(first + 1), ''];
+    return [line.slice(0, first), line.slice(first + 1, second), line.slice(second + 1)];
+}
+export async function commitWorkspaceGit(root, payload) {
+    const rootReal = await ensureWorkspaceGit(root);
+    if (payload.paths && payload.paths.length > 0) {
+        for (const relativePath of payload.paths) {
+            if (!workspaceRelativePathSchema.safeParse(relativePath).success) {
+                throw new GitWorkspaceError('invalid_workspace_path', relativePath);
+            }
+        }
+        await git(rootReal, ['add', '--', ...payload.paths]);
+    }
+    else {
+        await git(rootReal, ['add', '-A']);
+    }
+    const cached = await gitAllowFail(rootReal, ['diff', '--cached', '--quiet']);
+    if (cached.code === 0) {
+        throw new GitWorkspaceError('nothing_to_commit', payload.message);
+    }
+    await git(rootReal, ['commit', '-m', payload.message], 20000);
+    return (await git(rootReal, ['rev-parse', 'HEAD'])).trim();
+}
+export async function pushWorkspaceGit(root) {
+    const rootReal = await ensureWorkspaceGit(root);
+    const origin = await gitAllowFail(rootReal, ['remote', 'get-url', 'origin']);
+    if (origin.code !== 0) {
+        throw new GitWorkspaceError('remote_not_configured', 'origin');
+    }
+    const pushed = await gitAllowFail(rootReal, ['push', 'origin', 'HEAD'], 20000);
+    if (pushed.code !== 0) {
+        throw new GitWorkspaceError('git_command_failed', pushed.stderr.trim() || 'git_push_failed');
+    }
+}
+export async function ensureWorkspaceGit(root) {
+    const rootReal = await realpath(root);
+    if (!(await gitMarkerExists(rootReal))) {
+        const init = await gitAllowFail(rootReal, ['init']);
+        if (init.code !== 0) {
+            throw new GitWorkspaceError('git_command_failed', init.stderr.trim() || 'git_init_failed');
+        }
+        await git(rootReal, ['config', 'user.name', 'PlayCraft Workspace']);
+        await git(rootReal, ['config', 'user.email', 'workspace@playcraft.local']);
+    }
+    await assertWorkspaceGitRoot(rootReal);
+    return rootReal;
+}
+async function gitMarkerExists(rootReal) {
+    try {
+        await stat(join(rootReal, '.git'));
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function assertWorkspaceGitRoot(rootReal) {
+    const marker = join(rootReal, '.git');
+    const info = await stat(marker);
+    if (info.isDirectory()) {
+        assertInsideRoot(rootReal, await realpath(marker));
+        return;
+    }
+    if (info.isFile()) {
+        const text = await readFile(marker, 'utf8');
+        const match = /^gitdir:\s*(.+)$/m.exec(text);
+        if (!match)
+            throw new GitWorkspaceError('git_root_escape', 'invalid_gitdir');
+        const target = resolve(rootReal, match[1].trim());
+        assertInsideRoot(rootReal, await realpath(target));
+        return;
+    }
+    throw new GitWorkspaceError('git_root_escape', marker);
+}
+function assertInsideRoot(rootReal, target) {
+    const rel = relative(rootReal, target);
+    if (rel === '' || rel.startsWith(`..${sep}`) || rel === '..' || rel.startsWith('..')) {
+        throw new GitWorkspaceError('git_root_escape', target);
+    }
+}
+function parsePorcelain(raw) {
+    const parts = raw.split('\0').filter((part) => part.length > 0);
+    const files = [];
+    for (let i = 0; i < parts.length; i += 1) {
+        const entry = parts[i] ?? '';
+        if (entry.length < 3)
+            continue;
+        const indexStatus = entry[0] ?? ' ';
+        const worktreeStatus = entry[1] ?? ' ';
+        const pathPart = entry.slice(3);
+        if (indexStatus === 'R' || indexStatus === 'C' || worktreeStatus === 'R' || worktreeStatus === 'C') {
+            const dest = parts[i + 1] ?? pathPart;
+            i += 1;
+            files.push({ path: dest, indexStatus, worktreeStatus });
+            continue;
+        }
+        files.push({ path: pathPart, indexStatus, worktreeStatus });
+    }
+    return files;
+}
+async function git(root, args, timeoutMs = 15000) {
+    const result = await gitAllowFail(root, args, timeoutMs);
+    if (result.code !== 0) {
+        throw new GitWorkspaceError('git_command_failed', result.stderr.trim() || `git_exit_${result.code}`);
+    }
+    return result.stdout;
+}
+async function gitAllowFail(root, args, timeoutMs = 15000) {
+    return runGitProcess(root, [...GIT_PREFIX, `--git-dir=${join(root, '.git')}`, `--work-tree=${root}`, ...args], timeoutMs);
+}
+function gitEnv() {
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_COMMON_DIR;
+    delete env.GIT_INDEX_FILE;
+    delete env.GIT_OBJECT_DIRECTORY;
+    delete env.GIT_ALTERNATE_OBJECT_DIRECTORIES;
+    env.GIT_OPTIONAL_LOCKS = '0';
+    env.GIT_TERMINAL_PROMPT = '0';
+    return env;
+}
+function runGitProcess(cwd, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, env: gitEnv(), windowsHide: true });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            reject(new GitWorkspaceError('git_command_failed', 'timeout'));
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            if (error.code === 'ENOENT') {
+                reject(new GitWorkspaceError('git_binary_missing', 'git'));
+                return;
+            }
+            reject(error);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr, code: code ?? 1 });
+        });
+    });
+}