@playcraft/cli 0.1.54 → 0.1.56-beta

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

@@ -0,0 +1,471 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,49 @@
+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');
+    }
+}