@playcraft/cli 0.1.33 → 0.1.35-prod

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

@@ -1,56 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { chmod, lstat, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { resolveCliPackageRoot } from '../../scaffold/compose.js';
-const START = '<!-- playcraft:workspace-artifacts:start -->';
-const END = '<!-- playcraft:workspace-artifacts:end -->';
-/** Refresh only the platform-owned section; project and user instructions remain intact. */
-export async function ensureWorkspaceArtifactInstructions(root) {
-    const template = await readFile(join(resolveCliPackageRoot(), 'project-templates/empty/AGENTS.md'), 'utf8');
-    const start = template.indexOf(START), end = template.indexOf(END, start);
-    if (start < 0 || end < start)
-        throw new Error('workspace_instructions_invalid');
-    const section = template.slice(start, end + END.length);
-    const path = join(root, 'AGENTS.md');
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK).catch(error => {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw error;
-    });
-    let previous = '', mode = 0o664;
-    try {
-        if (handle) {
-            const stat = await handle.stat();
-            if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-                throw new Error('workspace_instructions_invalid');
-            mode = stat.mode & 0o777;
-            previous = await handle.readFile('utf8');
-        }
-    }
-    finally {
-        await handle?.close();
-    }
-    const existingStart = previous.indexOf(START), existingEnd = previous.indexOf(END);
-    if ((existingStart < 0) !== (existingEnd < 0) || existingEnd < existingStart ||
-        previous.indexOf(START, existingStart + START.length) >= 0 || previous.indexOf(END, existingEnd + END.length) >= 0)
-        throw new Error('workspace_instructions_invalid');
-    const next = existingStart >= 0
-        ? previous.slice(0, existingStart) + section + previous.slice(existingEnd + END.length)
-        : `${previous}${previous ? (previous.endsWith('\n') ? '\n' : '\n\n') : '# PlayCraft Workspace\n\n'}${section}\n`;
-    if (next === previous)
-        return;
-    const temporary = join(root, `.AGENTS.${randomUUID()}.tmp`);
-    try {
-        await writeFile(temporary, next, { flag: 'wx', mode });
-        await chmod(temporary, mode);
-        const current = await lstat(path).catch(error => { if (error.code === 'ENOENT')
-            return undefined; throw error; });
-        if (current && (!current.isFile() || current.isSymbolicLink() || current.nlink !== 1))
-            throw new Error('workspace_instructions_invalid');
-        await rename(temporary, path);
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}

package/dist/workspace-runtime/workspaces/json5-edit.js

@@ -1,170 +0,0 @@
-import JSON5 from 'json5';
-export class ParameterEditError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = 'ParameterEditError';
-    }
-}
-export function replaceJson5Path(source, fieldPath, value) {
-    const span = findJson5ValueSpan(source, fieldPath);
-    if (!span)
-        throw new ParameterEditError('parameter_field_missing');
-    const current = skipTrivia(source, span.start, span.end);
-    if (source[current] === '{' || source[current] === '[') {
-        throw new ParameterEditError('parameter_value_invalid');
-    }
-    return `${source.slice(0, span.start)}${formatJson5Value(value, source.slice(span.start, span.end))}${source.slice(span.end)}`;
-}
-export function findJson5ValueSpan(source, fieldPath) {
-    const start = skipTrivia(source, 0, source.length);
-    if (source[start] !== '{')
-        throw new ParameterEditError('parameter_document_invalid');
-    return findInObject(source, start, source.length, fieldPath, 0);
-}
-function findInObject(source, braceIndex, end, fieldPath, depth) {
-    let index = skipTrivia(source, braceIndex + 1, end);
-    while (index < end) {
-        if (source[index] === '}')
-            return undefined;
-        const key = parseKey(source, index, end);
-        index = skipTrivia(source, key.end, end);
-        if (source[index] !== ':')
-            throw new ParameterEditError('parameter_document_invalid');
-        const value = scanValue(source, index + 1, end);
-        if (key.name === fieldPath[depth]) {
-            if (depth === fieldPath.length - 1)
-                return value;
-            const nested = skipTrivia(source, value.start, end);
-            if (source[nested] !== '{')
-                throw new ParameterEditError('parameter_field_missing');
-            return findInObject(source, nested, value.end, fieldPath, depth + 1);
-        }
-        index = skipTrivia(source, value.end, end);
-        if (source[index] === ',')
-            index = skipTrivia(source, index + 1, end);
-    }
-    throw new ParameterEditError('parameter_document_invalid');
-}
-function parseKey(source, start, end) {
-    const index = skipTrivia(source, start, end);
-    const first = source[index];
-    if (first === '"' || first === "'") {
-        const close = stringEnd(source, index, end);
-        return { name: JSON5.parse(source.slice(index, close)), end: close };
-    }
-    if (!/[A-Za-z_$]/.test(first ?? ''))
-        throw new ParameterEditError('parameter_document_invalid');
-    let cursor = index + 1;
-    while (cursor < end && /[A-Za-z0-9_$]/.test(source[cursor]))
-        cursor += 1;
-    return { name: source.slice(index, cursor), end: cursor };
-}
-function scanValue(source, from, end) {
-    const start = skipTrivia(source, from, end);
-    const first = source[start];
-    if (first === '"' || first === "'")
-        return { start, end: stringEnd(source, start, end) };
-    if (first === '{' || first === '[')
-        return { start, end: balancedEnd(source, start, end) };
-    let cursor = start;
-    while (cursor < end) {
-        const current = source[cursor];
-        if (/\s/.test(current) || current === ',' || current === '}' || current === ']' || current === '/')
-            break;
-        cursor += 1;
-    }
-    if (cursor === start)
-        throw new ParameterEditError('parameter_document_invalid');
-    return { start, end: cursor };
-}
-function balancedEnd(source, start, end) {
-    const open = source[start];
-    const close = open === '{' ? '}' : ']';
-    let depth = 0;
-    let index = start;
-    while (index < end) {
-        const current = source[index];
-        if (current === '"' || current === "'") {
-            index = stringEnd(source, index, end);
-            continue;
-        }
-        if (current === '/' && source[index + 1] === '/') {
-            index = skipTrivia(source, index, end);
-            continue;
-        }
-        if (current === '/' && source[index + 1] === '*') {
-            index = skipTrivia(source, index, end);
-            continue;
-        }
-        if (current === open)
-            depth += 1;
-        else if (current === close) {
-            depth -= 1;
-            if (depth === 0)
-                return index + 1;
-        }
-        index += 1;
-    }
-    throw new ParameterEditError('parameter_document_invalid');
-}
-function stringEnd(source, start, end) {
-    const quote = source[start];
-    let index = start + 1;
-    while (index < end) {
-        const current = source[index];
-        if (current === '\\') {
-            index += 2;
-            continue;
-        }
-        if (current === quote)
-            return index + 1;
-        index += 1;
-    }
-    throw new ParameterEditError('parameter_document_invalid');
-}
-function skipTrivia(source, start, end) {
-    let index = start;
-    while (index < end) {
-        const current = source[index];
-        if (/\s/.test(current)) {
-            index += 1;
-            continue;
-        }
-        if (current === '/' && source[index + 1] === '/') {
-            index += 2;
-            while (index < end && source[index] !== '\n')
-                index += 1;
-            continue;
-        }
-        if (current === '/' && source[index + 1] === '*') {
-            const close = source.indexOf('*/', index + 2);
-            if (close < 0 || close >= end)
-                throw new ParameterEditError('parameter_document_invalid');
-            index = close + 2;
-            continue;
-        }
-        break;
-    }
-    return index;
-}
-function formatJson5Value(value, previous) {
-    if (typeof value === 'string') {
-        const trimmed = previous.trim();
-        if (trimmed.startsWith("'")) {
-            return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
-        }
-        return JSON.stringify(value);
-    }
-    if (typeof value === 'boolean' || value === null)
-        return String(value);
-    const trimmed = previous.trim();
-    if (/^[-+]?0x[0-9a-fA-F]+$/.test(trimmed) && Number.isInteger(value)) {
-        const sign = value < 0 ? '-' : trimmed.startsWith('+') ? '+' : '';
-        const hex = Math.abs(value).toString(16);
-        const upper = /[A-F]/.test(trimmed) && !/[a-f]/.test(trimmed);
-        return `${sign}0x${upper ? hex.toUpperCase() : hex}`;
-    }
-    return Number.isInteger(value) ? String(value) : JSON.stringify(value);
-}

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

