@playcraft/cli 0.1.17 → 0.1.19

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

@@ -1,354 +0,0 @@
-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, fileSnapshotContentKey, nativeTranscriptKey, fileSnapshotManifestSchema, hashSnapshotBytes, isDisposableBackupPath, isWorkspaceAttachmentPath, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { UNPUSHED_BUNDLE, addBundleObjects, repositoryResolves } from './git.js';
-const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
-/** Build output, caches and scratch folders, at any depth: regenerated, so not kept in storage. */
-const UNSTORED_DIRECTORY_NAMES = new Set([
-    'dist',
-    'dist-all',
-    'coverage',
-    '.vite',
-    '.cache',
-    '.turbo',
-    '.parcel-cache',
-    '.sass-cache',
-    '.next',
-    '.nuxt',
-    '.svelte-kit',
-    'tmp',
-    '.tmp',
-    '.temp',
-]);
-/** Scratch and cache files, at any depth. */
-const UNSTORED_FILE = /(?:\.tmp|\.log|\.tsbuildinfo|^\.eslintcache)$/;
-/**
- * At the workspace root: the preview build's output, the builder's scratch folder, and skill
- * artifacts the sandbox pulls from the registry by `.playcraft/skills.lock.json`.
- */
-const UNSTORED_ROOT_DIRECTORIES = [
-    '.playcraft-preview-out/',
-    '.playcraft-temp/',
-    '.playcraft/skills/',
-    'ta-workspace/logs/',
-];
-/**
- * Recordings, frames and reports the template's verify and record scripts write again on each run.
- * The ring JSON evidence the build gate reads stays, as do the agent-edited profile and catalogs.
- */
-const UNSTORED_RUN_OUTPUT = [
-    /^recordings\/(?:.+\.(?:mp4|webm)$|\.tmp-[^/]+\/|focus\/|clean\/)/,
-    /^validate\/(?:[^/]+\.md$|(?:ring\d+\/)?frames\/|ring\d+\/[^/]+\.mp4$)/,
-];
-/**
- * Whether a path goes to checkpoint storage. Credentials, lock files, build output, caches and
- * scratch files stay in the instance: its local copy keeps them, so restoring inside the instance
- * does not remove them.
- */
-export function keptInStorage(path) {
-    if (isWorkspaceAttachmentPath(path))
-        return true;
-    if (isDisposableBackupPath(path))
-        return false;
-    if (path.startsWith('.git/'))
-        return true;
-    if (UNSTORED_ROOT_DIRECTORIES.some((prefix) => path.startsWith(prefix)))
-        return false;
-    if (UNSTORED_RUN_OUTPUT.some((pattern) => pattern.test(path)))
-        return false;
-    const segments = path.split('/');
-    if (UNSTORED_FILE.test(segments[segments.length - 1]))
-        return false;
-    return !segments.slice(0, -1).some((segment) => UNSTORED_DIRECTORY_NAMES.has(segment));
-}
-/**
- * Under `.git/`, what a `local` capture leaves to the remote: packs and their indexes, submodule
- * repositories (`git submodule update` fetches them again), LFS objects, and template hooks.
- */
-const REMOTE_GIT_DIRECTORIES = new Set([
-    '.git/objects/pack',
-    '.git/objects/info',
-    '.git/modules',
-    '.git/lfs',
-    '.git/hooks',
-]);
-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, options = {}) {
-    const entries = [];
-    const files = [];
-    const bodies = new Map();
-    const seen = new Set();
-    let status = 'complete';
-    const skip = (relativePath, name, directory) => {
-        if (name === '.' || name === '..')
-            return true;
-        if (directory && name === '.git')
-            return !(options.git && relativePath === '.git');
-        // A submodule's `.git` file points into `.git/modules`, which is not kept either.
-        if (!directory && name === '.git' && relativePath !== '.git')
-            return true;
-        if (directory && SKIP_DIRECTORY_NAMES.has(name))
-            return true;
-        if (directory && options.git === 'local' && REMOTE_GIT_DIRECTORIES.has(relativePath))
-            return true;
-        // Git's own lock files only exist while a command runs and must not come back with a restore.
-        return !directory && relativePath.startsWith('.git/') && name.endsWith('.lock');
-    };
-    await walk(root, root, io, revisions, entries, files, bodies, seen, skip, () => {
-        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');
-    }
-    if (applicable.some((entry) => entry.path === '.git/HEAD')) {
-        const bundle = applicable.find((entry) => entry.path === UNPUSHED_BUNDLE && entry.kind === 'file');
-        if (bundle)
-            await addBundleObjects(rootReal, Buffer.from(bundle.contentBase64 ?? '', 'base64'));
-        await clearClonedGitMetadata(rootReal);
-    }
-    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: isWorkspaceAttachmentPath(entry.path) ? 0o755 : 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);
-    }
-    return {
-        skipped,
-        directoryReady: true,
-        repositoryReady: await repositoryResolves(rootReal),
-        environmentReady: false,
-    };
-}
-/**
- * The snapshot's `.git` replaces the one a new clone made, objects aside: a ref the clone wrote
- * would otherwise outrank the snapshot's packed refs.
- */
-async function clearClonedGitMetadata(rootReal) {
-    const gitDir = join(rootReal, '.git');
-    const info = await lstat(gitDir).catch(() => undefined);
-    if (!info?.isDirectory())
-        return;
-    for (const name of await readdir(gitDir)) {
-        if (name !== 'objects')
-            await rm(join(gitDir, name), { recursive: true, force: true });
-    }
-}
-/**
- * Content goes to the workspace's shared objects, keyed by hash. A hash in `uploaded` was stored by
- * this process before and is not sent again; hashes stored now are added to it. The manifest still
- * lists every stored file, so each snapshot restores on its own. Paths not `keptInStorage` are left
- * out of both the objects and the manifest.
- */
-export async function publishFileSnapshot(input) {
-    const stored = new Set();
-    const entries = input.tree.entries.filter((entry) => keptInStorage(entry.path));
-    for (const entry of entries) {
-        if (entry.kind !== 'file' || !entry.contentHash)
-            continue;
-        if (input.uploaded?.has(entry.contentHash) || stored.has(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, fileSnapshotContentKey(input.workspaceId, entry.contentHash), body, 'cli', input.headers);
-        stored.add(entry.contentHash);
-    }
-    const native = [];
-    for (const transcript of input.native ?? []) {
-        const contentHash = hashSnapshotBytes(transcript.body);
-        if (input.uploadedTranscripts?.get(transcript.path) !== contentHash) {
-            await putObjectBytes(input.baseUrl, nativeTranscriptKey(input.workspaceId, transcript.path), transcript.body, 'cli', input.headers);
-            input.uploadedTranscripts?.set(transcript.path, contentHash);
-        }
-        native.push({
-            sessionId: transcript.sessionId,
-            threadId: transcript.threadId,
-            path: transcript.path,
-            contentHash,
-            size: transcript.body.byteLength,
-            capturedAt: transcript.capturedAt,
-        });
-    }
-    const digest = fileSnapshotDigest(entries);
-    const manifest = fileSnapshotManifestSchema.parse({
-        snapshotId: input.snapshotId,
-        workspaceId: input.workspaceId,
-        generation: input.generation,
-        status: input.tree.status,
-        entries,
-        digest,
-        objectLayout: 'workspace',
-        ...(native.length > 0 ? { native } : {}),
-    });
-    const manifestKey = fileSnapshotManifestKey(input.workspaceId, input.generation, input.snapshotId);
-    await putObjectBytes(input.baseUrl, manifestKey, Buffer.from(JSON.stringify(manifest)), 'cli', input.headers);
-    for (const hash of stored)
-        input.uploaded?.add(hash);
-    return { manifestKey, checksum: digest, status: input.tree.status };
-}
-/**
- * Digest of what is on disk now, without the deletions recorded against the previous snapshot.
- * Transcripts count too: a turn that only talked still changes what a restore can resume.
- */
-export function liveTreeDigest(tree, native = []) {
-    const files = fileSnapshotDigest(tree.entries.filter((entry) => entry.kind !== 'deleted'));
-    if (native.length === 0)
-        return files;
-    const transcripts = native
-        .map((item) => `${item.sessionId}:${item.threadId}:${item.path}:${hashSnapshotBytes(item.body)}`)
-        .sort();
-    return hashSnapshotBytes(Buffer.from([files, ...transcripts].join('\n')));
-}
-async function walk(rootReal, current, io, revisions, entries, files, bodies, seen, skip, markIncomplete) {
-    const listed = await io.readdir(current);
-    for (const entry of listed) {
-        const child = join(current, entry.name);
-        const relativePath = toPosixRelative(rootReal, child);
-        if (skip(relativePath, entry.name, entry.isDirectory()))
-            continue;
-        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, skip, 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('/');
-}