@playcraft/cli 0.1.53-beta → 0.1.54

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

@@ -1,389 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { link, lstat, mkdir, open, readdir, realpath, rename, rm, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { ASSET_TRANSFER_BODY_MAX_BYTES, ASSET_TRANSFER_CHUNK_BYTES, ASSET_TRANSFER_FILE_MAX_BYTES, assetBundleReceiptSchema, assetTransferChunkSchema, assetTransferManifestSchema, assetTransferStatusSchema, hashAssetTransferManifest, isAssetBundleReceiptForManifest, } from '@playcraft/common/cloud-workspace/runtime';
-export class AssetTransferError extends Error {
-    code;
-    status;
-    constructor(code, status = 409) {
-        super(code);
-        this.code = code;
-        this.status = status;
-    }
-}
-const locks = new Map();
-export const ASSET_TRANSFER_MAX_ACTIVE = 4;
-export const ASSET_TRANSFER_TTL_MS = 24 * 60 * 60 * 1000;
-export const assetTransferMissing = (error) => error?.code === 'ENOENT';
-const failPath = () => { throw new AssetTransferError('invalid_workspace_path', 400); };
-/** Every path component is checked before use, including the private transfer directory. */
-export async function safeAssetTransferDirectory(root, path = '', create = false) {
-    const rootStat = await lstat(root);
-    if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || await realpath(root) !== root)
-        failPath();
-    let current = root;
-    for (const part of path.split('/').filter(Boolean)) {
-        if (part === '.' || part === '..' || /[\\:\x00-\x1f\x7f]/.test(part))
-            failPath();
-        current = join(current, part);
-        if (create)
-            await mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST')
-                throw error; });
-        const stat = await lstat(current);
-        if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(current) !== current)
-            failPath();
-    }
-    return current;
-}
-export async function syncAssetTransferDirectory(path) {
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function hashAssetTransferFile(path, limit = ASSET_TRANSFER_FILE_MAX_BYTES, allowLinks = false, expectedChunks) {
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const before = await handle.stat();
-        if (!before.isFile() || !allowLinks && before.nlink !== 1 || before.size > limit)
-            failPath();
-        const hash = createHash('sha256');
-        let chunkHash = createHash('sha256'), chunkBytes = 0, chunkIndex = 0;
-        const buffer = Buffer.allocUnsafe(64 * 1024);
-        let size = 0;
-        for (;;) {
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, size);
-            if (!bytesRead)
-                break;
-            size += bytesRead;
-            if (size > limit)
-                throw new AssetTransferError('asset_transfer_too_large', 413);
-            hash.update(buffer.subarray(0, bytesRead));
-            if (expectedChunks) {
-                let offset = 0;
-                while (offset < bytesRead) {
-                    const length = Math.min(bytesRead - offset, ASSET_TRANSFER_CHUNK_BYTES - chunkBytes);
-                    chunkHash.update(buffer.subarray(offset, offset + length));
-                    chunkBytes += length;
-                    offset += length;
-                    if (chunkBytes === ASSET_TRANSFER_CHUNK_BYTES) {
-                        if (chunkHash.digest('hex') !== expectedChunks[chunkIndex++])
-                            throw new AssetTransferError('asset_transfer_content_mismatch');
-                        chunkHash = createHash('sha256');
-                        chunkBytes = 0;
-                    }
-                }
-            }
-        }
-        const after = await handle.stat();
-        if (size !== before.size || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
-            throw new AssetTransferError('content_conflict');
-        if (expectedChunks && (chunkBytes && chunkHash.digest('hex') !== expectedChunks[chunkIndex++] || chunkIndex !== expectedChunks.length))
-            throw new AssetTransferError('asset_transfer_content_mismatch');
-        return { dev: before.dev, ino: before.ino, size, contentHash: hash.digest('hex') };
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function saveAssetTransfer(transfer) {
-    await safeAssetTransferDirectory(transfer.directory);
-    const temporary = join(transfer.directory, `record-${randomUUID()}.tmp`);
-    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-    try {
-        await handle.writeFile(JSON.stringify(transfer.record));
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    await safeAssetTransferDirectory(transfer.directory);
-    await rename(temporary, join(transfer.directory, 'record.json'));
-    await syncAssetTransferDirectory(transfer.directory);
-}
-async function readRecord(directory) {
-    const handle = await open(join(directory, 'record.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || ![1, 2].includes(stat.nlink) || stat.size > ASSET_TRANSFER_BODY_MAX_BYTES * 4)
-            throw new AssetTransferError('invalid_asset_transfer', 400);
-        const value = JSON.parse(await handle.readFile('utf8'));
-        const manifest = assetTransferManifestSchema.parse(value.manifest);
-        if (value.version !== 1 || value.manifestHash !== hashAssetTransferManifest(manifest)
-            || !['uploading', 'publishing', 'completed'].includes(value.status))
-            throw new AssetTransferError('invalid_asset_transfer', 400);
-        if (value.receipt)
-            value.receipt = assetBundleReceiptSchema.parse(value.receipt);
-        if (!Number.isFinite(value.createdAt) || value.status === 'completed'
-            && !isAssetBundleReceiptForManifest(manifest, value.manifestHash, value.receipt)
-            || value.status !== 'completed' && value.receipt)
-            throw new AssetTransferError('invalid_asset_transfer', 400);
-        if (stat.nlink === 2) {
-            // Creation uses an exclusive link so the same identifier can never replace a session.
-            // A crash before unlinking that private temporary name must remain resumable.
-            let repaired = false;
-            for (const name of await readdir(directory)) {
-                if (!/^create-[a-f0-9-]{36}\.tmp$/i.test(name))
-                    continue;
-                const alias = join(directory, name), linked = await lstat(alias);
-                if (!linked.isFile() || linked.isSymbolicLink() || linked.dev !== stat.dev || linked.ino !== stat.ino || linked.nlink !== 2)
-                    continue;
-                await unlink(alias);
-                await syncAssetTransferDirectory(directory);
-                repaired = true;
-                break;
-            }
-            if (!repaired || (await handle.stat()).nlink !== 1)
-                throw new AssetTransferError('invalid_asset_transfer', 400);
-        }
-        value.manifest = manifest;
-        return value;
-    }
-    finally {
-        await handle.close();
-    }
-}
-function validId(id) {
-    if (!/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(id))
-        throw new AssetTransferError('invalid_asset_transfer', 400);
-}
-export async function withAssetTransfer(root, scope, id, action) {
-    validId(id);
-    const key = `${root}\0${id}`;
-    const previous = locks.get(key) ?? Promise.resolve();
-    const next = previous.catch(() => undefined).then(async () => {
-        const rootReal = await realpath(root);
-        let directory;
-        try {
-            directory = await safeAssetTransferDirectory(rootReal, `.playcraft-temp/asset-transfers/${id}`);
-        }
-        catch (error) {
-            if (assetTransferMissing(error))
-                throw new AssetTransferError('asset_transfer_not_found', 404);
-            throw error;
-        }
-        let record;
-        try {
-            record = await readRecord(directory);
-        }
-        catch (error) {
-            if (assetTransferMissing(error))
-                throw new AssetTransferError('asset_transfer_not_found', 404);
-            throw error;
-        }
-        if (record.manifest.transferId !== id || Object.keys(scope).some(key => record.scope?.[key] !== scope[key]))
-            throw new AssetTransferError('asset_transfer_not_found', 404);
-        if (record.status === 'uploading' && !record.publication && Date.now() - record.createdAt > ASSET_TRANSFER_TTL_MS) {
-            await rm(directory, { recursive: true });
-            throw new AssetTransferError('asset_transfer_expired', 410);
-        }
-        return action({ root: rootReal, directory, record });
-    });
-    locks.set(key, next);
-    try {
-        return await next;
-    }
-    finally {
-        if (locks.get(key) === next)
-            locks.delete(key);
-    }
-}
-async function saveProgress(transfer, files) {
-    const temporary = join(transfer.directory, `progress-${randomUUID()}.tmp`);
-    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-    try {
-        await handle.writeFile(JSON.stringify(files));
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    await safeAssetTransferDirectory(transfer.directory);
-    await rename(temporary, join(transfer.directory, 'progress.json'));
-    await syncAssetTransferDirectory(transfer.directory);
-}
-async function readProgress(transfer) {
-    try {
-        const handle = await open(join(transfer.directory, 'progress.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            const stat = await handle.stat();
-            if (!stat.isFile() || stat.nlink !== 1 || stat.size > 256 * 1024)
-                return undefined;
-            const files = JSON.parse(await handle.readFile('utf8'));
-            if (!Array.isArray(files) || files.length !== transfer.record.manifest.files.length
-                || files.some((file, index) => file.fileIndex !== index || !Array.isArray(file.receivedChunks)
-                    || file.receivedChunks.some(chunk => !Number.isInteger(chunk) || chunk < 0 || chunk >= transfer.record.manifest.files[index].chunkHashes.length)))
-                return undefined;
-            return files;
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function assetTransferView(transfer, scan = true) {
-    const { record } = transfer;
-    let files = record.status === 'completed'
-        ? record.manifest.files.map((file, fileIndex) => ({ fileIndex, receivedChunks: file.chunkHashes.map((_, index) => index) }))
-        : scan ? undefined : await readProgress(transfer);
-    if (!files) {
-        files = [];
-        for (const [fileIndex, file] of record.manifest.files.entries()) {
-            const receivedChunks = [];
-            for (const [chunkIndex, expected] of file.chunkHashes.entries()) {
-                try {
-                    await safeAssetTransferDirectory(transfer.directory, 'chunks');
-                    const chunk = await hashAssetTransferFile(join(transfer.directory, 'chunks', `${fileIndex}-${chunkIndex}`), ASSET_TRANSFER_CHUNK_BYTES);
-                    const size = Math.min(ASSET_TRANSFER_CHUNK_BYTES, file.size - chunkIndex * ASSET_TRANSFER_CHUNK_BYTES);
-                    if (chunk.contentHash === expected && chunk.size === size)
-                        receivedChunks.push(chunkIndex);
-                }
-                catch (error) {
-                    if (!assetTransferMissing(error))
-                        throw error;
-                }
-            }
-            files.push({ fileIndex, receivedChunks });
-        }
-        await saveProgress(transfer, files);
-    }
-    const ready = files.every(file => file.receivedChunks.length === record.manifest.files[file.fileIndex].chunkHashes.length);
-    return assetTransferStatusSchema.parse({ transferId: record.manifest.transferId, manifestHash: record.manifestHash,
-        status: record.status === 'uploading' ? ready ? 'ready' : 'uploading' : record.status, files,
-        ...(record.receipt ? { receipt: record.receipt } : {}) });
-}
-async function createAssetTransferUnlocked(root, scope, input) {
-    const manifest = assetTransferManifestSchema.parse(input);
-    if ([...manifest.files.map(file => file.path), ...(manifest.directories ?? [])].some(path => /[\x00-\x1f\x7f]/.test(path)))
-        failPath();
-    const rootReal = await realpath(root);
-    const parent = await safeAssetTransferDirectory(rootReal, '.playcraft-temp/asset-transfers', true);
-    const present = await lstat(join(parent, manifest.transferId)).catch(error => { if (assetTransferMissing(error))
-        return undefined; throw error; });
-    if (!present) {
-        let active = 0;
-        for (const item of await readdir(parent, { withFileTypes: true })) {
-            if (!item.isDirectory())
-                continue;
-            try {
-                const directory = await safeAssetTransferDirectory(parent, item.name);
-                const record = await readRecord(directory);
-                if (record.status === 'uploading' && !record.publication && Date.now() - record.createdAt > ASSET_TRANSFER_TTL_MS) {
-                    await rm(directory, { recursive: true });
-                    continue;
-                }
-                if (record.status !== 'completed')
-                    active++;
-            }
-            catch {
-                active++;
-            }
-        }
-        if (active >= ASSET_TRANSFER_MAX_ACTIVE)
-            throw new AssetTransferError('asset_transfer_session_limit');
-    }
-    const directory = await safeAssetTransferDirectory(rootReal, `.playcraft-temp/asset-transfers/${manifest.transferId}`, true);
-    const record = { version: 1, createdAt: Date.now(), scope, manifest, manifestHash: hashAssetTransferManifest(manifest), status: 'uploading' };
-    const temporary = join(directory, `create-${randomUUID()}.tmp`);
-    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-    try {
-        await handle.writeFile(JSON.stringify(record));
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    try {
-        await link(temporary, join(directory, 'record.json'));
-        await syncAssetTransferDirectory(directory);
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-    }
-    finally {
-        await unlink(temporary).catch(() => undefined);
-    }
-    return withAssetTransfer(rootReal, scope, manifest.transferId, async (transfer) => {
-        if (transfer.record.manifestHash !== record.manifestHash)
-            throw new AssetTransferError('asset_transfer_manifest_conflict');
-        return assetTransferView(transfer);
-    });
-}
-export async function createAssetTransfer(root, scope, input) {
-    const key = `${await realpath(root)}\0create`;
-    const previous = locks.get(key) ?? Promise.resolve();
-    const next = previous.catch(() => undefined).then(() => createAssetTransferUnlocked(root, scope, input));
-    locks.set(key, next);
-    try {
-        return await next;
-    }
-    finally {
-        if (locks.get(key) === next)
-            locks.delete(key);
-    }
-}
-export const getAssetTransfer = (root, scope, id) => withAssetTransfer(root, scope, id, assetTransferView);
-async function acknowledgeChunk(transfer, fileIndex, chunkIndex) {
-    const files = await readProgress(transfer);
-    if (!files)
-        return assetTransferView(transfer);
-    if (!files[fileIndex].receivedChunks.includes(chunkIndex)) {
-        files[fileIndex].receivedChunks = [...files[fileIndex].receivedChunks, chunkIndex].sort((a, b) => a - b);
-        await saveProgress(transfer, files);
-    }
-    return assetTransferView(transfer, false);
-}
-export async function putAssetTransferChunk(root, scope, id, input) {
-    const chunk = assetTransferChunkSchema.parse(input);
-    return withAssetTransfer(root, scope, id, async (transfer) => {
-        if (transfer.record.status === 'publishing')
-            throw new AssetTransferError('asset_transfer_busy');
-        const file = transfer.record.manifest.files[chunk.fileIndex];
-        const expected = file?.chunkHashes[chunk.chunkIndex];
-        const bytes = Buffer.from(chunk.contentBase64, 'base64');
-        if (!file || !expected || bytes.length !== Math.min(ASSET_TRANSFER_CHUNK_BYTES, file.size - chunk.chunkIndex * ASSET_TRANSFER_CHUNK_BYTES)
-            || createHash('sha256').update(bytes).digest('hex') !== expected || bytes.toString('base64') !== chunk.contentBase64)
-            throw new AssetTransferError('asset_transfer_chunk_mismatch');
-        if (transfer.record.status === 'completed')
-            return assetTransferView(transfer, false);
-        const directory = await safeAssetTransferDirectory(transfer.directory, 'chunks', true);
-        const destination = join(directory, `${chunk.fileIndex}-${chunk.chunkIndex}`);
-        try {
-            const stored = await hashAssetTransferFile(destination, ASSET_TRANSFER_CHUNK_BYTES);
-            if (stored.size === bytes.length && stored.contentHash === expected)
-                return acknowledgeChunk(transfer, chunk.fileIndex, chunk.chunkIndex);
-        }
-        catch (error) {
-            if (!assetTransferMissing(error))
-                throw error;
-        }
-        const temporary = join(directory, `chunk-${randomUUID()}.tmp`);
-        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-        try {
-            await handle.writeFile(bytes);
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-        await safeAssetTransferDirectory(transfer.directory, 'chunks');
-        await rename(temporary, destination);
-        await syncAssetTransferDirectory(directory);
-        return acknowledgeChunk(transfer, chunk.fileIndex, chunk.chunkIndex);
-    });
-}
-export const cancelAssetTransfer = (root, scope, id) => withAssetTransfer(root, scope, id, async (transfer) => {
-    if (transfer.record.status === 'publishing')
-        throw new AssetTransferError('asset_transfer_busy');
-    await safeAssetTransferDirectory(transfer.directory);
-    await rm(transfer.directory, { recursive: true });
-    return { cancelled: true };
-});

package/dist/workspace-runtime/workspaces/attachment-content.js

@@ -1,73 +0,0 @@
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
-import { extname } from 'node:path';
-import { attachmentIdsSchema, attachmentUploadSchema, WORKSPACE_ATTACHMENT_MAX_BYTES, WORKSPACE_USER_UPLOADS_DIRECTORY, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES, } from '@playcraft/common/cloud-workspace/runtime';
-import { artifactMime, artifactPath } from './artifact-files.js';
-import { openLibraryAttachmentFile, readLibraryAttachmentMetadata } from './library-attachments.js';
-import { openWorkspaceDirectoryFile, readWorkspaceDirectoryMetadata } from './directory-attachments.js';
-import { serveOpenedWorkspaceContent } from './binary-content.js';
-const additionalMediaTypes = {
-    '.aac': 'audio/aac', '.opus': 'audio/ogg', '.oga': 'audio/ogg', '.aif': 'audio/aiff', '.aiff': 'audio/aiff',
-    '.bmp': 'image/bmp', '.ico': 'image/vnd.microsoft.icon', '.heic': 'image/heic', '.heif': 'image/heif',
-    '.tif': 'image/tiff', '.tiff': 'image/tiff',
-};
-const detectedImageTypes = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
-async function openAttachment(root, id, filePath) {
-    const metadataPath = await artifactPath(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata/${id}.json`);
-    const metadataFile = await open(metadataPath, constants.O_RDONLY | constants.O_NOFOLLOW);
-    let metadata;
-    try {
-        const stat = await metadataFile.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-            throw new Error('attachment_unavailable');
-        metadata = JSON.parse(await metadataFile.readFile('utf8'));
-        if (metadata.id !== id || !attachmentUploadSchema.shape.name.safeParse(metadata.name).success)
-            throw new Error('attachment_unavailable');
-    }
-    finally {
-        await metadataFile.close();
-    }
-    if (metadata.origin?.kind === 'asset-library') {
-        const library = await readLibraryAttachmentMetadata(root, id);
-        return openLibraryAttachmentFile(root, library, filePath);
-    }
-    if (metadata.kind === 'directory') {
-        const directory = await readWorkspaceDirectoryMetadata(root, id);
-        return openWorkspaceDirectoryFile(root, directory, filePath);
-    }
-    if (filePath !== undefined)
-        throw new Error('attachment_unavailable');
-    const path = await artifactPath(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}/${metadata.name}`);
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        const mimeType = detectedImageTypes.has(metadata.mimeType) ? metadata.mimeType
-            : additionalMediaTypes[extname(metadata.name).toLowerCase()] ?? artifactMime(metadata.name);
-        const limit = mimeType.startsWith('video/') ? WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES : WORKSPACE_ATTACHMENT_MAX_BYTES;
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size !== metadata.size || stat.size > limit)
-            throw new Error('attachment_unavailable');
-        return { handle, name: metadata.name, mimeType, size: stat.size };
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
-    }
-}
-/** Serve only registered references; no caller-supplied file paths reach the filesystem. */
-export async function serveWorkspaceAttachment(root, attachmentId, request, response, filePath) {
-    if (!attachmentIdsSchema.safeParse([attachmentId]).success) {
-        response.writeHead(400, { 'content-type': 'application/json', 'cache-control': 'no-store' });
-        response.end(JSON.stringify({ error: 'invalid_attachment' }));
-        return;
-    }
-    let content;
-    try {
-        content = await openAttachment(root, attachmentId, filePath);
-    }
-    catch {
-        response.writeHead(404, { 'content-type': 'application/json', 'cache-control': 'no-store' });
-        response.end(JSON.stringify({ error: 'attachment_not_found' }));
-        return;
-    }
-    await serveOpenedWorkspaceContent(content, request, response);
-}

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

@@ -1,185 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { chmod, lstat, mkdir, open, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { WORKSPACE_USER_UPLOADS_DIRECTORY, attachmentIdsSchema, attachmentUploadSchema, WORKSPACE_ATTACHMENT_MAX_BYTES, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES, WORKSPACE_VIDEO_ATTACHMENT_MIME_TYPES, workspaceVideoAttachmentQuerySchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { NativePreparationError } from '../codex/native-adapter.js';
-import { excludeFromGit } from './dependencies.js';
-import { hashAttachment, probeAttachmentVideo } from './video-attachments.js';
-import { resolveLibraryAttachment } from './library-attachments.js';
-import { resolveWorkspaceDirectoryAttachment } from './directory-attachments.js';
-async function attachmentRoot(root) {
-    // Reject redirected upload directories, including symlinks that stay inside the workspace.
-    let directory = root;
-    for (const part of WORKSPACE_USER_UPLOADS_DIRECTORY.split('/')) {
-        directory = join(directory, part);
-        await mkdir(directory, { mode: 0o755 }).catch((error) => {
-            if (error.code !== 'EEXIST')
-                throw error;
-        });
-        if (!(await lstat(directory)).isDirectory())
-            throw new Error('invalid_attachment');
-        await chmod(directory, 0o755);
-    }
-    return directory;
-}
-export function imageMime(bytes) {
-    if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
-        return 'image/png';
-    if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255)
-        return 'image/jpeg';
-    if (/^GIF8[79]a$/.test(bytes.subarray(0, 6).toString('ascii')))
-        return 'image/gif';
-    if (bytes.subarray(0, 4).toString() === 'RIFF' && bytes.subarray(8, 12).toString() === 'WEBP')
-        return 'image/webp';
-    return 'application/octet-stream';
-}
-export async function readAttachmentUpload(request) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of request) {
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        size += bytes.length;
-        if (size > 4 * Math.ceil(WORKSPACE_ATTACHMENT_MAX_BYTES / 3) + 4096)
-            throw new Error('invalid_attachment');
-        chunks.push(bytes);
-    }
-    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-}
-/** References belong to the workspace and are retained by its checkpoints. */
-export async function uploadWorkspaceAttachment(root, body) {
-    const parsed = attachmentUploadSchema.parse(body);
-    const bytes = Buffer.from(parsed.content, 'base64');
-    if (bytes.length > WORKSPACE_ATTACHMENT_MAX_BYTES || bytes.toString('base64') !== parsed.content)
-        throw new Error('invalid_attachment');
-    const attachment = {
-        id: randomUUID(),
-        name: parsed.name,
-        size: bytes.length,
-        mimeType: imageMime(bytes),
-    };
-    await excludeFromGit(root, `/${WORKSPACE_USER_UPLOADS_DIRECTORY}/`);
-    const uploads = await attachmentRoot(root);
-    const directory = join(uploads, attachment.id);
-    const metadataDirectory = join(uploads, '.metadata');
-    await mkdir(metadataDirectory, { mode: 0o755 }).catch((error) => {
-        if (error.code !== 'EEXIST')
-            throw error;
-    });
-    if (!(await lstat(metadataDirectory)).isDirectory())
-        throw new Error('invalid_attachment');
-    // Codex can run as a different user from the sandbox control process.
-    await mkdir(directory, { mode: 0o755 });
-    await writeFile(join(directory, attachment.name), bytes, { flag: 'wx', mode: 0o644 });
-    await writeFile(join(metadataDirectory, `${attachment.id}.json`), JSON.stringify(attachment), {
-        flag: 'wx',
-        mode: 0o644,
-    });
-    return attachment;
-}
-/** Video bodies are streamed into an unpublished attachment and never decoded as base64. */
-export async function uploadWorkspaceVideoAttachment(root, request, query) {
-    const { name } = workspaceVideoAttachmentQuerySchema.parse(query);
-    const contentType = String(request.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase();
-    const declaredSize = request.headers['content-length'];
-    if (!WORKSPACE_VIDEO_ATTACHMENT_MIME_TYPES.includes(contentType)
-        || (declaredSize !== undefined && (!/^\d+$/.test(declaredSize) || Number(declaredSize) > WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES)))
-        throw new Error('invalid_attachment');
-    await excludeFromGit(root, `/${WORKSPACE_USER_UPLOADS_DIRECTORY}/`);
-    const uploads = await attachmentRoot(root);
-    const id = randomUUID(), directory = join(uploads, id), metadataDirectory = join(uploads, '.metadata');
-    await mkdir(metadataDirectory, { mode: 0o755 }).catch((error) => { if (error.code !== 'EEXIST')
-        throw error; });
-    if (!(await lstat(metadataDirectory)).isDirectory())
-        throw new Error('invalid_attachment');
-    await mkdir(directory, { mode: 0o755 });
-    const handle = await open(join(directory, name), constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | constants.O_NOFOLLOW, 0o644);
-    try {
-        let size = 0;
-        for await (const data of request) {
-            const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data);
-            size += bytes.length;
-            if (size > WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES)
-                throw new Error('invalid_attachment');
-            let offset = 0;
-            while (offset < bytes.length)
-                offset += (await handle.write(bytes, offset, bytes.length - offset, size - bytes.length + offset)).bytesWritten;
-        }
-        if (!size || (declaredSize !== undefined && Number(declaredSize) !== size))
-            throw new Error('invalid_attachment');
-        await handle.sync();
-        const media = await probeAttachmentVideo(handle);
-        if (contentType !== media.mimeType && !(contentType === 'video/quicktime' && media.mimeType === 'video/mp4'))
-            throw new Error('invalid_attachment');
-        const attachment = { id, name, size, ...media, sha256: await hashAttachment(handle) };
-        await writeFile(join(metadataDirectory, `${id}.json`), JSON.stringify(attachment), { flag: 'wx', mode: 0o644 });
-        return attachment;
-    }
-    catch (error) {
-        await rm(directory, { recursive: true, force: true });
-        throw error;
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function resolveWorkspaceAttachments(root, input) {
-    try {
-        const ids = attachmentIdsSchema.parse(input ?? []);
-        const attachments = await Promise.all(ids.map(async (id) => {
-            const uploads = await attachmentRoot(root);
-            const directory = join(uploads, id);
-            if (!(await lstat(directory)).isDirectory())
-                throw new Error('invalid_attachment');
-            await chmod(directory, 0o755);
-            if (!(await lstat(join(uploads, '.metadata'))).isDirectory())
-                throw new Error('invalid_attachment');
-            const metadataHandle = await open(join(uploads, '.metadata', `${id}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
-            let metadata;
-            try {
-                const stat = await metadataHandle.stat();
-                if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-                    throw new Error('invalid_attachment');
-                metadata = JSON.parse(await metadataHandle.readFile('utf8'));
-            }
-            finally {
-                await metadataHandle.close();
-            }
-            if (metadata.origin?.kind === 'asset-library')
-                return resolveLibraryAttachment(root, id);
-            if (metadata.kind === 'directory')
-                return resolveWorkspaceDirectoryAttachment(root, id);
-            attachmentUploadSchema.shape.name.parse(metadata.name);
-            if (metadata.id !== id)
-                throw new Error('invalid_attachment');
-            const path = join(directory, metadata.name);
-            const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-            try {
-                const stat = await handle.stat();
-                const video = metadata.mimeType?.startsWith('video/');
-                if (!stat.isFile() || stat.nlink !== 1 || stat.size !== metadata.size || stat.size > (video ? WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES : WORKSPACE_ATTACHMENT_MAX_BYTES))
-                    throw new Error('invalid_attachment');
-                if (video) {
-                    const media = await probeAttachmentVideo(handle);
-                    const sha256 = await hashAttachment(handle);
-                    if (sha256 !== metadata.sha256 || media.mimeType !== metadata.mimeType || media.durationMs !== metadata.durationMs
-                        || media.width !== metadata.width || media.height !== metadata.height)
-                        throw new Error('invalid_attachment');
-                    return { ...metadata, ...media, path };
-                }
-                const bytes = Buffer.alloc(12);
-                const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
-                return { ...metadata, size: stat.size, mimeType: imageMime(bytes.subarray(0, bytesRead)), path };
-            }
-            finally {
-                await handle.close();
-            }
-        }));
-        if (attachments.reduce((total, attachment) => total + attachment.size, 0) > WORKSPACE_ATTACHMENT_MAX_BYTES)
-            throw new Error('invalid_attachment');
-        return attachments;
-    }
-    catch {
-        throw new NativePreparationError('attachment_unavailable');
-    }
-}