@playcraft/cli 0.1.54 → 0.1.56-beta

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

@@ -0,0 +1,438 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { link, lstat, mkdir, open, readdir, realpath, rename, rm, rmdir, unlink } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { ASSET_TRANSFER_CHUNK_BYTES, assetBundleSavePayloadSchema, assetBundleReceiptSchema, isAssetBundleReceiptForManifest, } from '@playcraft/common/cloud-workspace/runtime';
+import { AssetTransferError, assetTransferMissing, hashAssetTransferFile, safeAssetTransferDirectory, saveAssetTransfer, syncAssetTransferDirectory, withAssetTransfer, } from './asset-transfer-storage.js';
+import { validateAssetTransferDependencies } from './asset-transfer-dependencies.js';
+import { shareWorkspaceAssetDirectory, shareWorkspaceAssetFile } from './asset-publication-access.js';
+const same = (left, right) => left.dev === right.dev && left.ino === right.ino
+    && left.size === right.size && left.contentHash === right.contentHash;
+async function targetFile(transfer, path) {
+    try {
+        await safeAssetTransferDirectory(transfer.root, dirname(path) === '.' ? '' : dirname(path));
+        return await hashAssetTransferFile(join(transfer.root, path));
+    }
+    catch (error) {
+        if (assetTransferMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+async function privateFile(transfer, directory, index) {
+    try {
+        await safeAssetTransferDirectory(transfer.directory, directory);
+        return await hashAssetTransferFile(join(transfer.directory, directory, String(index)), undefined, true);
+    }
+    catch (error) {
+        if (assetTransferMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+async function assertSource(transfer, file) {
+    if (file.source && (await targetFile(transfer, file.source.path))?.contentHash !== file.source.contentHash)
+        throw new AssetTransferError('source_content_conflict');
+}
+async function assemble(transfer) {
+    await safeAssetTransferDirectory(transfer.directory, 'chunks', true);
+    await safeAssetTransferDirectory(transfer.directory, 'incoming', true);
+    const staged = [];
+    for (const [index, file] of transfer.record.manifest.files.entries()) {
+        const destination = join(transfer.directory, 'incoming', String(index));
+        const output = await open(destination, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        const hash = createHash('sha256');
+        try {
+            for (const [chunkIndex, expected] of file.chunkHashes.entries()) {
+                let input;
+                try {
+                    input = await open(join(transfer.directory, 'chunks', `${index}-${chunkIndex}`), constants.O_RDONLY | constants.O_NOFOLLOW);
+                }
+                catch (error) {
+                    if (assetTransferMissing(error))
+                        throw new AssetTransferError('asset_transfer_incomplete');
+                    throw error;
+                }
+                try {
+                    const stat = await input.stat();
+                    const size = Math.min(ASSET_TRANSFER_CHUNK_BYTES, file.size - chunkIndex * ASSET_TRANSFER_CHUNK_BYTES);
+                    if (!stat.isFile() || stat.nlink !== 1 || stat.size !== size)
+                        throw new AssetTransferError('asset_transfer_chunk_mismatch');
+                    const bytes = await input.readFile();
+                    if (bytes.length !== size || createHash('sha256').update(bytes).digest('hex') !== expected)
+                        throw new AssetTransferError('asset_transfer_chunk_mismatch');
+                    hash.update(bytes);
+                    await output.writeFile(bytes);
+                }
+                finally {
+                    await input.close();
+                }
+            }
+            await shareWorkspaceAssetFile(transfer.root, output);
+            await output.sync();
+        }
+        finally {
+            await output.close();
+        }
+        const contentHash = hash.digest('hex');
+        if (file.contentHash && file.contentHash !== contentHash)
+            throw new AssetTransferError('asset_transfer_content_mismatch');
+        const sampled = await hashAssetTransferFile(destination);
+        if (sampled.size !== file.size || sampled.contentHash !== contentHash)
+            throw new AssetTransferError('asset_transfer_content_mismatch');
+        staged.push(sampled);
+    }
+    return staged;
+}
+function validatePublication(transfer) {
+    const publication = transfer.record.publication;
+    if (!publication || publication.manifestHash !== transfer.record.manifestHash
+        || typeof publication.operationId !== 'string' || !publication.operationId || publication.operationId.length > 128
+        || !Array.isArray(publication.files) || publication.files.length !== transfer.record.manifest.files.length
+        || !Array.isArray(publication.directories))
+        throw new AssetTransferError('asset_transfer_recovery_required');
+    for (const file of publication.files)
+        for (const identity of [file.staged, file.previous].filter(Boolean)) {
+            if (!identity || !Number.isSafeInteger(identity.dev) || !Number.isSafeInteger(identity.ino) || !Number.isSafeInteger(identity.size)
+                || !/^[a-f0-9]{64}$/.test(identity.contentHash))
+                throw new AssetTransferError('asset_transfer_recovery_required');
+        }
+    for (const directory of publication.directories) {
+        if (typeof directory.path !== 'string' || !Number.isSafeInteger(directory.dev) || !Number.isSafeInteger(directory.ino)
+            || ![...transfer.record.manifest.files.map(file => file.path), ...(transfer.record.manifest.directories ?? [])]
+                .some(path => path === directory.path || path.startsWith(directory.path + '/')))
+            throw new AssetTransferError('asset_transfer_recovery_required');
+    }
+    if (publication.markers?.some(marker => !Number.isSafeInteger(marker.dev) || !Number.isSafeInteger(marker.ino)
+        || !transfer.record.manifest.directories?.includes(marker.path)))
+        throw new AssetTransferError('asset_transfer_recovery_required');
+    return publication;
+}
+async function createDirectories(transfer, path) {
+    const publication = validatePublication(transfer);
+    let directory = '';
+    for (const part of path.split('/').filter(Boolean)) {
+        directory = [directory, part].filter(Boolean).join('/');
+        try {
+            await safeAssetTransferDirectory(transfer.root, directory);
+        }
+        catch (error) {
+            if (!assetTransferMissing(error))
+                throw error;
+            await safeAssetTransferDirectory(transfer.root, dirname(directory) === '.' ? '' : dirname(directory));
+            await mkdir(join(transfer.root, directory), { mode: 0o700 });
+            await shareWorkspaceAssetDirectory(transfer.root, join(transfer.root, directory));
+            const stat = await lstat(await safeAssetTransferDirectory(transfer.root, directory));
+            publication.directories.push({ path: directory, dev: stat.dev, ino: stat.ino });
+            await saveAssetTransfer(transfer);
+        }
+    }
+}
+async function cleanPublicationFiles(transfer, completed = false) {
+    for (const name of completed ? ['chunks', 'incoming', 'previous'] : ['incoming', 'previous']) {
+        try {
+            await safeAssetTransferDirectory(transfer.directory, name);
+            await rm(join(transfer.directory, name), { recursive: true });
+        }
+        catch (error) {
+            if (!assetTransferMissing(error))
+                throw error;
+        }
+    }
+}
+async function ensureDirectoryMarkers(transfer) {
+    const publication = validatePublication(transfer);
+    for (const path of transfer.record.manifest.directories ?? []) {
+        const parent = await safeAssetTransferDirectory(transfer.root, path);
+        const marker = join(parent, '.gitkeep');
+        try {
+            const handle = await open(marker, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+            try {
+                await shareWorkspaceAssetFile(transfer.root, handle);
+                await handle.sync();
+                const stat = await handle.stat();
+                (publication.markers ??= []).push({ path, dev: stat.dev, ino: stat.ino });
+                await saveAssetTransfer(transfer);
+            }
+            finally {
+                await handle.close();
+            }
+            await syncAssetTransferDirectory(parent);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const stat = await lstat(marker);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1)
+                throw new AssetTransferError('content_conflict');
+        }
+    }
+}
+async function assertCompletedTargets(transfer) {
+    if (!isAssetBundleReceiptForManifest(transfer.record.manifest, transfer.record.manifestHash, transfer.record.receipt))
+        throw new AssetTransferError('asset_transfer_content_mismatch');
+    for (const [index, file] of transfer.record.manifest.files.entries()) {
+        await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
+        const current = await hashAssetTransferFile(join(transfer.root, file.path), undefined, false, file.chunkHashes);
+        const saved = transfer.record.receipt.files[index];
+        if (saved.path !== file.path || current.size !== file.size || current.contentHash !== saved.contentHash)
+            throw new AssetTransferError('asset_transfer_content_mismatch');
+    }
+    for (const directory of transfer.record.manifest.directories ?? [])
+        await safeAssetTransferDirectory(transfer.root, directory);
+}
+async function finishPublication(transfer) {
+    const publication = validatePublication(transfer);
+    const files = [];
+    for (const [index, file] of transfer.record.manifest.files.entries()) {
+        await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
+        const current = await hashAssetTransferFile(join(transfer.root, file.path), undefined, false, file.chunkHashes);
+        if (!current || !same(current, publication.files[index].staged))
+            throw new AssetTransferError('content_conflict');
+        files.push({ path: file.path, size: current.size, contentHash: current.contentHash });
+    }
+    await ensureDirectoryMarkers(transfer);
+    const receipt = assetBundleReceiptSchema.parse({ transferId: transfer.record.manifest.transferId,
+        manifestHash: transfer.record.manifestHash, files,
+        ...(transfer.record.manifest.directories ? { directories: transfer.record.manifest.directories } : {}) });
+    if (!isAssetBundleReceiptForManifest(transfer.record.manifest, transfer.record.manifestHash, receipt))
+        throw new AssetTransferError('asset_transfer_content_mismatch');
+    transfer.record.status = 'completed';
+    transfer.record.receipt = receipt;
+    await saveAssetTransfer(transfer);
+    await cleanPublicationFiles(transfer, true).catch(() => undefined);
+    return receipt;
+}
+/** Complete only this journal's exclusive link/unlink pairs left behind by a crash. */
+async function normalizePublicationAliases(transfer) {
+    const publication = validatePublication(transfer);
+    for (const [index, file] of transfer.record.manifest.files.entries()) {
+        const parent = dirname(file.path) === '.' ? '' : dirname(file.path);
+        try {
+            await safeAssetTransferDirectory(transfer.root, parent);
+        }
+        catch (error) {
+            if (assetTransferMissing(error))
+                continue;
+            throw error;
+        }
+        const target = join(transfer.root, file.path);
+        const targetStat = await lstat(target).catch(error => { if (assetTransferMissing(error))
+            return undefined; throw error; });
+        if (!targetStat || targetStat.nlink === 1)
+            continue;
+        if (!targetStat.isFile() || targetStat.isSymbolicLink() || targetStat.nlink !== 2)
+            throw new AssetTransferError('asset_transfer_recovery_required');
+        let normalized = false;
+        for (const [directory, expected] of [['incoming', publication.files[index].staged], ['previous', publication.files[index].previous]]) {
+            if (!expected || targetStat.dev !== expected.dev || targetStat.ino !== expected.ino)
+                continue;
+            try {
+                await safeAssetTransferDirectory(transfer.directory, directory);
+            }
+            catch (error) {
+                if (assetTransferMissing(error))
+                    continue;
+                throw error;
+            }
+            const alias = join(transfer.directory, directory, String(index));
+            const aliasStat = await lstat(alias).catch(error => { if (assetTransferMissing(error))
+                return undefined; throw error; });
+            if (!aliasStat || !aliasStat.isFile() || aliasStat.isSymbolicLink() || aliasStat.nlink !== 2
+                || aliasStat.dev !== expected.dev || aliasStat.ino !== expected.ino)
+                continue;
+            const observed = await hashAssetTransferFile(target, undefined, true);
+            if (!same(observed, expected))
+                throw new AssetTransferError('asset_transfer_recovery_required');
+            // Recheck both names immediately before unlinking the known private alias.
+            const [current, privateAlias] = await Promise.all([lstat(target), lstat(alias)]);
+            if (current.dev !== expected.dev || current.ino !== expected.ino || current.nlink !== 2
+                || privateAlias.dev !== expected.dev || privateAlias.ino !== expected.ino || privateAlias.nlink !== 2)
+                throw new AssetTransferError('asset_transfer_recovery_required');
+            await unlink(alias);
+            await syncAssetTransferDirectory(join(transfer.directory, directory));
+            normalized = true;
+            break;
+        }
+        if (!normalized)
+            throw new AssetTransferError('asset_transfer_recovery_required');
+    }
+}
+/** Roll back only files still owned by this publication; preserve concurrent external edits and backups. */
+async function rollbackPublication(transfer) {
+    await normalizePublicationAliases(transfer);
+    const publication = validatePublication(transfer);
+    let conflict = false;
+    for (let index = publication.files.length - 1; index >= 0; index--) {
+        const file = transfer.record.manifest.files[index], expected = publication.files[index];
+        try {
+            const current = await targetFile(transfer, file.path);
+            const backup = await privateFile(transfer, 'previous', index);
+            if (backup) {
+                if (!expected.previous || !same(backup, expected.previous)) {
+                    conflict = true;
+                    continue;
+                }
+                if (current) {
+                    if (!same(current, expected.staged)) {
+                        conflict = true;
+                        continue;
+                    }
+                    await unlink(join(transfer.root, file.path));
+                }
+                await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
+                await link(join(transfer.directory, 'previous', String(index)), join(transfer.root, file.path));
+                await unlink(join(transfer.directory, 'previous', String(index)));
+                await syncAssetTransferDirectory(join(transfer.root, dirname(file.path)));
+            }
+            else if (current && same(current, expected.staged)) {
+                if (expected.previous) {
+                    conflict = true;
+                    continue;
+                }
+                await unlink(join(transfer.root, file.path));
+            }
+            else if (expected.previous && (!current || !same(current, expected.previous)))
+                conflict = true;
+        }
+        catch {
+            conflict = true;
+        }
+    }
+    if (conflict)
+        throw new AssetTransferError('asset_transfer_recovery_required');
+    for (const marker of publication.markers ?? []) {
+        try {
+            const parent = await safeAssetTransferDirectory(transfer.root, marker.path);
+            const path = join(parent, '.gitkeep'), stat = await lstat(path);
+            if (stat.dev === marker.dev && stat.ino === marker.ino && stat.isFile() && stat.nlink === 1 && stat.size === 0)
+                await unlink(path);
+        }
+        catch (error) {
+            if (!assetTransferMissing(error))
+                throw error;
+        }
+    }
+    for (const directory of [...publication.directories].reverse()) {
+        try {
+            const target = await safeAssetTransferDirectory(transfer.root, directory.path);
+            const stat = await lstat(target);
+            if (stat.dev === directory.dev && stat.ino === directory.ino)
+                await rmdir(target);
+        }
+        catch (error) {
+            if (!assetTransferMissing(error) && !['ENOTEMPTY', 'EEXIST'].includes(String(error.code)))
+                throw error;
+        }
+    }
+    transfer.record.status = 'uploading';
+    delete transfer.record.publication;
+    delete transfer.record.receipt;
+    await saveAssetTransfer(transfer);
+    await cleanPublicationFiles(transfer);
+}
+export async function recoverAssetTransfer(transfer) {
+    if (transfer.record.status === 'completed') {
+        await assertCompletedTargets(transfer);
+        await cleanPublicationFiles(transfer, true);
+        return;
+    }
+    if (transfer.record.status !== 'publishing')
+        return;
+    await normalizePublicationAliases(transfer);
+    try {
+        await finishPublication(transfer);
+    }
+    catch {
+        await rollbackPublication(transfer);
+    }
+}
+export async function publishAssetTransfer(root, scope, input, options) {
+    const payload = assetBundleSavePayloadSchema.parse(input);
+    return withAssetTransfer(root, scope, payload.transferId, async (transfer) => {
+        if (transfer.record.manifestHash !== payload.manifestHash)
+            throw new AssetTransferError('asset_transfer_manifest_conflict');
+        options.onManifest?.(transfer.record.manifest);
+        await recoverAssetTransfer(transfer);
+        if (transfer.record.status === 'completed')
+            return transfer.record.receipt;
+        await options.assertCurrent?.();
+        await cleanPublicationFiles(transfer);
+        let staged;
+        try {
+            staged = await assemble(transfer);
+            await validateAssetTransferDependencies(transfer);
+        }
+        catch (error) {
+            await cleanPublicationFiles(transfer);
+            throw error;
+        }
+        const previous = [];
+        for (const file of transfer.record.manifest.files) {
+            const observed = await targetFile(transfer, file.path);
+            if ((observed?.contentHash ?? null) !== file.expectedContentHash)
+                throw new AssetTransferError('content_conflict');
+            await assertSource(transfer, file);
+            await options.assertRevision?.(file, observed);
+            previous.push(observed);
+        }
+        transfer.record.status = 'publishing';
+        transfer.record.publication = { operationId: options.operationId, manifestHash: payload.manifestHash,
+            files: staged.map((identity, index) => ({ staged: identity, ...(previous[index] ? { previous: previous[index] } : {}) })), directories: [] };
+        await saveAssetTransfer(transfer);
+        try {
+            await safeAssetTransferDirectory(transfer.directory, 'previous', true);
+            for (const directory of transfer.record.manifest.directories ?? [])
+                await createDirectories(transfer, directory);
+            for (const [index, file] of transfer.record.manifest.files.entries()) {
+                await options.assertCurrent?.();
+                await createDirectories(transfer, dirname(file.path) === '.' ? '' : dirname(file.path));
+                const current = await targetFile(transfer, file.path);
+                if (previous[index] ? !current || !same(current, previous[index]) : current)
+                    throw new AssetTransferError('content_conflict');
+                await assertSource(transfer, file);
+                if (current) {
+                    await rename(join(transfer.root, file.path), join(transfer.directory, 'previous', String(index)));
+                    const backup = await privateFile(transfer, 'previous', index);
+                    if (!backup || !same(backup, current))
+                        throw new AssetTransferError('content_conflict');
+                    await syncAssetTransferDirectory(join(transfer.directory, 'previous'));
+                }
+                await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
+                // Creating the destination with link refuses a concurrently-created file instead of overwriting it.
+                await link(join(transfer.directory, 'incoming', String(index)), join(transfer.root, file.path));
+                await unlink(join(transfer.directory, 'incoming', String(index)));
+                await syncAssetTransferDirectory(join(transfer.root, dirname(file.path)));
+                await options.onPublishedFile?.(index);
+            }
+            await options.assertCurrent?.();
+            return await finishPublication(transfer);
+        }
+        catch (error) {
+            await rollbackPublication(transfer);
+            throw error;
+        }
+    });
+}
+export async function recoverAssetTransfers(root, scope) {
+    const recovered = [];
+    let directory;
+    try {
+        directory = await safeAssetTransferDirectory(await realpath(root), '.playcraft-temp/asset-transfers');
+    }
+    catch (error) {
+        if (assetTransferMissing(error))
+            return recovered;
+        throw error;
+    }
+    for (const item of await readdir(directory, { withFileTypes: true })) {
+        if (!item.isDirectory() || !/^[a-f0-9-]{36}$/i.test(item.name))
+            continue;
+        await withAssetTransfer(root, scope, item.name, async (transfer) => {
+            await recoverAssetTransfer(transfer);
+            if (transfer.record.status === 'completed' && transfer.record.publication?.operationId)
+                recovered.push({ operationId: transfer.record.publication.operationId, receipt: transfer.record.receipt, manifest: transfer.record.manifest });
+        }).catch(() => undefined);
+    }
+    return recovered;
+}