@playcraft/cli 0.1.53-beta → 0.1.54

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

@@ -1,471 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { constants, createWriteStream } from 'node:fs';
-import { chmod, copyFile, lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve, sep } from 'node:path';
-import { Transform } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { isCredentialFile } from './git.js';
-const EXCLUDED = new Set(['.git', 'node_modules', '.playcraft-workspace.json', '.playcraft.json']);
-const GIT_TIMEOUT_MS = 15 * 60_000;
-const GIT_OPTIONS = ['-c', 'core.hooksPath=/dev/null', '-c', 'commit.gpgsign=false', '-c', 'core.autocrlf=false',
-    '-c', 'user.name=PlayCraft Workspace', '-c', 'user.email=workspace@playcraft.local'];
-const SNAPSHOT_MESSAGE = 'PlayCraft workspace snapshot v1';
-export const RAW_ATTRIBUTES = '* -text -eol -working-tree-encoding -filter -ident\n';
-export class WorkspaceTransferError extends Error {
-    code;
-    details;
-    constructor(code, details) {
-        super(code);
-        this.code = code;
-        this.details = details;
-    }
-}
-function gitEnvironment() {
-    return { PATH: process.env.PATH, HOME: tmpdir(), GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null',
-        GIT_TERMINAL_PROMPT: '0', GIT_ALLOW_PROTOCOL: 'file', GIT_AUTHOR_NAME: 'PlayCraft Workspace',
-        GIT_AUTHOR_EMAIL: 'workspace@playcraft.local', GIT_COMMITTER_NAME: 'PlayCraft Workspace',
-        GIT_COMMITTER_EMAIL: 'workspace@playcraft.local', GIT_AUTHOR_DATE: '2000-01-01T00:00:00Z',
-        GIT_COMMITTER_DATE: '2000-01-01T00:00:00Z' };
-}
-function excluded(path) {
-    const parts = path.split('/');
-    return parts.some(part => EXCLUDED.has(part.toLowerCase()) || /^\.playcraft-(?:credential|transfer)-.*\.tmp$/i.test(part)) ||
-        parts.some((part, index) => part === '.playcraft' && /^(?:workspace-context(?:\..*)?|video-replication)$/.test(parts[index + 1] ?? '')) ||
-        isCredentialFile(path);
-}
-export function transferGit(root, args) {
-    const result = spawnSync('git', [...GIT_OPTIONS, ...args], { cwd: root, encoding: 'utf8', env: gitEnvironment(), timeout: GIT_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024 });
-    if (result.status !== 0) {
-        const code = result.error?.code;
-        throw new WorkspaceTransferError(code === 'ETIMEDOUT' ? 'workspace_transfer_git_timeout'
-            : code === 'ENOENT' ? 'workspace_transfer_git_missing' : 'workspace_transfer_git_failed');
-    }
-    return result.stdout.trim();
-}
-/** Large object operations write directly to disk and remain cancellable. */
-export async function runTransferGit(root, args, options = {}) {
-    options.signal?.throwIfAborted();
-    return new Promise((resolveResult, reject) => {
-        const child = spawn('git', [...GIT_OPTIONS, ...args], { cwd: root, env: gitEnvironment(), stdio: ['ignore', 'pipe', 'pipe'] });
-        let stdout = '', stderr = '', failure, timedOut = false;
-        const abort = () => { failure = options.signal?.reason ?? new Error('workspace_transfer_cancelled'); child.kill('SIGKILL'); };
-        const timeout = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, GIT_TIMEOUT_MS);
-        options.signal?.addEventListener('abort', abort, { once: true });
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
-        child.stdout.on('data', (chunk) => {
-            try {
-                if (options.onStdout)
-                    options.onStdout(chunk);
-                else {
-                    stdout += chunk;
-                    if (stdout.length > 8 * 1024 * 1024)
-                        throw new WorkspaceTransferError('workspace_transfer_git_output_too_large');
-                }
-            }
-            catch (error) {
-                failure = error;
-                child.kill('SIGKILL');
-            }
-        });
-        child.stderr.on('data', (chunk) => { if (stderr.length < 4096)
-            stderr += chunk.slice(0, 4096 - stderr.length); });
-        child.once('error', error => {
-            failure = new WorkspaceTransferError(error.code === 'ENOENT'
-                ? 'workspace_transfer_git_missing' : 'workspace_transfer_git_failed');
-        });
-        child.once('close', code => {
-            clearTimeout(timeout);
-            options.signal?.removeEventListener('abort', abort);
-            if (failure)
-                reject(failure);
-            else if (timedOut)
-                reject(new WorkspaceTransferError('workspace_transfer_git_timeout', { operation: args[0] }));
-            else if (code !== 0)
-                reject(new WorkspaceTransferError(/no space left|disk full/i.test(stderr)
-                    ? 'workspace_transfer_disk_full' : 'workspace_transfer_git_failed', { operation: args[0], exitCode: code }));
-            else
-                resolveResult(stdout.trim());
-        });
-    });
-}
-async function copySnapshot(source, target, signal, hashOnly = false) {
-    let bytes = 0, files = 0;
-    async function copy(directory, prefix) {
-        signal?.throwIfAborted();
-        const treeParts = [];
-        const directoryInfo = await lstat(directory);
-        const directoryReal = await realpath(directory);
-        if (!directoryInfo.isDirectory() || directoryInfo.isSymbolicLink() ||
-            (directoryReal !== source && !directoryReal.startsWith(`${source}${sep}`)))
-            throw new WorkspaceTransferError('workspace_transfer_conflict');
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
-            const path = prefix ? `${prefix}/${entry.name}` : entry.name;
-            if (excluded(path))
-                continue;
-            signal?.throwIfAborted();
-            const from = join(directory, entry.name), to = target ? join(target, path) : undefined;
-            const info = await lstat(from);
-            if (info.isSymbolicLink())
-                continue;
-            if (info.isDirectory()) {
-                if (to)
-                    await mkdir(to, { recursive: true });
-                const child = await copy(from, path);
-                if (child && child !== EMPTY_TREE)
-                    treeParts.push({ name: entry.name, directory: true,
-                        value: Buffer.concat([Buffer.from(`40000 ${entry.name}\0`), Buffer.from(child, 'hex')]) });
-            }
-            else if (info.isFile()) {
-                bytes += info.size;
-                files++;
-                if (!(await realpath(from)).startsWith(`${source}${sep}`))
-                    throw new WorkspaceTransferError('workspace_transfer_conflict');
-                if (!to && !hashOnly)
-                    continue;
-                const handle = await open(from, constants.O_RDONLY | constants.O_NOFOLLOW);
-                try {
-                    const before = await handle.stat();
-                    if (!before.isFile() || before.dev !== info.dev || before.ino !== info.ino || before.size !== info.size ||
-                        before.mtimeMs !== info.mtimeMs || before.ctimeMs !== info.ctimeMs)
-                        throw new WorkspaceTransferError('workspace_transfer_conflict');
-                    let size = 0;
-                    const hash = hashOnly ? createHash('sha1').update(`blob ${before.size}\0`) : undefined;
-                    if (to) {
-                        const guard = new Transform({ transform(chunk, _encoding, callback) {
-                                size += chunk.length;
-                                callback(size > before.size ? new WorkspaceTransferError('workspace_transfer_conflict') : null, chunk);
-                            } });
-                        await pipeline(handle.createReadStream({ autoClose: false }), guard, createWriteStream(to, { flags: 'wx', mode: 0o600 }), { signal });
-                    }
-                    else {
-                        for await (const chunk of handle.createReadStream({ autoClose: false })) {
-                            signal?.throwIfAborted();
-                            size += chunk.length;
-                            if (size > before.size)
-                                throw new WorkspaceTransferError('workspace_transfer_conflict');
-                            hash.update(chunk);
-                        }
-                    }
-                    const after = await handle.stat();
-                    if (size !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
-                        throw new WorkspaceTransferError('workspace_transfer_conflict');
-                    if (hash)
-                        treeParts.push({ name: entry.name, directory: false,
-                            value: Buffer.concat([Buffer.from(`${info.mode & 0o111 ? '100755' : '100644'} ${entry.name}\0`), hash.digest()]) });
-                }
-                finally {
-                    await handle.close();
-                }
-                if (to)
-                    await chmod(to, info.mode & 0o111 ? 0o755 : 0o644);
-            }
-        }
-        const after = await lstat(directory);
-        if (after.dev !== directoryInfo.dev || after.ino !== directoryInfo.ino || after.mtimeMs !== directoryInfo.mtimeMs || after.ctimeMs !== directoryInfo.ctimeMs)
-            throw new WorkspaceTransferError('workspace_transfer_conflict');
-        if (hashOnly) {
-            treeParts.sort((left, right) => Buffer.compare(Buffer.from(left.name + (left.directory ? '/' : '\0')), Buffer.from(right.name + (right.directory ? '/' : '\0'))));
-            const length = treeParts.reduce((total, part) => total + part.value.length, 0);
-            const hash = createHash('sha1').update(`tree ${length}\0`);
-            for (const part of treeParts)
-                hash.update(part.value);
-            return hash.digest('hex');
-        }
-    }
-    const tree = await copy(source, '');
-    return { bytes, files, ...(tree ? { tree } : {}) };
-}
-const EMPTY_TREE = createHash('sha1').update('tree 0\0').digest('hex');
-export async function inspectWorkspaceTransfer(root, options = {}) {
-    return copySnapshot(await realpath(root), undefined, options.signal);
-}
-export async function inspectWorkspaceTree(root, options = {}) {
-    const snapshot = await copySnapshot(await realpath(root), undefined, options.signal, true);
-    return { bytes: snapshot.bytes, files: snapshot.files, tree: snapshot.tree };
-}
-async function matchesFile(root, path, expected) {
-    const target = await safeTarget(root, path);
-    const info = await lstat(target).catch(error => { if (['ENOENT', 'ENOTDIR'].includes(error.code))
-        return undefined; throw error; });
-    if (!expected)
-        return !info || info.isDirectory();
-    if (!info?.isFile() || Boolean(info.mode & 0o111) !== expected.executable)
-        return false;
-    const handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        const hash = createHash(expected.sha.length === 64 ? 'sha256' : 'sha1');
-        hash.update(`blob ${stat.size}\0`);
-        for await (const chunk of handle.createReadStream({ autoClose: false }))
-            hash.update(chunk);
-        return hash.digest('hex') === expected.sha;
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function removeEmptyParents(root, target) {
-    let parent = dirname(target);
-    while (parent !== root) {
-        if ((await readdir(parent)).length > 0)
-            break;
-        await rmdir(parent);
-        parent = dirname(parent);
-    }
-}
-async function installFile(root, path, source, executable) {
-    const target = await safeTarget(root, path);
-    const existing = await lstat(target).catch(error => { if (error.code === 'ENOENT')
-        return undefined; throw error; });
-    if (existing?.isDirectory())
-        await rmdir(target);
-    await mkdir(dirname(target), { recursive: true });
-    const stage = join(dirname(target), `.playcraft-transfer-${randomUUID()}.tmp`);
-    try {
-        await copyFile(source, stage);
-        await chmod(stage, executable ? 0o755 : 0o644);
-        await rename(stage, target);
-    }
-    catch (error) {
-        await rm(stage, { force: true }).catch(() => undefined);
-        await removeEmptyParents(root, target).catch(() => undefined);
-        throw error;
-    }
-    finally {
-        await rm(stage, { force: true }).catch(() => undefined);
-    }
-}
-/** A fresh history contains only the current portable files, including uncommitted changes. */
-export async function createWorkspaceTransfer(root, options = {}) {
-    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-transfer-'));
-    const cleanup = () => rm(temporary, { recursive: true, force: true });
-    try {
-        const checkout = join(temporary, 'checkout');
-        await mkdir(checkout);
-        const stats = await copySnapshot(await realpath(root), checkout, options.signal);
-        await runTransferGit(checkout, ['init', '--initial-branch=main'], options);
-        // Portable snapshots preserve bytes even when project attributes request content conversion.
-        await writeFile(join(checkout, '.git', 'info', 'attributes'), RAW_ATTRIBUTES);
-        await runTransferGit(checkout, ['add', '--force', '--all'], options);
-        const tree = await runTransferGit(checkout, ['write-tree'], options);
-        const head = await canonicalCommit(checkout, tree, options.signal);
-        await runTransferGit(checkout, ['update-ref', 'refs/heads/main', head], options);
-        const bundlePath = join(temporary, 'workspace.bundle');
-        if (!options.skipBundle)
-            await runTransferGit(checkout, ['bundle', 'create', bundlePath, 'HEAD'], options);
-        return { bundlePath, tree, head, stats, cleanup };
-    }
-    catch (error) {
-        await cleanup();
-        throw error;
-    }
-}
-async function canonicalCommit(root, tree, signal) {
-    return runTransferGit(root, ['commit-tree', tree, '-m', SNAPSHOT_MESSAGE], { signal });
-}
-/** Only objects introduced since the last cloud snapshot are packed; local history stays local. */
-export async function createWorkspacePushTransfer(root, expectedTree, options = {}) {
-    if (!/^[a-f0-9]{40,64}$/.test(expectedTree))
-        throw new WorkspaceTransferError('invalid_workspace_transfer');
-    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-push-'));
-    const cleanup = () => rm(temporary, { recursive: true, force: true });
-    try {
-        const checkout = join(temporary, 'checkout');
-        await runTransferGit(temporary, ['clone', '--shared', '--no-checkout', '--', await realpath(root), checkout], options);
-        const tree = await runTransferGit(checkout, ['rev-parse', '--verify', 'HEAD^{tree}'], options);
-        const stats = summarizeEntries(await treeEntries(checkout, tree, options.signal));
-        try {
-            await runTransferGit(checkout, ['cat-file', '-e', `${expectedTree}^{tree}`], options);
-        }
-        catch (error) {
-            if (error instanceof WorkspaceTransferError && error.code === 'workspace_transfer_git_failed')
-                throw new WorkspaceTransferError('workspace_transfer_base_missing');
-            throw error;
-        }
-        const base = await canonicalCommit(checkout, expectedTree, options.signal);
-        const head = await runTransferGit(checkout, ['commit-tree', tree, '-p', base, '-m', SNAPSHOT_MESSAGE], options);
-        const transferRef = `refs/heads/playcraft-transfer-${tree}`;
-        await runTransferGit(checkout, ['update-ref', transferRef, head], options);
-        await runTransferGit(checkout, ['symbolic-ref', 'HEAD', transferRef], options);
-        const bundlePath = join(temporary, 'workspace.bundle');
-        await runTransferGit(checkout, ['bundle', 'create', bundlePath, 'HEAD', transferRef, `^${base}`], options);
-        return { bundlePath, tree, head, stats, cleanup };
-    }
-    catch (error) {
-        await cleanup();
-        throw error;
-    }
-}
-async function treeEntries(root, ref = 'HEAD', signal) {
-    const entries = [];
-    const normalized = new Set();
-    let pending = '';
-    const parse = (line) => {
-        const match = /^(100644|100755) blob ([a-f0-9]{40,64})\s+(\d+)\t(.+)$/s.exec(line);
-        if (!match)
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        const path = match[4];
-        if (path.length > 1024 || path.includes('\\') || path.startsWith('/') || /[\x00-\x1f\x7f]/.test(path) ||
-            path.split('/').some(part => !part || part === '.' || part === '..') || excluded(path))
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        const size = Number(match[3]);
-        if (!Number.isSafeInteger(size) || normalized.has(path.toLowerCase()))
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        normalized.add(path.toLowerCase());
-        entries.push({ path, sha: match[2], executable: match[1] === '100755', size });
-    };
-    await runTransferGit(root, ['ls-tree', '-r', '-z', '-l', ref], { signal, onStdout(chunk) {
-            pending += chunk;
-            let end;
-            while ((end = pending.indexOf('\0')) !== -1) {
-                parse(pending.slice(0, end));
-                pending = pending.slice(end + 1);
-            }
-            if (pending.length > 1200)
-                throw new WorkspaceTransferError('invalid_workspace_transfer');
-        } });
-    if (pending)
-        throw new WorkspaceTransferError('invalid_workspace_transfer');
-    return entries;
-}
-function summarizeEntries(entries) {
-    const bytes = entries.reduce((total, entry) => total + entry.size, 0);
-    if (!Number.isSafeInteger(bytes))
-        throw new WorkspaceTransferError('invalid_workspace_transfer');
-    return { bytes, files: entries.length };
-}
-export async function inspectWorkspaceCommit(root, ref = 'HEAD', options = {}) {
-    const tree = await runTransferGit(root, ['rev-parse', '--verify', '--end-of-options', `${ref}^{tree}`], options);
-    return summarizeEntries(await treeEntries(root, tree, options.signal));
-}
-async function safeTarget(root, path) {
-    const target = resolve(root, path);
-    if (!target.startsWith(`${root}${sep}`))
-        throw new WorkspaceTransferError('invalid_workspace_transfer');
-    let current = root;
-    for (const segment of path.split('/')) {
-        current = join(current, segment);
-        const info = await lstat(current).catch(error => { if (['ENOENT', 'ENOTDIR'].includes(error.code))
-            return undefined; throw error; });
-        if (info?.isSymbolicLink())
-            throw new WorkspaceTransferError('workspace_transfer_symlink');
-    }
-    return target;
-}
-/** Compare the entire checkout before applying local commits, so cloud edits are never overwritten. */
-export async function applyWorkspaceTransfer(root, bundle, expectedTree, options = {}) {
-    if (!/^[a-f0-9]{40,64}$/.test(expectedTree))
-        throw new WorkspaceTransferError('invalid_workspace_transfer');
-    options.signal?.throwIfAborted();
-    const rootReal = await realpath(root);
-    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-import-'));
-    let current;
-    try {
-        const bundlePath = typeof bundle === 'string' ? resolve(bundle) : join(temporary, 'incoming.bundle');
-        const incoming = join(temporary, 'checkout');
-        if (typeof bundle !== 'string')
-            await writeFile(bundlePath, bundle, { mode: 0o600 });
-        const bundleInfo = await stat(bundlePath);
-        if (!bundleInfo.isFile() || !bundleInfo.size)
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        const advertised = await runTransferGit(temporary, ['bundle', 'list-heads', bundlePath], options);
-        const targets = advertised.split('\n').map(line => /^[a-f0-9]{40,64} refs\/heads\/playcraft-transfer-([a-f0-9]{40,64})$/.exec(line)?.[1]).filter(Boolean);
-        if (targets.length > 1)
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        const targetTree = targets[0];
-        current = await createWorkspaceTransfer(rootReal, { ...options, skipBundle: true });
-        // A lost response can be retried after the original prerequisite has left the cloud snapshot.
-        if (targetTree === current.tree) {
-            await options.validateSnapshot?.(current.stats, current.stats, bundleInfo.size);
-            return { tree: current.tree, head: current.head, changedPaths: [] };
-        }
-        const baseline = join(dirname(current.bundlePath), 'checkout');
-        await runTransferGit(temporary, ['clone', '--shared', '--no-checkout', '--', baseline, incoming], options);
-        await writeFile(join(incoming, '.git', 'info', 'attributes'), RAW_ATTRIBUTES);
-        try {
-            await runTransferGit(incoming, ['fetch', '--no-tags', '--', bundlePath, 'HEAD'], options);
-        }
-        catch (error) {
-            if (current.tree !== expectedTree)
-                throw new WorkspaceTransferError('workspace_transfer_conflict');
-            if (error instanceof WorkspaceTransferError && error.code === 'workspace_transfer_git_failed')
-                throw new WorkspaceTransferError('invalid_workspace_transfer');
-            throw error;
-        }
-        const entries = await treeEntries(incoming, 'FETCH_HEAD', options.signal);
-        const tree = await runTransferGit(incoming, ['rev-parse', 'FETCH_HEAD^{tree}'], options);
-        const head = await runTransferGit(incoming, ['rev-parse', 'FETCH_HEAD'], options);
-        if (targetTree && targetTree !== tree)
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        await options.validateSnapshot?.(summarizeEntries(entries), current.stats, bundleInfo.size);
-        if (current.tree === tree)
-            return { tree, head, changedPaths: [] };
-        if (current.tree !== expectedTree)
-            throw new WorkspaceTransferError('workspace_transfer_conflict');
-        const previous = new Map((await treeEntries(baseline, 'HEAD', options.signal)).map(entry => [entry.path, entry]));
-        const next = new Map(entries.map(entry => [entry.path, entry]));
-        const changedPaths = [...new Set([...previous.keys(), ...next.keys()])]
-            .filter(path => previous.get(path)?.sha !== next.get(path)?.sha || previous.get(path)?.executable !== next.get(path)?.executable);
-        for (const path of changedPaths) {
-            const target = await safeTarget(rootReal, path);
-            const info = await lstat(target).catch(error => { if (['ENOENT', 'ENOTDIR'].includes(error.code))
-                return undefined; throw error; });
-            if (next.has(path) && info?.isDirectory()) {
-                const children = await readdir(target, { recursive: true });
-                for (const child of children) {
-                    const childPath = `${path}/${child.split(sep).join('/')}`;
-                    const childInfo = await lstat(join(target, child));
-                    if (!childInfo.isDirectory() && (!previous.has(childPath) || next.has(childPath)))
-                        throw new WorkspaceTransferError('workspace_transfer_conflict');
-                }
-            }
-        }
-        await runTransferGit(incoming, ['checkout', '--force', '--detach', head], options);
-        const recheck = await copySnapshot(rootReal, undefined, options.signal, true);
-        if (recheck.tree !== expectedTree)
-            throw new WorkspaceTransferError('workspace_transfer_conflict');
-        const applied = [];
-        try {
-            // Deleting files first also permits a file to become a directory, or the reverse.
-            for (const path of changedPaths.filter(path => !next.has(path)).sort((a, b) => b.length - a.length)) {
-                options.signal?.throwIfAborted();
-                if (!await matchesFile(rootReal, path, previous.get(path)))
-                    throw new WorkspaceTransferError('workspace_transfer_conflict');
-                await rm(await safeTarget(rootReal, path), { force: true });
-                applied.push(path);
-                await removeEmptyParents(rootReal, join(rootReal, path));
-            }
-            for (const path of changedPaths.filter(path => next.has(path))) {
-                options.signal?.throwIfAborted();
-                if (!await matchesFile(rootReal, path, previous.get(path)))
-                    throw new WorkspaceTransferError('workspace_transfer_conflict');
-                const entry = next.get(path);
-                await installFile(rootReal, path, join(incoming, path), entry.executable);
-                applied.push(path);
-            }
-        }
-        catch (error) {
-            // Roll back only our writes; never replace another writer's intervening content.
-            for (const path of applied.reverse()) {
-                if (!await matchesFile(rootReal, path, next.get(path)))
-                    throw new WorkspaceTransferError('workspace_transfer_rollback_conflict');
-                const old = previous.get(path);
-                if (old)
-                    await installFile(rootReal, path, join(baseline, path), old.executable);
-                else {
-                    await rm(await safeTarget(rootReal, path), { force: true });
-                    await removeEmptyParents(rootReal, join(rootReal, path));
-                }
-            }
-            throw error;
-        }
-        return { tree, head, changedPaths };
-    }
-    finally {
-        await current?.cleanup();
-        await rm(temporary, { recursive: true, force: true });
-    }
-}

package/dist/workspace-runtime/workspaces/turn-changes.js

@@ -1,75 +0,0 @@
-import { TURN_FILES_CHANGED_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
-import { diffWorkspaceTrees, retainTurnSnapshots, snapshotWorkspaceTree } from './git.js';
-import { shareWorkspaceGit } from './shared-git.js';
-const TURN_ENDS = new Set(['turn/completed', 'turn.completed', 'turn.interrupted', 'turn.failed']);
-/**
- * Snapshots taken when a session's turn starts, until that turn ends. Kept in memory only: a
- * restart ends the native turn as well, and that turn then simply reports no changes.
- */
-const started = new WeakMap();
-function turnsOf(state) {
-    let turns = started.get(state);
-    if (!turns)
-        started.set(state, turns = new Map());
-    return turns;
-}
-/**
- * Records the work tree before a turn is sent. A directory that cannot be snapshotted (no
- * repository, Git failure) gets no change summary; the turn itself is never held back by it.
- */
-export async function beginTurnChanges(state, sessionId, input) {
-    turnsOf(state).delete(sessionId);
-    if (input.directoryName === 'root')
-        return;
-    await shareWorkspaceGit(state, input.root).catch(() => undefined);
-    const before = await snapshotWorkspaceTree(input.root).catch(() => undefined);
-    if (before)
-        turnsOf(state).set(sessionId, { ...input, before });
-}
-/** A turn that never started has nothing to compare. */
-export function abandonTurnChanges(state, sessionId) {
-    turnsOf(state).delete(sessionId);
-}
-/**
- * When a session's turn ends, compares the work tree with its start and records the files that
- * changed for that session's conversation. Returns no event when nothing changed.
- */
-export async function finishTurnChanges(state, event) {
-    const { threadId, turnId } = event;
-    if (!TURN_ENDS.has(event.method) || !threadId || !turnId)
-        return [];
-    const session = state.journal.listSessions().find((item) => item.threadId === threadId);
-    const start = session && turnsOf(state).get(session.sessionId);
-    if (!session || !start)
-        return [];
-    turnsOf(state).delete(session.sessionId);
-    try {
-        await shareWorkspaceGit(state, start.root);
-        const after = await snapshotWorkspaceTree(start.root);
-        const { files, truncated } = await diffWorkspaceTrees(start.root, start.before, after);
-        if (!files.length)
-            return [];
-        await retainTurnSnapshots(start.root, turnId, start.before, after);
-        const changes = { threadId, turnId, before: start.before, after, files, truncated };
-        return [await state.journal.allocateSourceEvent({
-                runtimeId: state.config.runtimeId,
-                generation: state.config.generation,
-                runtimeEpoch: state.runtimeEpoch,
-                type: TURN_FILES_CHANGED_EVENT,
-                payload: {
-                    ...changes,
-                    sessionId: session.sessionId,
-                    ...(start.workspaceId ? { workspaceId: start.workspaceId } : {}),
-                    ...(start.directoryName ? { directoryName: start.directoryName } : {}),
-                },
-                occurredAt: new Date().toISOString(),
-                sessionId: session.sessionId,
-                workspaceId: start.workspaceId,
-                threadId,
-                turnId,
-            })];
-    }
-    catch {
-        return [];
-    }
-}

package/dist/workspace-runtime/workspaces/video-attachments.js

@@ -1,49 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { WORKSPACE_VIDEO_ATTACHMENT_MAX_DURATION_MS, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
-/** Probe the opened descriptor so replacing a pathname cannot redirect the media reader. */
-export async function probeAttachmentVideo(handle) {
-    const output = await new Promise((resolve, reject) => {
-        const child = spawn(process.env.PLAYCRAFT_FFPROBE_PATH ?? 'ffprobe', [
-            '-v', 'error', '-protocol_whitelist', 'file,pipe', '-show_entries',
-            'format=format_name,duration:stream=codec_type,width,height', '-of', 'json',
-            process.platform === 'linux' ? '/proc/self/fd/3' : '/dev/fd/3',
-        ], { stdio: ['ignore', 'pipe', 'ignore', handle.fd] });
-        let text = '';
-        const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('invalid_attachment')); }, 15_000);
-        timer.unref();
-        child.stdout.on('data', (chunk) => {
-            text += chunk.toString('utf8');
-            if (text.length > 64 * 1024) {
-                child.kill('SIGKILL');
-                reject(new Error('invalid_attachment'));
-            }
-        });
-        child.once('error', () => { clearTimeout(timer); reject(new Error('video_probe_unavailable')); });
-        child.once('close', code => { clearTimeout(timer); code === 0 ? resolve(text) : reject(new Error('invalid_attachment')); });
-    });
-    const result = JSON.parse(output);
-    const stream = result.streams?.find(item => item.codec_type === 'video');
-    const durationMs = Math.round(Number(result.format?.duration) * 1000);
-    const formats = result.format?.format_name?.split(',') ?? [];
-    const mimeType = formats.includes('webm') ? 'video/webm' : formats.includes('mp4') ? 'video/mp4' : formats.includes('mov') ? 'video/quicktime' : undefined;
-    if (!stream || !mimeType || !Number.isFinite(durationMs) || durationMs <= 0 || durationMs > WORKSPACE_VIDEO_ATTACHMENT_MAX_DURATION_MS
-        || !Number.isSafeInteger(stream.width) || !Number.isSafeInteger(stream.height) || stream.width <= 0 || stream.height <= 0
-        || stream.width > 16384 || stream.height > 16384)
-        throw new Error('invalid_attachment');
-    return { mimeType, durationMs, width: stream.width, height: stream.height };
-}
-export async function hashAttachment(handle) {
-    const digest = createHash('sha256');
-    const chunk = Buffer.allocUnsafe(64 * 1024);
-    let position = 0;
-    for (;;) {
-        const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
-        if (!bytesRead)
-            return digest.digest('hex');
-        digest.update(chunk.subarray(0, bytesRead));
-        position += bytesRead;
-        if (position > WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES)
-            throw new Error('invalid_attachment');
-    }
-}