@@ -1,268 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { chmod, lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { WORKSPACE_USER_UPLOADS_DIRECTORY, WORKSPACE_LIBRARY_ATTACHMENT_MAX_BYTES, WORKSPACE_ATTACHMENT_MAX_COUNT, workspaceAttachmentSchema, workspaceLibraryAttachmentUploadSchema, workspaceLibraryFilePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { excludeFromGit } from './dependencies.js';
-const METADATA_MAX_BYTES = 1024 * 1024;
-const locks = new Map();
-const hash = (bytes) => createHash('sha256').update(bytes).digest('hex');
-async function safeDirectory(root, path, create = false) {
-    let directory = root;
-    for (const part of path.split('/').filter(Boolean)) {
-        directory = join(directory, part);
-        if (create)
-            await mkdir(directory, { mode: 0o755 }).catch((error) => {
-                if (error.code !== 'EEXIST')
-                    throw error;
-            });
-        const stat = await lstat(directory);
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            throw new Error('invalid_library_attachment');
-    }
-    return directory;
-}
-async function metadataDirectory(root, create = false) {
-    return safeDirectory(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata`, create);
-}
-export async function readLibraryAttachmentMetadata(root, id) {
-    if (!/^[a-f0-9-]{36}$/.test(id))
-        throw new Error('invalid_library_attachment');
-    const directory = await metadataDirectory(root);
-    const handle = await open(join(directory, `${id}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > METADATA_MAX_BYTES)
-            throw new Error('invalid_library_attachment');
-        const raw = JSON.parse(await handle.readFile('utf8'));
-        const { sessionIds, unbound, clientRequestIds = [], ...publicFields } = raw;
-        const attachment = workspaceAttachmentSchema.parse(publicFields);
-        if (attachment.id !== id || !attachment.origin || !['file', 'bundle'].includes(attachment.kind ?? '') || !attachment.files?.length)
-            throw new Error('invalid_library_attachment');
-        const prefix = `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}`;
-        const expected = attachment.kind === 'bundle' ? prefix : `${prefix}/${attachment.files[0].path}`;
-        if (attachment.path !== expected || (attachment.kind === 'file' && attachment.files.length !== 1))
-            throw new Error('invalid_library_attachment');
-        if (!Array.isArray(sessionIds) || sessionIds.some(session => typeof session !== 'string' || session.length > 128))
-            throw new Error('invalid_library_attachment');
-        if (!Array.isArray(clientRequestIds) || clientRequestIds.some(id => typeof id !== 'string' || !/^[a-f0-9-]{36}$/.test(id)))
-            throw new Error('invalid_library_attachment');
-        return { ...attachment, sessionIds: sessionIds, unbound: unbound === true, clientRequestIds: clientRequestIds };
-    }
-    finally {
-        await handle.close();
-    }
-}
-function publicAttachment({ sessionIds: _sessionIds, unbound: _unbound, clientRequestIds: _clientRequestIds, ...attachment }) {
-    return attachment;
-}
-export async function openLibraryAttachmentFile(root, attachment, filePath) {
-    const selected = filePath ?? (attachment.kind === 'file' ? attachment.files?.[0]?.path : undefined);
-    const file = attachment.files?.find(file => file.path === selected);
-    if (!file || !workspaceLibraryFilePathSchema.safeParse(selected).success)
-        throw new Error('attachment_unavailable');
-    const relative = `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${attachment.id}/${file.path}`;
-    await safeDirectory(root, dirname(relative));
-    const handle = await open(join(root, relative), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size !== file.size || stat.size > WORKSPACE_LIBRARY_ATTACHMENT_MAX_BYTES)
-            throw new Error('attachment_unavailable');
-        return { handle, name: file.path.split('/').at(-1), mimeType: file.mimeType, size: file.size, sha256: file.sha256 };
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
-    }
-}
-export async function resolveLibraryAttachment(root, id) {
-    const record = await readLibraryAttachmentMetadata(root, id);
-    let total = 0;
-    for (const file of record.files) {
-        const opened = await openLibraryAttachmentFile(root, record, file.path);
-        try {
-            if (hash(await opened.handle.readFile()) !== file.sha256)
-                throw new Error('library_asset_changed');
-            total += file.size;
-        }
-        finally {
-            await opened.handle.close();
-        }
-    }
-    if (total !== record.size || total > WORKSPACE_LIBRARY_ATTACHMENT_MAX_BYTES)
-        throw new Error('invalid_library_attachment');
-    return { ...publicAttachment(record), path: join(root, record.path) };
-}
-async function listLibraryRecords(root, sessionId) {
-    let directory;
-    try {
-        directory = await metadataDirectory(root);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const attachments = [];
-    for (const name of await readdir(directory)) {
-        if (!/^[a-f0-9-]{36}\.json$/.test(name))
-            continue;
-        try {
-            const record = await readLibraryAttachmentMetadata(root, name.slice(0, -5));
-            if (record.unbound || (sessionId && record.sessionIds.includes(sessionId)))
-                attachments.push(record);
-        }
-        catch { /* Legacy upload metadata and incomplete records are not library sources. */ }
-    }
-    return attachments.sort((a, b) => b.origin.importedAt.localeCompare(a.origin.importedAt));
-}
-export async function listWorkspaceLibraryAttachments(root, sessionId) {
-    return (await listLibraryRecords(root, sessionId)).map(publicAttachment);
-}
-export async function listWorkspaceLibraryImportReceipts(root, sessionId) {
-    const receipts = new Map();
-    for (const record of await listLibraryRecords(root, sessionId)) {
-        for (const id of record.clientRequestIds)
-            receipts.set(id, [...(receipts.get(id) ?? []), record.id]);
-    }
-    return [...receipts].map(([clientRequestId, attachmentIds]) => ({ clientRequestId, attachmentIds }));
-}
-function attachmentId(asset) {
-    const hex = hash(JSON.stringify([asset.assetId, asset.contentHash])).slice(0, 32).split('');
-    hex[12] = '5';
-    hex[16] = ['8', '9', 'a', 'b'][parseInt(hex[16], 16) % 4];
-    const value = hex.join('');
-    return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
-}
-async function importAttachment(root, body) {
-    const { asset, sessionId, clientRequestId } = workspaceLibraryAttachmentUploadSchema.parse(body);
-    const previousImports = (await listLibraryRecords(root, sessionId)).filter(record => record.clientRequestIds.includes(clientRequestId));
-    const replay = previousImports.find(record => record.origin.assetId === asset.assetId);
-    if (replay) {
-        await resolveLibraryAttachment(root, replay.id);
-        return publicAttachment(replay);
-    }
-    if (previousImports.length >= WORKSPACE_ATTACHMENT_MAX_COUNT)
-        throw new Error('library_attachment_limit');
-    const files = asset.files.map(file => {
-        const bytes = Buffer.from(file.content, 'base64');
-        if (bytes.toString('base64') !== file.content || hash(bytes) !== file.sha256)
-            throw new Error('library_asset_changed');
-        return { ...file, bytes };
-    });
-    const size = files.reduce((sum, file) => sum + file.bytes.length, 0);
-    if (size > WORKSPACE_LIBRARY_ATTACHMENT_MAX_BYTES)
-        throw new Error('library_asset_too_large');
-    const contentHash = hash(JSON.stringify(files.map(file => [file.path, file.sha256]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
-    if (asset.contentHash !== contentHash)
-        throw new Error('library_asset_changed');
-    const id = attachmentId(asset);
-    await excludeFromGit(root, `/${WORKSPACE_USER_UPLOADS_DIRECTORY}/`);
-    const uploads = await safeDirectory(root, WORKSPACE_USER_UPLOADS_DIRECTORY, true);
-    const metadata = await metadataDirectory(root, true);
-    let record;
-    try {
-        record = await readLibraryAttachmentMetadata(root, id);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-    }
-    if (record)
-        await resolveLibraryAttachment(root, id);
-    if (!record) {
-        const temporary = join(uploads, `.import-${randomUUID()}`);
-        const target = join(uploads, id);
-        await mkdir(temporary, { mode: 0o755 });
-        try {
-            for (const file of files) {
-                const parent = dirname(file.path);
-                if (parent !== '.')
-                    await safeDirectory(temporary, parent, true);
-                await writeFile(join(temporary, file.path), file.bytes, { flag: 'wx', mode: 0o644 });
-            }
-            const prefix = `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}`;
-            record = {
-                id, name: asset.kind === 'file' ? files[0].path.split('/').at(-1) : asset.name,
-                kind: asset.kind, size,
-                mimeType: asset.kind === 'file' ? files[0].mimeType : 'application/vnd.playcraft.asset-bundle',
-                path: asset.kind === 'file' ? `${prefix}/${files[0].path}` : prefix,
-                origin: { kind: 'asset-library', assetId: asset.assetId, name: asset.name,
-                    libraryPath: asset.libraryPath, visibility: asset.visibility, teamId: asset.teamId,
-                    contentHash, importedAt: new Date().toISOString() },
-                files: files.map(file => ({ path: file.path, size: file.bytes.length, mimeType: file.mimeType, sha256: file.sha256 })),
-                sessionIds: [], unbound: !sessionId, clientRequestIds: [],
-            };
-            // Publish the complete directory before making the source visible through its metadata.
-            let alreadyPublished = false;
-            try {
-                await safeDirectory(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}`);
-                for (const file of record.files) {
-                    const opened = await openLibraryAttachmentFile(root, record, file.path);
-                    try {
-                        if (hash(await opened.handle.readFile()) !== file.sha256)
-                            throw new Error('library_asset_changed');
-                    }
-                    finally {
-                        await opened.handle.close();
-                    }
-                }
-                alreadyPublished = true;
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-                // A pre-existing incomplete directory must not be overwritten by a retry.
-                try {
-                    await lstat(target);
-                    throw new Error('invalid_library_attachment');
-                }
-                catch (targetError) {
-                    if (targetError.code !== 'ENOENT')
-                        throw targetError;
-                }
-            }
-            if (alreadyPublished)
-                await rm(temporary, { recursive: true, force: true });
-            else
-                await rename(temporary, target);
-        }
-        catch (error) {
-            await rm(temporary, { recursive: true, force: true });
-            throw error;
-        }
-    }
-    record.sessionIds = [...new Set([...record.sessionIds, ...(sessionId ? [sessionId] : [])])];
-    record.clientRequestIds = [...new Set([...record.clientRequestIds, clientRequestId])];
-    record.unbound ||= !sessionId;
-    const tempMetadata = join(metadata, `.import-${randomUUID()}.json`);
-    await writeFile(tempMetadata, JSON.stringify(record), { flag: 'wx', mode: 0o644 });
-    await rename(tempMetadata, join(metadata, `${id}.json`));
-    await chmod(join(uploads, id), 0o755);
-    return publicAttachment(record);
-}
-export async function importWorkspaceLibraryAttachment(root, body) {
-    const previous = locks.get(root) ?? Promise.resolve();
-    const current = previous.catch(() => undefined).then(() => importAttachment(root, body));
-    locks.set(root, current);
-    try {
-        return await current;
-    }
-    finally {
-        if (locks.get(root) === current)
-            locks.delete(root);
-    }
-}
-export async function readLibraryAttachmentUpload(request) {
-    const chunks = [];
-    let size = 0;
-    const limit = 4 * Math.ceil(WORKSPACE_LIBRARY_ATTACHMENT_MAX_BYTES / 3) + 1024 * 1024;
-    for await (const chunk of request) {
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        size += bytes.length;
-        if (size > limit)
-            throw new Error('library_asset_too_large');
-        chunks.push(bytes);
-    }
-    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-}