@playcraft/cli 0.1.66 → 0.1.68

package/dist/workspace-runtime/workspaces/level-editor-history-store.js

@@ -0,0 +1,250 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, lstat, open, readdir, realpath, rename, rm } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { LevelEditorError, isLevelEditorJson, levelEditorTransactionRequestSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+const digest = (value) => createHash('sha256').update(value).digest('hex');
+const MAX_RECORD_BYTES = 16 * 1024 * 1024;
+const MAX_HISTORY_BYTES = 32 * 1024 * 1024;
+const MAX_HISTORY_RECORDS = 128;
+export async function readHistoryText(file) {
+    const stat = await lstat(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > MAX_RECORD_BYTES)
+        throw new LevelEditorError('level_editor_history_state_invalid');
+    const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const opened = await handle.stat();
+        if (opened.ino !== stat.ino || opened.dev !== stat.dev || opened.size !== stat.size)
+            throw new LevelEditorError('level_editor_history_state_invalid');
+        const bytes = Buffer.alloc(stat.size + 1);
+        let size = 0;
+        while (size < bytes.length) {
+            const read = await handle.read(bytes, size, bytes.length - size, null);
+            if (!read.bytesRead)
+                break;
+            size += read.bytesRead;
+        }
+        if (size !== stat.size)
+            throw new LevelEditorError('level_editor_history_state_invalid');
+        const text = bytes.subarray(0, size).toString('utf8');
+        if (Buffer.byteLength(text) !== size)
+            throw new LevelEditorError('level_editor_history_state_invalid');
+        return text;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function assertLevelEditorHistoryScope(context) {
+    const { state } = context;
+    const operation = 'operation' in context
+        ? context.operation
+        : {
+            environment: state.config.environment,
+            userId: state.config.userId,
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            workspaceId: context.workspaceId,
+            directoryName: context.directoryName,
+        };
+    if (operation.environment !== state.config.environment ||
+        operation.userId !== state.config.userId ||
+        operation.generation !== state.config.generation ||
+        operation.runtimeEpoch !== state.runtimeEpoch ||
+        operation.directoryName === 'root' ||
+        (!operation.workspaceId && state.config.workspaceMode === 'multi'))
+        throw new LevelEditorError('level_editor_history_scope_invalid');
+}
+export async function historyDirectory(root, context) {
+    assertLevelEditorHistoryScope(context);
+    const { state } = context;
+    const operation = 'operation' in context ? context.operation : context;
+    const requested = resolve(state.config.stateDir, 'level-editor-history');
+    const project = await realpath(root);
+    let ancestor = requested;
+    const missing = [];
+    for (;;) {
+        try {
+            ancestor = await realpath(ancestor);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            missing.unshift(basename(ancestor));
+            ancestor = dirname(ancestor);
+        }
+    }
+    const anticipated = relative(project, join(ancestor, ...missing));
+    if (!isAbsolute(anticipated) && anticipated !== '..' && !anticipated.startsWith(`..${sep}`))
+        throw new LevelEditorError('level_editor_history_state_not_private');
+    // private
+    await mkdir(requested, { recursive: true, mode: 0o700 });
+    if ((await lstat(requested)).isSymbolicLink())
+        throw new LevelEditorError('level_editor_history_state_invalid');
+    const parent = await realpath(requested);
+    const rel = relative(project, parent);
+    if (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`))
+        throw new LevelEditorError('level_editor_history_state_not_private');
+    const scope = [
+        state.config.environment,
+        state.config.userId,
+        state.config.runtimeId,
+        operation.workspaceId ?? 'local',
+        operation.directoryName ?? 'basic',
+        state.config.generation,
+        state.runtimeEpoch,
+    ];
+    const directory = join(parent, digest(JSON.stringify(scope)));
+    // private
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new LevelEditorError('level_editor_history_state_invalid');
+    return directory;
+}
+/** The digest is a filename only; the exact original request remains part of the checked record. */
+export async function readLevelEditorHistory(root, context, requestId) {
+    const file = join(await historyDirectory(root, context), `${digest(requestId)}.json`);
+    try {
+        const value = JSON.parse(await readHistoryText(file));
+        const request = levelEditorTransactionRequestSchema.parse(value.request);
+        if (request.requestId !== requestId ||
+            value.requestDigest !== digest(JSON.stringify(request)) ||
+            (value.phase !== 'prepared' && value.phase !== 'confirmed') ||
+            !isLevelEditorJson(value.before) ||
+            !isLevelEditorJson(value.after) ||
+            (request.version === 1 && value.documentId !== request.documentId) ||
+            (request.version === 2 && !value.batch) ||
+            !/^[a-f0-9]{64}$/.test(value.contentHash) ||
+            !Number.isSafeInteger(value.size) ||
+            value.size < 0 ||
+            typeof value.path !== 'string' ||
+            JSON.stringify(value.command) !==
+                JSON.stringify(request.version === 1
+                    ? {
+                        commandId: request.commandId,
+                        selection: request.selection,
+                        input: request.input,
+                    }
+                    : request.commands[0]))
+            throw new LevelEditorError('level_editor_history_state_invalid');
+        if (value.batch) {
+            const batch = value.batch;
+            if (request.version !== 2 ||
+                JSON.stringify(batch.commands) !== JSON.stringify(request.commands) ||
+                !Array.isArray(batch.documents) ||
+                !batch.documents.length ||
+                !Array.isArray(batch.files) ||
+                batch.files.length !== batch.documents.length ||
+                !batch.baselines ||
+                typeof batch.baselines !== 'object' ||
+                Array.isArray(batch.baselines) ||
+                typeof batch.operationId !== 'string' ||
+                !batch.operationId ||
+                batch.operationId.length > 256 ||
+                JSON.stringify(Object.keys(batch.baselines).sort()) !==
+                    JSON.stringify(Object.keys(request.expectedDocuments).sort()) ||
+                Object.entries(batch.baselines).some(([id, baseline]) => !baseline ||
+                    !workspaceRelativePathSchema.safeParse(baseline.path).success ||
+                    baseline.contentHash !== request.expectedDocuments[id]?.contentHash ||
+                    baseline.revision !== request.expectedDocuments[id]?.revision) ||
+                new Set(batch.files.map((file) => file.documentId)).size !== batch.files.length ||
+                new Set(batch.documents.map((item) => item.documentId)).size !== batch.documents.length ||
+                batch.documents.some((item) => typeof item.documentId !== 'string' ||
+                    !isLevelEditorJson(item.before) ||
+                    !isLevelEditorJson(item.after)) ||
+                batch.files.some((file) => !workspaceRelativePathSchema.safeParse(file.path).success ||
+                    typeof file.beforeBytes !== 'string' ||
+                    typeof file.afterBytes !== 'string' ||
+                    file.path !== batch.baselines[file.documentId]?.path ||
+                    file.revision !== batch.baselines[file.documentId].revision + 1 ||
+                    !Number.isSafeInteger(file.size) ||
+                    file.size < 0 ||
+                    !/^[a-f0-9]{64}$/.test(file.contentHash) ||
+                    Buffer.from(file.beforeBytes, 'base64').toString('base64') !== file.beforeBytes ||
+                    Buffer.from(file.afterBytes, 'base64').toString('base64') !== file.afterBytes ||
+                    digest(Buffer.from(file.beforeBytes, 'base64').toString('utf8')) !==
+                        batch.baselines[file.documentId]?.contentHash ||
+                    digest(Buffer.from(file.afterBytes, 'base64').toString('utf8')) !== file.contentHash ||
+                    Buffer.from(file.afterBytes, 'base64').length !== file.size ||
+                    !batch.documents.some((item) => item.documentId === file.documentId)))
+                throw new LevelEditorError('level_editor_history_state_invalid');
+        }
+        return { ...value, request };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        if (error instanceof LevelEditorError)
+            throw error;
+        throw new LevelEditorError('level_editor_history_state_invalid');
+    }
+}
+export const levelEditorHistoryRequestDigest = (request) => digest(JSON.stringify(request));
+async function reserveHistoryCapacity(directory, destination, bytes, referenced) {
+    const records = [];
+    for (const name of await readdir(directory)) {
+        if (!/^[a-f0-9]{64}\.json$/.test(name))
+            continue;
+        const path = join(directory, name), stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > MAX_RECORD_BYTES)
+            throw new LevelEditorError('level_editor_history_state_invalid');
+        records.push({ path, size: stat.size, time: stat.mtimeMs });
+    }
+    let total = records.reduce((sum, item) => sum + (item.path === destination ? 0 : item.size), bytes);
+    let count = records.length + (records.some((item) => item.path === destination) ? 0 : 1);
+    if (count <= MAX_HISTORY_RECORDS && total <= MAX_HISTORY_BYTES)
+        return;
+    const candidates = [];
+    for (const item of records) {
+        if (item.path === destination || item.path === referenced)
+            continue;
+        const old = JSON.parse(await readHistoryText(item.path));
+        if (old.phase === 'confirmed')
+            candidates.push({ ...item, inverse: Boolean(old.request?.history) });
+    }
+    // Preserve original undo sources ahead of metadata for already-observed inverse requests.
+    for (const item of candidates.sort((left, right) => Number(right.inverse) - Number(left.inverse) || left.time - right.time)) {
+        if (count <= MAX_HISTORY_RECORDS && total <= MAX_HISTORY_BYTES)
+            break;
+        await rm(item.path);
+        total -= item.size;
+        count--;
+    }
+    if (count > MAX_HISTORY_RECORDS || total > MAX_HISTORY_BYTES)
+        throw new LevelEditorError('level_editor_history_budget');
+}
+/** Prepared evidence is durable before the engineering file is replaced. */
+export async function writeLevelEditorHistory(root, context, value) {
+    const directory = await historyDirectory(root, context);
+    const text = JSON.stringify(value);
+    if (Buffer.byteLength(text) > MAX_RECORD_BYTES)
+        throw new LevelEditorError('level_editor_history_budget');
+    const temporary = join(directory, `.${randomUUID()}.tmp`), destination = join(directory, `${digest(value.request.requestId)}.json`);
+    await reserveHistoryCapacity(directory, destination, Buffer.byteLength(text), value.request.history
+        ? join(directory, `${digest(value.request.history.requestId)}.json`)
+        : undefined);
+    try {
+        // private
+        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            await handle.writeFile(text);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, destination);
+        const parent = await open(directory, constants.O_RDONLY);
+        try {
+            await parent.sync();
+        }
+        finally {
+            await parent.close();
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/workspace-runtime/workspaces/level-editor-json5.js

@@ -0,0 +1,132 @@
+import JSON5 from 'json5';
+import { LevelEditorError, levelEditorCanonicalJson } from '@playcraft/common/cloud-workspace/runtime';
+/** Keep untouched author bytes; refuse structural replacement that would discard authored comments. */
+export function editLevelEditorJson5(source, changes, expected) {
+    JSON5.parse(source);
+    let output = source;
+    for (const change of changes) {
+        const root = tree(output);
+        let span = root;
+        let parent;
+        for (const key of change.path) {
+            parent = span;
+            span = span?.children?.get(key);
+        }
+        if (!span || change.op === 'remove') {
+            if (!parent || parent.commented)
+                throw new LevelEditorError('level_editor_comment_preservation_required');
+            const value = JSON5.parse(output.slice(parent.start, parent.end));
+            const key = change.path.at(-1);
+            if (change.op === 'remove') {
+                if (Array.isArray(value) && typeof key === 'number')
+                    value.splice(key, 1);
+                else
+                    delete value[key];
+            }
+            else
+                value[key] = change.value;
+            output = output.slice(0, parent.start) + JSON.stringify(value) + output.slice(parent.end);
+        }
+        else {
+            if (span.commented)
+                throw new LevelEditorError('level_editor_comment_preservation_required');
+            output = output.slice(0, span.start) + JSON.stringify(change.value) + output.slice(span.end);
+        }
+    }
+    if (levelEditorCanonicalJson(JSON5.parse(output)) !== levelEditorCanonicalJson(expected))
+        throw new LevelEditorError('level_editor_serialization_mismatch');
+    return output;
+}
+function tree(source) {
+    let cursor = 0;
+    let comments = 0;
+    function trivia() {
+        for (;;) {
+            while (/\s/.test(source[cursor] ?? '') && cursor < source.length)
+                cursor++;
+            if (source.slice(cursor, cursor + 2) === '//') {
+                comments++;
+                cursor = source.indexOf('\n', cursor + 2);
+                if (cursor < 0)
+                    cursor = source.length;
+            }
+            else if (source.slice(cursor, cursor + 2) === '/*') {
+                comments++;
+                const end = source.indexOf('*/', cursor + 2);
+                if (end < 0)
+                    throw new LevelEditorError('level_editor_invalid_json');
+                cursor = end + 2;
+            }
+            else
+                break;
+        }
+    }
+    function quoted() {
+        const quote = source[cursor++];
+        while (cursor < source.length) {
+            const char = source[cursor++];
+            if (char === '\\')
+                cursor++;
+            else if (char === quote)
+                return;
+        }
+        throw new LevelEditorError('level_editor_invalid_json');
+    }
+    function value(depth) {
+        if (depth > 64)
+            throw new LevelEditorError('level_editor_document_budget');
+        trivia();
+        const start = cursor, before = comments;
+        const first = source[cursor];
+        let children;
+        if (first === '{' || first === '[') {
+            children = new Map();
+            cursor++;
+            trivia();
+            let index = 0;
+            const close = first === '{' ? '}' : ']';
+            while (source[cursor] !== close) {
+                if (cursor >= source.length)
+                    throw new LevelEditorError('level_editor_invalid_json');
+                let key = index++;
+                if (first === '{') {
+                    const keyStart = cursor;
+                    if (source[cursor] === '"' || source[cursor] === "'")
+                        quoted();
+                    else
+                        while (cursor < source.length && !/[\s:]/.test(source[cursor]))
+                            cursor++;
+                    key = Object.keys(JSON5.parse(`{${source.slice(keyStart, cursor)}:null}`))[0];
+                    trivia();
+                    if (source[cursor++] !== ':')
+                        throw new LevelEditorError('level_editor_invalid_json');
+                }
+                if (children.has(key))
+                    throw new LevelEditorError('level_editor_duplicate_json_member');
+                children.set(key, value(depth + 1));
+                trivia();
+                if (source[cursor] === ',') {
+                    cursor++;
+                    trivia();
+                }
+                else if (source[cursor] !== close)
+                    throw new LevelEditorError('level_editor_invalid_json');
+            }
+            cursor++;
+        }
+        else if (first === '"' || first === "'")
+            quoted();
+        else {
+            while (cursor < source.length && !/[\s,\]}]/.test(source[cursor]) && source[cursor] !== '/')
+                cursor++;
+        }
+        if (cursor === start)
+            throw new LevelEditorError('level_editor_invalid_json');
+        return { start, end: cursor, children, commented: comments !== before };
+    }
+    const root = value(0);
+    trivia();
+    if (cursor !== source.length)
+        throw new LevelEditorError('level_editor_invalid_json');
+    return root;
+}