package/project-template/.claude/skills/playcraft-replica-validation/SKILL.md

@@ -1,25 +0,0 @@
----
-name: playcraft-replica-validation
-description: Record a reconstructed browser playable with real inputs, compare it with its reference video, and use timestamped differences to improve the replica. Use after implementation or fixes; use video understanding first when the reference has not been analyzed.
-version: 1.0.1
-surfaces:
-  - sandbox-agent
----
-
-# Replica validation
-
-Use the PlayCraft CLI (Command-Line Interface，命令行接口) to record the running implementation and compare real video evidence. Codex chooses the scenario, reads the evidence, edits the playable, and repeats the checks. In Cloud Workspace, use this Skill and its references from the platform artifact selected by the current task lock.
-
-Read [command and evidence contracts](references/contracts.md) before the first recording or comparison. Check `playcraft playable record --help`, `playcraft video compare --help`, and `playcraft video models --json`. If a required command is unavailable, report that the workspace CLI needs upgrading. Provider credentials and model requests belong to Model Proxy; do not call Gemini directly or copy a key into the project.
-
-Use a completed reference `analysis.json` from `playcraft-video-understanding`. Inspect its original keyframes and distinguish observed actions from inferred controls. Run from the project root. Write an explicit, versioned scenario for the current implementation, using real browser coordinates and inputs. Include the initial view, first action and result, principal feedback, and ending when demonstrated. Keep hidden rules and unshown branches unknown. Start or restart the current project using its own development command; do not depend on internal auto-play hooks. Confirm that the supplied development address belongs to this process and serves this round's version. If that cannot be confirmed, do not claim validation of the current version. The project digest proves the recorded checkout stayed unchanged, but does not attest which source version an already-running server serves.
-
-Record into a fresh directory under `.playcraft/video-replication/`. Keep the original recording, its input logs, scenario, control recordings, and project snapshot together. Do not edit the video or its manifest to repair a failing check. Match the reference viewport when practical and record enough time for every expected result. A completed recording proves capture succeeded; it does not prove the interaction worked.
-
-Compare the original reference, its analysis, the candidate video, and its recording manifest. Inspect `comparison.md`, `comparison.json`, paired keyframes, contact sheets, input logs, and controls using available image and file-reading tools. Review event alignment before judging motion or feedback timing. The model can suggest differences; the CLI derives the final status from validated evidence and the comparison policy. A single similarity score is insufficient. Keep the default full comparison policy for delivery; an explicitly limited diagnostic must be reported as partial coverage. Do not loosen thresholds just to obtain a passing result.
-
-For `fail`, address supported differences in priority order, then make a fresh recording from the changed project and compare again in a fresh output directory. For `inconclusive`, resolve missing controls, insufficient duration, unpaired required events, low confidence, or unknown input intent before declaring completion. Preserve valid differences even when other dimensions lack evidence. Report the tested path, unsupported branches, and unevaluated audio explicitly.
-
-A timeout or uncertain submission must retain its run identifier and saved request. Resume the same comparison with `playcraft video compare --resume <runId> --out <same-directory>`; recovery reads the existing task and never creates another paid request. Explicit cancellation is separate from ending the local wait. Do not resubmit because the command exited early. Treat malformed model output, stale recordings, changed hashes, or missing frames as errors, never as a passing comparison.
-
-Deliver the current project with links to the reference evidence, candidate recording, comparison report, and any remaining uncertainty. Keep validation evidence in workspace checkpoints and out of Git and deliverable builds.